【Python学习笔记】集合

• 概述
• 集合的一般操作
• 内建函数进行标准操作集合
• 数学运算符进行标准操作集合
• 集合的应用

　　概述

　　集合的创建使用关键字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‘]))

集合的一般操作

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

• 可变集合类型的方法和操作

　　集合操作符