Section 8.1: 集合的操作

与其他sets

# 交集
{1, 2, 3, 4, 5}.intersection({3, 4, 5, 6}) # {3, 4, 5}
{1, 2, 3, 4, 5} & {3, 4, 5, 6} # {3, 4, 5}

# 并集
{1, 2, 3, 4, 5}.union({3, 4, 5, 6}) # {1, 2, 3, 4, 5, 6}
{1, 2, 3, 4, 5} | {3, 4, 5, 6} # {1, 2, 3, 4, 5, 6}

# 差异
{1, 2, 3, 4}.difference({2, 3, 5}) # {1, 4}
{1, 2, 3, 4} - {2, 3, 5} # {1, 4}

# 对称差分
{1, 2, 3, 4}.symmetric_difference({2, 3, 5}) # {1, 4, 5}
{1, 2, 3, 4} ^ {2, 3, 5} # {1, 4, 5}

# 父集检查
{1, 2}.issuperset({1, 2, 3}) # False
{1, 2} >= {1, 2, 3} # False

# 子集检查
{1, 2}.issubset({1, 2, 3}) # True
{1, 2} <= {1, 2, 3} # True

# 不相接检查
{1, 2}.isdisjoint({3, 4}) # True
{1, 2}.isdisjoint({1, 4}) # False

与单个元素

# 检查是否存在
2 in {1,2,3} # True
4 in {1,2,3} # False
4 not in {1,2,3} # True

# 添加和删除
s = {1,2,3}
s.add(4) # s == {1,2,3,4}
s.discard(3) # s == {1,2,4}
s.discard(5) # s == {1,2,4}
s.remove(2) # s == {1,4}
s.remove(2) # KeyError!

集合操作会返回新的集合，但有相应的对应的操作符：

例如：

s = {1, 2}
s.update({3, 4}) # s == {1, 2, 3, 4}

Section 8.2: 获取列表中的唯一元素

比方说，你有一个餐馆列表，也许是从一个文件中读取的。你关心的是列表中唯一的餐馆。从list 中获取唯一元素的最佳方法是将其转化为set：

restaurants = ["McDonald's", "Burger King", "McDonald's", "Chicken Chicken"]
unique_restaurants = set(restaurants)
print(unique_restaurants)
# prints {'Chicken Chicken', "McDonald's", 'Burger King'}

请注意，set 的顺序与原始 list 的顺序不同；这是因为 set 是无序的，就像 dict 一样。

使用 Python 内置的 list 函数，可以很容易地将其转换回 List，从而得到与原始 list 相同但没有重复的另一个 list：

list(unique_restaurants)
# ['Chicken Chicken', "McDonald's", 'Burger King']

这样写在一行也很常见：

# Removes all duplicates and returns another list
list(set(restaurants))

现在，可以再次对原始列表执行任何操作。

Section 8.3: Set of Sets

像下面这样定义一个set

{{1,2}, {3,4}}

会出现下面的类型错误：

TypeError: unhashable type: 'set'

请使用 frozenset，则不会报错:

{frozenset({1, 2}), frozenset({3, 4})}

Section 8.4: 使用方法和内置程序进行set操作

我们定义两个 sets a 和 b

>>> a = {1, 2, 2, 3, 4}
>>> b = {3, 3, 4, 4, 5}

注意：{1} 创建的集合只有一个元素，而 {} 创建的是空 dict。创建空集的正确方法是 set()。

交集

a.intersection(b) 返回一个新集合，其元素同时出现在 a 和 b 中

>>> a.intersection(b)
{3, 4}

联合

a.union(b) 返回一个新集合，其中包含 a 和 b 中的元素

>>> a.union(b)
{1, 2, 3, 4, 5}

差集

a.difference(b) 返回一个新集合，其元素存在于 a 中，但不在 b 中

>>> a.difference(b)
{1, 2}
>>> b.difference(a)
{5}

对称差集

a.symmetric_difference(b) 返回一个新集合，其元素存在于 a 或 b 中，但不同时存在于两个集合中。

>>> a.symmetric_difference(b)
{1, 2, 5}
>>> b.symmetric_difference(a)
{1, 2, 5}

注： a.symmetric_difference(b) == b.symmetric_difference(a)

子集和超集

c.issubset(a) 测试 c 的每个元素是否都在 a 中。

a.issuperset(c) 测试 c 的每个元素是否都在 a 中。

>>> c = {1, 2}
>>> c.issubset(a)
True
>>> a.issuperset(c)
True

后一种操作有如下所示的等效运算符：

互不相交的集合

如果 a 中没有元素也在 d 中，则集合 a 和 d 不相交，反之亦然。

>>> d = {5, 6}
>>> a.isdisjoint(b) # {2、3、4}都在这两个集合中
False
>>> a.isdisjoint(d)
True

# 这是一种等效的检查，但效率较低
>>> len(a & d) == 0
True

# 这样的效率更低
>>> a & d == set()
True

测试成员

内置关键字可搜索出现次数

>>> 1 in a
True
>>> 6 in a
False

长度

内置 len() 函数返回集合中元素的个数

>>> len(a)
4
>>> len(b)
3

Section 8.5: 集合和多集合

sets 是由不同元素组成的无序集合。但有时我们需要处理不一定是不同元素的无序集合，并跟踪元素的乘数。

请看这个例子：

>>> setA = {'a','b','b','c'}
>>> setA
set(['a', 'c', 'b'])

将字符串 a、b、b、c 保存到 set 数据结构中，我们就丢失了 b 出现两次的信息。当然，将元素保存到 list 中可以保留这些信息

>>> listA = ['a','b','b','c']
>>> listA
['a', 'b', 'b', 'c']

但 list 数据结构会引入额外的不需要的排序，从而减慢我们的计算速度。

为了实现多集合，Python 提供了集合模块中的 Counter 类（从 2.7 版开始）： Python 2.x 版本 ≥ 2.7

>>> from collections import Counter
>>> counterA = Counter(['a','b','b','c'])
>>> counterA
Counter({'b': 2, 'a': 1, 'c': 1})

counter 是一个字典，其中元素作为字典键存储，其计数作为字典值存储。和所有字典一样，它是一个无序集合。