集合

之前看到的列表和字符串都是一种有序序列，而集合是一种无序的序列。

因为集合是无序的，所以当集合中存在两个同样的元素的时候，Python 只会保存其中的一个（唯一性）；同时为了确保其中不包含同样的元素，集合中放入的元素只能是不可变的对象（确定性）。

集合生成

可以用 set() 函数来显示的生成空集合：

a = set()

				

					
				
				

					
				
				

					
				
				

					
				
			

type(a)

				

					
				
				

					
				
				

					
				
				

					
				
			

set

				

					
				
				

					
				
				

					
				
				

					
				
			

也可以使用一个列表来初始化一个集合：

a = set([1, 2, 3, 1])

				

					
				
				

					
				
				

					
				
				

					
				
			

a

				

					
				
				

					
				
				

					
				
				

					
				
			

{1, 2, 3}

				

					
				
				

					
				
				

					
				
				

					
				
			

集合会自动去除重复元素 1。

集合中的元素是用大括号 {} 包含起来的，这意味着可以用 {} 的形式来创建集合：

a = {1, 2, 3, 1}

				

					
				
				

					
				
				

					
				
				

					
				
			

a

				

					
				
				

					
				
				

					
				
				

					
				
			

{1, 2, 3}

				

					
				
				

					
				
				

					
				
				

					
				
			

创建空集合的时候只能用 set() 函数来创建，因为在 Python 中 {} 创建的是一个空的字典：

s = {}

				

					
				
				

					
				
				

					
				
				

					
				
			

type(s)

				

					
				
				

					
				
				

					
				
				

					
				
			

dict

				

					
				
				

					
				
				

					
				
				

					
				
			

集合操作

a = {1, 2, 3, 4}

				

					
				
				

					
				
				

					
				
				

					
				
			

b = {3, 4, 5, 6}

				

					
				
				

					
				
				

					
				
				

					
				
			

两个集合的并，返回包含两个集合所有元素的集合（去除重复）。可以用方法 a.union(b) 或者操作 a | b 实现：

a.union(b)

				

					
				
				

					
				
				

					
				
				

					
				
			

{1, 2, 3, 4, 5, 6}

				

					
				
				

					
				
				

					
				
				

					
				
			

a | b

				

					
				
				

					
				
				

					
				
				

					
				
			

{1, 2, 3, 4, 5, 6}

				

					
				
				

					
				
				

					
				
				

					
				
			

两个集合的交，返回包含两个集合共有元素的集合。可以用方法 a.intersection(b) 或者操作 a & b 实现：

a.intersection(b)

				

					
				
				

					
				
				

					
				
				

					
				
			

{3, 4}

				

					
				
				

					
				
				

					
				
				

					
				
			

a & b

				

					
				
				

					
				
				

					
				
				

					
				
			

{3, 4}

				

					
				
				

					
				
				

					
				
				

					
				
			

b & a

				

					
				
				

					
				
				

					
				
				

					
				
			

{3, 4}

				

					
				
				

					
				
				

					
				
				

					
				
			

a 和 b 的差集，返回只在 a 不在 b 的元素组成的集合。可以用方法 a.difference(b) 或者操作 a - b 实现:

a - b

				

					
				
				

					
				
				

					
				
				

					
				
			

{1, 2}

				

					
				
				

					
				
				

					
				
				

					
				
			

b - a

				

					
				
				

					
				
				

					
				
				

					
				
			

{5, 6}

				

					
				
				

					
				
				

					
				
				

					
				
			

a.difference(b)

				

					
				
				

					
				
				

					
				
				

					
				
			

{1, 2}

				

					
				
				

					
				
				

					
				
				

					
				
			

b.difference(a)

				

					
				
				

					
				
				

					
				
				

					
				
			

{5, 6}

				

					
				
				

					
				
				

					
				
				

					
				
			

a 和 b 的对称差集，返回在 a 或在 b 中，但是不同时在 a 和 b 中的元素组成的集合。可以用方法 a.symmetric_difference(b) 或者操作 a ^ b 实现（异或操作符）：

a.symmetric_difference(b)

				

					
				
				

					
				
				

					
				
				

					
				
			

{1, 2, 5, 6}

				

					
				
				

					
				
				

					
				
				

					
				
			

b.symmetric_difference(a)

				

					
				
				

					
				
				

					
				
				

					
				
			

{1, 2, 5, 6}

				

					
				
				

					
				
				

					
				
				

					
				
			

b ^ a

				

					
				
				

					
				
				

					
				
				

					
				
			

{1, 2, 5, 6}

				

					
				
				

					
				
				

					
				
				

					
				
			

a ^ b

				

					
				
				

					
				
				

					
				
				

					
				
			

{1, 2, 5, 6}

				

					
				
				

					
				
				

					
				
				

					
				
			

包含关系

a = {1, 2, 3}

				

					
				
				

					
				
				

					
				
				

					
				
			

b = {1, 2}

				

					
				
				

					
				
				

					
				
				

					
				
			

.issubset() 方法或者 b <= a 判断子集：

b.issubset(a)

				

					
				
				

					
				
				

					
				
				

					
				
			

True

				

					
				
				

					
				
				

					
				
				

					
				
			

b <= a

				

					
				
				

					
				
				

					
				
				

					
				
			

True

				

					
				
				

					
				
				

					
				
				

					
				
			

与之对应，也可以用.issuperset() 方法或者 a >= b 来判断：

a.issuperset(b)

				

					
				
				

					
				
				

					
				
				

					
				
			

True

				

					
				
				

					
				
				

					
				
				

					
				
			

a >= b

				

					
				
				

					
				
				

					
				
				

					
				
			

True

				

					
				
				

					
				
				

					
				
				

					
				
			

操作符可以用来判断真子集：

b > a

				

					
				
				

					
				
				

					
				
				

					
				
			

False

				

					
				
				

					
				
				

					
				
				

					
				
			

a > b

				

					
				
				

					
				
				

					
				
				

					
				
			

True

				

					
				
				

					
				
				

					
				
				

					
				
			

集合方法

.add() 方法添加单个元素：

t = {1, 2, 3}

				

					
				
				

					
				
				

					
				
				

					
				
			

t.add(5)

				

					
				
				

					
				
				

					
				
				

					
				
			

t

				

					
				
				

					
				
				

					
				
				

					
				
			

{1, 2, 3, 5}

				

					
				
				

					
				
				

					
				
				

					
				
			

如果添加的是已有元素，集合不改变：

t.add(3)

				

					
				
				

					
				
				

					
				
				

					
				
			

t

				

					
				
				

					
				
				

					
				
				

					
				
			

{1, 2, 3, 5}

				

					
				
				

					
				
				

					
				
				

					
				
			

.update() 方法更新多个元素：

t.update([5, 6, 7])

				

					
				
				

					
				
				

					
				
				

					
				
			

t

				

					
				
				

					
				
				

					
				
				

					
				
			

{1, 2, 3, 5, 6, 7}

				

					
				
				

					
				
				

					
				
				

					
				
			

不可变集合

对应于元组与列表的关系，对于集合，Python 提供了一种叫做不可变集合的数据结构。

不可变集合使用 frozenset () 函数来进行创建：

s = frozenset([1, 2, 3, 'a', 1])

				

					
				
				

					
				
				

					
				
				

					
				
			

s

				

					
				
				

					
				
				

					
				
				

					
				
			

frozenset({1, 2, 3, 'a'})

				

					
				
				

					
				
				

					
				
				

					
				
			

与集合不同的是，不可变集合一旦创建就不可以改变。

不可变集合的一个主要应用是用来作为字典的键。例如，用一个字典来记录两个城市之间的距离：

flight_distance = {}
city_pair = frozenset(['Los Angeles', 'New York'])
flight_distance[city_pair] = 2498
flight_distance[frozenset(['Austin', 'Los Angeles'])] = 1233
flight_distance[frozenset(['Austin', 'New York'])] = 1515
flight_distance

				

					
				
				

					
				
				

					
				
				

					
				
			

{frozenset({'Los Angeles', 'New York'}): 2498,
 frozenset({'Austin', 'Los Angeles'}): 1233,
 frozenset({'Austin', 'New York'}): 1515}

				

					
				
				

					
				
				

					
				
				

					
				
			

由于集合不分顺序，所以不同顺序不会影响查阅结果：

flight_distance[frozenset(['New York','Austin'])]

				

					
				
				

					
				
				

					
				
				

					
				
			

1515

				

					
				
				

					
				
				

					
				
				

					
				
			

flight_distance[frozenset(['Austin','New York'])]

				

					
				
				

					
				
				

					
				
				

					
				
			

1515