《Python进阶系列》十一：集合（set and frozenset）语法汇总

集合的基本语法知识

目前有两种集合类型：set和frozenset。

可变集合：set()

set类型是可变的， 其内容可以使用 add() 和 remove() 这样的方法来改变，因为是可变的，所以没有哈希值，且不能被用作字典的键或其它集合的元素。 set构建除了使用set构造器，非空的set还可以通过将以逗号分隔的元素列表包含于花括号之内来创建。

set的构造器方法：

• set(iterable) :返回一个新的set对象，其元素来自于iterable。如果未指定 iterable，则将返回一个新的空集合。

可变集合类型的方法如下：

• s.update(t)：用t中的元素修改s，即，s现在包含s或t的成员。
• s.intersection_update(t)：s中的成员是共同属于s和t的元素。
• s.difference_update(t)：s中的成员是属于s但不包含在t中的元素。
• s.symmetric_difference_update(t)：s中的成员更新为那些包含在s或t中，但不是s和t共有的元素。
• s.add(obj)：在集合s中添加对象obj。
• s.remove(obj)：从集合s中删除对象obj；如果obj不是集合s中的元素，将引发KeyError错误。
• s.discard(obj)：如果obj是集合s``中的元素，从集合s中删除对象obj。
• s.pop()：删除集合s中的任意一个对象，并返回它。
• s.clear()：删除集合s中的所有元素。

注意事项：

1. 集合是一个无序的不重复的元素序列，能够去重复，删除重复项。
2. 空集合必须使用set()，因为{}是用来创建空字典。
3. set中的数据一定要是不可变数据，否则报错。如下：

>>> set([1, 2, [1, 34]])
Traceback (most recent call last):
  File "", line 1, in <module>
TypeError: unhashable type: 'list'
1
2
3
4

冻结集合：frozenset()

frozenset()方法返回一个不可变的frozenset对象，该对象使用给定iterable中的元素进行初始化。冻结集合（Frozen set）只是Python集合对象的不可变版本。 一个集合的元素可以随时修改，但是冻结集合的元素在创建后保持不变。因此，冻结集合可以用作Dictionary中的键或用作另一个集合的元素。 但是像集合一样，它也不是有序的。

frozenset()方法的语法为：

frozenset([iterable])
1

• iterable（可选）- 可迭代对象，它包含用于初始化frozenset的元素。可迭代对象可以是集合、字典、元组等。
• frozenset()方法返回一个不可变的frozenset，它使用给定iterable中的元素进行初始化。如果未传递任何参数，则返回一个空的frozenset。

例子1：传入一个元组。

>>> vowels = ('a', 'e', 'i', 'o', 'u')
>>> fSet = frozenset(vowels)
>>> fSet
frozenset({'o', 'u', 'i', 'e', 'a'})
>>> frozenset()
frozenset()
1
2
3
4
5
6

例子2：当将字典用作冻结集合的可迭代对象时, 只使用字典的键来创建集合。

>>> person = {"name": "John", "age": 23, "sex": "male"}
>>> fSet = frozenset(person)
>>> fSet
frozenset({'sex', 'age', 'name'})
1
2
3
4

例子3：如果想更改frozenset对象，则会引发错误

>>> favourite_subject = ["OS", "Data Base", "Algorithm"]
>>> f_subject = frozenset(favourite_subject)
>>> f_subject[1] = "Networking"
Traceback (most recent call last):
  File "", line 1, in <module>
TypeError: 'frozenset' object does not support item assignmen
1
2
3
4
5
6

例子4：验证set与frozenset的区别（add()函数）

>>> f_set = frozenset("hiekay") 
>>> f_set
frozenset(['h', 'i', 'e', 'k', 'a','y'])
>>> f_set.add("python")  # 报错，没有add方法
Traceback (most recent call last):
  File "", line 1, in <module>
AttributeError: 'frozenset' object has no attribute 'add'

######################################################################################

>>> a_set = set("github")  # 可以原处修改的set
>>> a_set
set(['b', 'g', 'i', 'h', 'u', 't'])
>>> a_set.add("python")
>>> a_set
set(['b', 'g', 'i', 'h', 'python', 'u', 't'])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

set与frozenset的区别

set（可变集合）与frozenset（不可变集合）的区别：

• set无序排序且不重复，是可变的，有add()，remove()等方法。既然是可变的，所以它不存在哈希值。基本功能包括关系测试和消除重复元素。集合对象还支持union（联合），intersection（交集），difference（差集）和sysmmetric_difference（对称差集）等数学运算。作为一个无序的集合，set不记录元素位置或者插入点。因此，set不支持indexing，或其它类序列的操作。
• frozenset是冻结的集合，它是不可变的，存在哈希值，好处是它可以作为字典的key，也可以作为其它集合的元素。缺点是一旦创建便不能更改，没有add，remove方法。

基本的集合运算

元素与集合的关系

属于

元素是否属于某个集合。

>>> aset
set(['h', 'o', 'n', 'p', 't', 'y'])
>>> "a" in aset
False
>>> "h" in aset
True
1
2
3
4
5
6

集合与集合的关系

集合相等

A是否等于B，即两个集合的元素完全一样。

>>> a = set("abcde")
>>> b = set("abfgh")
>>> a
set(['a', 'b', 'c', 'd', 'e'])
>>> b
set(['a', 'b', 'f', 'g', 'h'])
>>> a == b
False
>>> a != b
True
1
2
3
4
5
6
7
8
9
10

子集 / 超集

A是否是B的子集，或者反过来，B是否是A的超集。即A的元素也都是B的元素，但是B的元素比A的元素数量多。

>>> c = set("ab")
>>> a
set(['a', 'c', 'b', 'e', 'd'])
>>> c
set(['a', 'b'])
>>> c < a     # c是a的子集
True
>>> c.issubset(a)   # 或者用这种方法，判断c是否是a的子集
True
>>> a.issuperset(c) # 判断a是否是c的超集
True
 
>>> b
set(['a', 'h', 'b', 'g', 'f'])
>>> a < b     # a不是b的子集
False
>>> a.issubset(b)   # 或者这样做
False
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

并集

A、B的并集，即A、B所有元素
>>> a set(['a', 'c', 'b', 'e', 'd']) >>> b set(['a', 'h', 'b', 'g', 'f']) >>> a | b # 可以有两种方式，结果一样 set(['a', 'c', 'b', 'e', 'd', 'g', 'f', 'h']) >>> a.union(b) set(['a', 'c', 'b', 'e', 'd', 'g', 'f', 'h'])

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

交集

A、B的交集，即A、B所公有的元素

>>> a
set(['a', 'c', 'b', 'e', 'd'])
>>> b
set(['a', 'h', 'b', 'g', 'f'])
>>> a & b   # 两种方式，等价
set(['a', 'b'])
>>> a and b
set(['a', 'h', 'b', 'g', 'f'])
>>> a.intersection(b)
set(['a', 'b'])
1
2
3
4
5
6
7
8
9
10

差 / 补

A相对B的差（补），即A相对B不同的部分元素。差符号有一个等价的方法：difference()。

>>> a
set(['a', 'c', 'b', 'e', 'd'])
>>> b
set(['a', 'h', 'b', 'g', 'f'])
>>> a - b
set(['c', 'e', 'd'])
>>> a.difference(b)
set(['c', 'e', 'd'])
1
2
3
4
5
6
7
8

对称差

对称差分是集合的XOR（又称“异或”）。两个集合（A和B）的对称差分是指另外一个集合C，该集合中的元素，只能是属于集合A或者集合B的成员，不能同时属于两个集合。
对称差分有一个等价的方法：symmetric_difference()。

>>> a
set(['a', 'c', 'b', 'e', 'd'])
>>> b
set(['a', 'h', 'b', 'g', 'f'])
>>> a.symmetric_difference(b)
set(['c', 'e', 'd', 'g', 'f', 'h'])
1
2
3
4
5
6

混合集合类型操作

左边是可变集合，右边是不可变集合，运算符所产生的仍然是可变集合。但是如果左右操作数的顺序反过来，结果相反：

>>> fSet = frozenset(('a', 'e', 'i', 'o', 'u'))
>>> Set = {'a', 'c'}

>>> fSet | Set
frozenset({'c', 'o', 'u', 'i', 'e', 'a'})

>>> Set | fSet
{'c', 'o', 'u', 'i', 'e', 'a'}
1
2
3
4
5
6
7
8

如果左右两个操作数的类型相同， 即都是可变集合或不可变集合，则所产生的结果类型是相同的，但如果左右两个操作数的类型不相同（左操作数是set，右操作数是frozenset，或相反情况)，则所产生的结果类型与左操作数的类型相同。