Python3.7之集合
集合中的元素有三个特征：
1.互异性：由不同元素组成
2.无序性：如集合{3,4,5}和集合{3,5,4}算作同一个集合
3.集合中的元素必须是不可变类型（可hash）
一、集合的定义
1.集合的去重效果
>>> L = {1,2,3,1}
>>> L
{1, 2, 3}
2.定义可变集合（注意集合具有无序性）
>>> set_test=set('hello')
>>> set_test
{'l', 'o', 'e', 'h'}
3.定义不可变集合frozenset
>>> f_set_test=frozenset(set_test)
>>> f_set_test
frozenset({'l', 'o', 'e', 'h'})
二、集合的关系运算
1.子集
子集，为某个集合中一部分的集合，故亦称部分集合。
使用操作符 < 执行子集操作，同样地，也可使用方法 issubset() 完成。
>>> A = set('abcd')
>>> B = set('cdef')
>>> C = set("ab")
>>> C < A
True # C 是 A 的子集
>>> C < B
False
>>> C.issubset(A)
True
2.并集
一组集合的并集是这些集合的所有元素构成的集合，而不包含其他元素。
使用操作符 | 执行并集操作，同样地，也可使用方法 union() 完成。
>>> A | B
{'c', 'b', 'f', 'd', 'e', 'a'}
>>> A.union(B)
{'c', 'b', 'f', 'd', 'e', 'a'}
3.交集
两个集合 A 和 B 的交集是含有所有既属于 A 又属于 B 的元素，而没有其他元素的集合。
使用 & 操作符执行交集操作，同样地，也可使用方法 intersection() 完成。
>>> A & B
{'c', 'd'}
>>> A.intersection(B)
{'c', 'd'}
4.差集
A 与 B 的差集是所有属于 A 且不属于 B 的元素构成的集合
使用操作符 - 执行差集操作，同样地，也可使用方法 difference() 完成。
A - B
{'b', 'a'}
A.difference(B)
{'b', 'a'}
5.对称差
两个集合的对称差是只属于其中一个集合，而不属于另一个集合的元素组成的集合。
使用 ^ 操作符执行差集操作，同样地，也可使用方法 symmetric_difference() 完成。
A ^ B
{'b', 'f', 'e', 'a'}
A.symmetric_difference(B)
{'b', 'f', 'e', 'a'}
三、集合方法
1. add
向集合中添加元素
s = {1, 2, 3, 4, 5, 6}
s.add("s")
s
{1, 2, 3, 4, 5, 6, 's'}
2. clear
清空集合
s = {1, 2, 3, 4, 5, 6}
s.clear()
s
set()
3. copy
返回集合的浅拷贝
s = {1, 2, 3, 4, 5, 6}
new_s = s.copy()
new_s
{1, 2, 3, 4, 5, 6}
4. pop
删除并返回任意的集合元素（如果集合为空，会引发 KeyError）
s = {1, 2, 3, 4, 5, 6}
s.pop() # pop删除时是无序的随机删除
1
s
{2, 3, 4, 5, 6}
5. remove
删除集合中的一个元素（如果元素不存在，会引发 KeyError）
s = {1, 2, 3, 4, 5, 6}
s.remove(3)
s
{1, 2, 4, 5, 6}
6.discard
删除集合中的一个元素（如果元素不存在，则不执行任何操作）
s = {1, 2, 3, 4, 5, 6}
s.discard("sb")
s
{1, 2, 3, 4, 5, 6}
7.intersection
将两个集合的交集作为一个新集合返回
s = {1, 2, 3, 4, 5, 6}
s2 = {3, 4, 5, 6, 7, 8}
s.intersection(s2)
{3, 4, 5, 6}
s&s2 # 可以达到相同的效果
{3, 4, 5, 6}
8.union
集合的并集作为一个新集合返回
s = {1, 2, 3, 4, 5, 6}
s2 = {3, 4, 5, 6, 7, 8}
print(s.union(s2))
{1, 2, 3, 4, 5, 6, 7, 8}
print(s|s2) # 用 | 可以达到相同效果
{1, 2, 3, 4, 5, 6, 7, 8}
9.difference
将两个或多个集合的差集作为一个新集合返回
s = {1, 2, 3, 4, 5, 6}
s2 = {3, 4, 5, 6, 7, 8}
print("差集:",s.difference(s2)) # 去除s和s2中相同元素，删除s2 保留s中剩余元素
差集: {1, 2}
print("差集:",s2.difference(s)) # 去除s和s2中相同元素，删除s2 保留s2中剩余元素<br>
差集: {8, 7}
print("差集:",s - s2) # 符号 - 可以达到相同结果
差集: {1, 2}
print("差集:",s2 - s) # 符号 - 可以达到相同结果
差集: {8, 7}
10. symmetric_difference
将两个集合的对称差作为一个新集合返回(两个集合合并删除相同部分，其余保留)
s = {1, 2, 3, 4, 5, 6}
s2 = {3, 4, 5, 6, 7, 8}
s.symmetric_difference(s2)
{1, 2, 7, 8}
11. update
用自己和另一个的并集来更新这个集合
s = {'p', 'y'}
s.update(['t', 'h', 'o', 'n']) # 添加多个元素
s
{'p', 't', 'o', 'y', 'h', 'n'}
s.update(['H', 'e'], {'l', 'l', 'o'}) # 添加列表和集合
s
{'p', 'H', 't', 'l', 'o', 'y', 'e', 'h', 'n'}
12. intersection_update()
用自己和另一个的交集来更新这个集合
s = {'a', 'b', 'c', 'd', 'q'}
s2 = {'c', 'd', 'e', 'f'}
s.intersection_update(s2) # 相当于s = s - s2
s
{'c', 'd'}
13. isdisjoint()
如果两个集合有一个空交集，返回 True
s = {1, 2}
s1 = {3, 4}
s2 = {2, 3}
s.isdisjoint(s1)
True # s 和 s1 两个集合的交集为空返回 True
s.isdisjoint(s2)
False # s 和 s2 两个集合的交集为 2 不是空 所有返回False
14. issubset()
如果另一个集合包含这个集合，返回 True
s = {1, 2, 3}
s1 = {1, 2, 3, 4}
s2 = {2, 3}
s.issubset(s1)
True # 因为 s1 集合 包含 s 集合
s.issubset(s2)
False # s2 集合 不包含 s 集合
15. issuperset()
如果这个集合包含另一个集合，返回 True
s = {1, 2, 3}
s1 = {1, 2, 3, 4}
s2 = {2, 3}
s.issuperset(s1)
False # s 集合不包含 s1 集合
s.issuperset(s2)
True # s 集合包含 s2 集合
16. difference_update()
从这个集合中删除另一个集合的所有元素
s = {1, 2, 3}
s1 = {1, 2, 3, 4}
s2 = {2, 3}
s.difference_update(s2)
s
{1} # s2中的2,3 s集合中也有2,3 所以保留1
s1.difference_update(s2)
s1
{1, 4}
17. symmetric_difference_update()
用自己和另一个的对称差来更新这个集合
s = {1, 2, 3}
s1 = {1, 2, 3, 4}
s2 = {2, 3}
s1.symmetric_difference_update(s)
s1
{4}
s1.symmetric_difference_update(s2)
s1
{2, 3, 4}
s.symmetric_difference_update(s2)
s
{1}
