集合概述
集合是由具有唯一性的可哈希对象（一个对象的哈希值如果在其生命周期内绝不改变）组成的无序多项集。
目前有两种内置集合类型，set 和 frozenset，前者是可变类型，后者是不可变类型。
type({1}), type(frozenset())
(set, frozenset)
因为一对花括号表示字典而非集合，所以创建空集合必须使用构造函数 set() 和 frozenset() 来表示。两个内置函数还可将可迭代对象转换为集合：
type({}), set(), frozenset()
(dict, set(), frozenset())
set('121'), frozenset('112')
({'1', '2'}, frozenset({'1', '2'}))
构造 set 集合还可以直接使用一对花括号包含元素，元素之间用逗号隔开：
{1, 2}
集合的元素必须是可哈希的，例如字符串，元组（不能包含不可哈希对象，例如元组里有列表）；也是唯一的，同时存在多个哈希值相等的元素，只保留一个。
print(hash(False),hash(0))
0 0
{(1, 2), '12', False}
set 类型集合是可变类型，没有哈希值，不可作为集合的元素或字典的键，而 frozenset 类型的集合可以：
{frozenset({1, 2})}
两种类型集合可进行比较，并集，交集，差集，对称差集操作：
{1,2} == frozenset({1,2})
True
{1,2} | frozenset({1,2,3})
{1, 2, 3}
frozenset({1,2,3}) ^ {1,2}
frozenset({3})
set 类型是可变的，还可进行元素增、删、改，等操作，而 frozenset 类型不可以：
a = set()
print(id(a))
# a 增加元素 1
a.add(1)
print(id(a),a)
# 将一个集合并入 a
a |= frozenset({1,2,3})
print(id(a),a)
# 清空集合 a
a.clear()
print(id(a),a)
2029775797832
2029775797832 {1}
2029775797832 {1, 2, 3}
2029775797832 set()
集合是按哈希值对元素进行储存，而不是按顺序，因此集合没有索引和切片操作。搜索元素时，由于是通过哈希值匹配，集合比序列类型效率高。
由于集合仅定义了部分排序（子集关系），比较大小的排序并无定义。
True
a = [{2,1,5},{9},{6},{2,5}]
a.sort()
a
[{1, 2, 5}, {9}, {6}, {2, 5}]
set.isdisjoint 交集为空吗？
集合方法 set.isdisjoint()，Python 官方文档描述如下：
Help on method_descriptor:
isdisjoint(...)
Return True if two sets have a null intersection.
两个集合的交集为空，则返回 True。方法中的参数可以是可迭代对象。
False
True
{1,2}.isdisjoint('12') # 参数是字符串而非数字
True
set.issubset 是子集吗？
集合方法 set.issubset()，Python 官方文档描述如下：
Help on method_descriptor:
issubset(...)
Report whether another set contains this set.
检查一个集合中的元素，是否都在另一个集合中。相当于 a <= b（a，b 是两个集合），但方法中的参数可以是可迭代对象。
True
True
True
该方法检查是否是子集，而对于真子集，可以使用 < 进行检查：
False
True
set.issuperset 是超集吗？
集合方法 set.issuperset()，Python 官方文档描述如下：
Help on method_descriptor:
issuperset(...)
Report whether this set contains another set.
检查一个集合是否是另一个集合的超集。相当于 a >= b（a，b 是两个集合），但方法中的参数可以是可迭代对象。
{1,2}.issuperset({True:'1',2:'2'})
True
True
对于真超集，使用 > 进行检查：
True
False
set.union 并集
集合方法 set.union()，Python 官方文档描述如下：
Help on method_descriptor:
union(...)
Return the union of sets as a new set.
(i.e. all elements that are in either set.)
该方法接收任意的位置参数，返回一个所有集合的元素组成的新集合。相当于 a | b | … （a，b 是集合），但方法中的参数可以是可迭代对象。
{1, 2, 3, 4}
{1, 2, 3, 4}
set.intersection 交集
集合方法 set.intersection()，Python 官方文档描述如下：
Help on method_descriptor:
intersection(...)
Return the intersection of two sets as a new set.
(i.e. all elements that are in both sets.)
该方法接收任意的位置参数，返回一个所有集合中共有的元素组成的新集合。相当于 a & b & … （a，b 是集合），但方法中的参数可以是可迭代对象。
{1,2,3}.intersection({3,4},[1,5,3])
{3}
{1,2,3} & {3,4} & {1,5,3}
{3}
set.difference 差集
集合方法 set.difference()，Python 官方文档描述如下：
Help on method_descriptor:
difference(...)
Return the difference of two or more sets as a new set.
(i.e. all elements that are in this set but not the others.)
该方法接收任意的位置参数，返回一个集合在其他所有集合中都不存在的元素组成的新集合。相当于 a - b - … （a，b 是集合），但方法的参数可以是可迭代对象。
{1,2,3,4}.difference((2,1,5),{6,2,4})
{3}
{1,2,3,4} - {2,1,5} - {6,2,4}
{3}
set.symmetric_difference 对称差
集合方法 set.symmetric_difference()，Python 官方文档描述如下：
help(set.symmetric_difference)
Help on method_descriptor:
symmetric_difference(...)
Return the symmetric difference of two sets as a new set.
(i.e. all elements that are in exactly one of the sets.)
返回两个集合中非共同元素组成的新集合。相当于 a ^ b（a，b 是集合），但方法的参数可以是可迭代对象。
{1,2,3}.symmetric_difference([2,3,4])
{1, 4}
{1, 4}
set.copy 浅拷贝
集合方法 set.copy()，Python 官方文档描述如下：
Help on method_descriptor:
copy(...)
Return a shallow copy of a set.
返回集合的一个浅拷贝。
a = {1,2}
print(id(a),a)
b = a.copy()
id(b),b
2091426558696 {1, 2}
(2091426559368, {1, 2})
set.update 合并更新
集合方法 set.update()，Python 官方文档描述如下：
Help on method_descriptor:
update(...)
Update a set with the union of itself and others.
该方法接收任意的位置参数，将其他集合的元素合并到一个集合中。相当于 a |= b | … （a，b 是集合），但方法的参数可以是可迭代对象。
a = {1,2}
a.update([3],(4,5))
a
{1, 2, 3, 4, 5}
a = {1,2}
a |= {3} | {4,5}
a
{1, 2, 3, 4, 5}
该方法是一个过程，就地修改集合，返回值为 None。
a = {1,2}
b = a.update([3],(4,5))
print(b)
None
set.intersection_update 交集更新
集合方法 set.intersection_update()，Python 官方文档描述如下：
help(set.intersection_update)
Help on method_descriptor:
intersection_update(...)
Update a set with the intersection of itself and another.
该方法接收任意的位置参数，更新集合，只保留在其他所有集合中都存在的元素。相当于 a &= b & …（a，b 是集合），但方法的参数可以是可迭代对象。
a = {1,2,3,4}
a.intersection_update((1,2,5),{1,3,5})
a
{1}
a = {1,2,3,4}
a &= {1,2,5} & {1,3,5}
a
{1}
该方法是一个过程，就地修改集合，返回值为 None。
a = {1,2,3,4}
b = a.intersection_update()
print(b)
None
set.difference_update 差集更新
集合方法 set.difference_update()，Python 官方文档描述如下：
help(set.difference_update)
Help on method_descriptor:
difference_update(...)
Remove all elements of another set from this set.
该方法接收任意的位置参数，更新集合，移除在其他集合中也存在的元素。相当于 a -= b | …（a，b 是集合），但方法的参数可以是可迭代对象。
a = {1,2,3,4}
a.difference_update((1,3,5),[4,5])
a
{2}
a = {1,2,3,4}
a -= {1,3,5} | {4,5}
a
{2}
该方法是一个过程，就地修改集合，返回值为 None。
a = {1,2,3,4}
b = a.difference_update([4,5])
print(b)
None
set ^= other 对称差集更新
集合的对称差集更新操作，相当于集合方法 set.symmetric_difference_update，其文档描述如下：
help(set.symmetric_difference_update)
Help on method_descriptor:
symmetric_difference_update(...)
Update a set with the symmetric difference of itself and another.
更新集合，只保留两个集合中非共同部分。
a = {1,2,3}
a.symmetric_difference_update([2,3,4])
a
{1, 4}
a = {1,2,3}
a ^= {2,3,4}
a
{1, 4}
该方法是一个过程，就地修改集合，返回值为 None。
a = {1,2,3}
b = a.symmetric_difference_update([2,3,4])
print(b)
None
set.add 添加元素
集合方法 set.add()，Python 官方文档描述如下：
Help on method_descriptor:
add(...)
Add an element to a set.
This has no effect if the element is already present.
集合中增加一个元素，如果元素已经存在，没有任何影响。
{1, 2, 3}
{1, 2}
该方法是一个过程，就地修改集合，返回值为 None。
a = {1,2}
b = a.add(3)
print(b)
None
set.remove 删除元素
集合方法 set.remove()，Python 官方文档描述如下：
Help on method_descriptor:
remove(...)
Remove an element from a set; it must be a member.
If the element is not a member, raise a KeyError.
删除一个指定元素，删除元素不存在则引发 KeyError。
{2}
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
<ipython-input-3-d0f57d460301> in <module>
1 a = {1,2}
----> 2 a.remove(3)
3 a
KeyError: 3
该方法是一个过程，就地修改集合，返回值为 None。
a = {1,2}
b = a.remove(1)
print(b)
None
set.discard 删除元素
集合方法 set.discard()，Python 官方文档描述如下：
Help on method_descriptor:
discard(...)
Remove an element from a set if it is a member.
If the element is not a member, do nothing.
从集合中删除一个指定元素，元素不存在没有任何影响。
{2}
{1, 2}
该方法是一个过程，就地修改集合，返回值为 None。
a = {1,2}
b = a.discard(1)
print(b)
None
set.pop 删除元素并返回
集合方法 set.pop()，Python 官方文档描述如下：
Help on method_descriptor:
pop(...)
Remove and return an arbitrary set element.
Raises KeyError if the set is empty.
集合中删除任意一个元素，并返回它。如果集合为空，引发 KeyError。
1
{2}
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
<ipython-input-6-db3bab0ab3b8> in <module>
----> 1 set().pop()
KeyError: 'pop from an empty set'
set.clear 清空集合元素
集合方法 set.clear()，Python 官方文档描述如下：
Help on method_descriptor:
clear(...)
Remove all elements from this set.
清空集合所有元素。
set()
该方法是一个过程，就地修改集合，返回值为 None。
a = {1,2}
b = a.clear()
print(b)
None