【Python学习笔记】集合
- 概述
- 集合的一般操作
- 内建函数进行标准操作集合
- 数学运算符进行标准操作集合
- 集合的应用
概述
python的集合(set)是无序不重复元素集，是一种容器。集合(set)中的元素必须是不可变对象，即可用被哈希，这和字典的键是一样的，所以列表、字典等可变对象不可作为set的元素。集合不提供索引或切片操作，即对象不存在相关的键值。python中的集合分为两种：set是可变的集合，frozenset是不可变的集合。
集合的创建使用关键字set或frozenset， 参数可以是列表、字符串或元组等不可变对象。
- 可变集合set
>>> s1=set("abcdef") >>> s2=set(['a','b','c','d','e']) >>> s3=set(('a','b','c','d','e')) >>> s1,s2,s3 (set(['a', 'c', 'b', 'e', 'd', 'f']), set(['a', 'c', 'b', 'e', 'd']), set(['a', 'c', 'b', 'e', 'd']))
- 不可变集合frozenset
>>> fs1=frozenset([1,2,3]) >>> fs2=frozenset((1,2,3)) >>> fs3=frozenset("123") >>> fs1,fs2,fs3 (frozenset([1, 2, 3]), frozenset([1, 2, 3]), frozenset(['1', '3', '2']))
集合的一般操作
1. 获取集合元素
s=set([1,2,3,4,5])
L = len(s) #L=5
2. 获取集合的副本s.copy()
s.copy()获取到的副本和使用s1=s方式获得的集合是不一样的。s1=s得到的s1和s指向的是同一个集合，Python并没有为s1新开辟一块内存并把s拷贝过去，s1和s指向的是同一块内存。而s.copy()方式会在内存中新建一个set并把s的值拷贝过去。
>>> s=set([1,2,3]) >>> s1=s >>> s2=s.copy() >>> id(s),id(s1),id(s2) (40826920L, 40826920L, 40825800L)
从上面的例子中我们可以看到，s和s1的id是相同的，表明它们指向同一块内存，而s2的id则和它们不同.
3.增加元素s.add(item)
>>> s = set([1,2,3]) >>> s.add(4) >>> s set([1, 2, 3, 4])
4.随机删除元素s.pop()
s.pop()返回任意的集合元素，并将其从s中删除
set([1, 2, 3, 4]) >>> s = set([1,2,3]) >>> s.pop() 1 >>> s set([2, 3])
5.删除指定元素 s.remove(item)和s.discard(item)
s.remove(item)从s中删除item，如果item不是s的成员，则引发KeyError异常。
>>> s = set([1,2,3]) >>> s.remove(2) >>> s set([1, 3])
>>> s.remove(4)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 4
s.discard(item)删除item，如果s中不存在item，则没有效果,不会引发异常.
>>> s = set([1,2,3]) >>> s.discard(2) >>> s set([1, 3]) >>> s.discard(4) >>> s set([1, 3])
6.删除所有元素s.clear()
>>> s = set([1,2,3])
>>> s.clear()
7.更新集合s.update(t)
s.update(t)将t中的所有项添加到s中，t可以是另外一个集合、序列或支持迭代的任意对象，t也可以是字典，如果是字典的话则只是将字典的键加入到集合s中。
>>> s = set([1,2,3]) >>> t = set([4,5,6])
#t是集合 >>> s.update(t) >>> s set([1, 2, 3, 4, 5, 6])
#t是元组 >>> s.update((7,8,9)) >>> s set([1, 2, 3, 4, 5, 6, 7, 8, 9])
#t是列表 >>> s.update([10,11,12]) >>> s set([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
#t是字典 >>> s.update({"a":13,"b":14}) >>> s set([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 'a', 'b'])
8. 判断集合中是否存在某元素,in , not in
>>> s = set([1,2,3,4]) >>> 1 in s True
>>> 1 not in s False
使用内建函数操作集合
集合的标准操作包括集合的交集、并集、差集和对称差操作，下面举例解释下。
假设s=[1,2,3,4]，t=[3,4,5,6]
交集：既在s又在t中的元素, 操作结果为[3,4].
并集: s中或t中的元素,操作结果为[1,2,3,4,5,6].
差集: 只在s中的元素,操作结果为[1,2].
对称差：s中或t中的元素，但是不同在这两个集合中的元素.
子集：如果s的元素在t中都有，则s是t的子集.
超集: 如果s包含t中的所有元素，则s是t的超集合.
Python的集合操作的结果与最左边的操作数具有相同的类型，所以如果s是一个frozennet，而t是一个set，则结果将是frozennet。Python的集合操作可以使用集合的内建函数，也可以使用数学操作符。
由于Python的集合分为可变集合set和不可变集合frozenset两种，所以Python集合的内建函数的集合标准操作也分为两种。一种是set和frozenset都支持的，直接返回操作结果。另一种是仅set支持的操作，可以更改当前集合。
1. 不改变集合的标准操作
- s.intersection(t):交集.
- s.union(t)：并集.
- s.difference(t)：差集.
- s.symmetric_difference(t)：对称差.
- s.issubset(t):如果s是t的子集，返回True.
- s.issuperset(t):如果s是t的超集，返回True.
- d.isdisjoint(t):如果s和t没有共同项，则返回True
>>> s = set([1,2,3,4]);t = set([3,4,5,6])
#交集 >>> s.intersection(t) set([3, 4])
#并集 >>> s.union(t) set([1, 2, 3, 4, 5, 6])
#差集 >>> s.difference(t) set([1, 2])
#对称差 >>> s.symmetric_difference(t) set([1, 2, 5, 6])
#判断子集 >>> set([1,2]).issubset(s) True
#判断超集 >>> s.issuperset(set([1,2])) True
#判断有没有共同项 >>> s.isdisjoint(t) False
2. 改变集合的操作：
- s.intersection_update(t):交集
- s.difference_update(t)：差集
- s.symmetric_difference_update(t)：对称差
这三个函数会将操作的结果写入到集合s中。
>>> s = set([1,2,3,4]);t = set([3,4,5,6])
#交集 >>> s.intersection_update(t) >>> s set([3, 4])
#差集
>>> s.difference_update(t) >>> s set([1, 2])
#对称差 >>> s = set([1,2,3,4]);t = set([3,4,5,6]) >>> s.symmetric_difference_update(t) >>> s set([1, 2, 5, 6])
数学运算符进行标准操作集合
支持的数学运算符操作如下：
s | t : 并集
s & t : 交集
s - t: 差集
s ^ t: 对称差
s < t: 如果s是t的子集返回True,否则False.
s > t: 如果s是t的超集返回True，否则返回False.
s == t: s和t相等返回True,否则False.
>>> s = set([1,2,3,4]); t = set([3,4,5,6])
>>> s & t set([3, 4])
>>> s | t set([1, 2, 3, 4, 5, 6])
>>> s - t set([1, 2])
>>> s ^ t set([1, 2, 5, 6])
>>> set([1,2]) < s True
>>> t > set([3,4,5]) True
>>> s == t False
- 可变集合类型的方法和操作
集合操作符
集合的内建函数
集合的应用
