Python从入门到精通，100天就够了！（7）——常用数据结构之集合

前几章我们分别讲了列表（list）、元组（tuple）、字符串（string），这一章我们讲新的容器型的数据类型：集合（set）。

集合（set）是一个无序的不重复元素序列。可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

集合的创建

1. 字面量语法
   创建集合可以使用{}字面量语法，{}中需要至少有一个元素，因为没有元素的{}并不是空集合而是一个空字典。若要创建空集合，使用内置函数set.
   基本语法为：

nums = {value01,value02,...}
# 空集合
num1 = set()  

2. 构造器语法
   当然，也可以使用内置函数set来创建一个集合，准确的说set并不是一个函数，而是创建集合对象的构造器。

# 创建集合的构造器语法
set2 = set('hello')
print(set2)         # {'h', 'l', 'o', 'e'}
# 将列表转换成集合(可以去掉列表中的重复元素)
set3 = set([1, 2, 3, 3, 2, 1])
print(set3)         # {1, 2, 3}

3. 生成式语法
   除了这两种方式，我们还可以使用生成式语法来创建集合，就像我们之前用生成式创建列表那样。要知道集合中有多少个元素，还是使用内置函数len；使用for循环可以实现对集合元素的遍历。

# 创建集合的生成式语法(将列表生成式的[]换成{})
set4 = {num for num in range(1, 20) if num % 3 == 0 or num % 5 == 0}
print(set4)         # {3, 5, 6, 9, 10, 12, 15, 18}

注意：
需要提醒大家，集合中的元素必须是hashable类型。所谓hashable类型指的是能够计算出哈希码的数据类型，你可以暂时将哈希码理解为和变量对应的唯一的ID值。通常不可变类型都是hashable类型，如整数、浮点、字符串、元组等，而可变类型都不是hashable类型，因为可变类型无法确定唯一的ID值，所以也就不能放到集合中。集合本身也是可变类型，所以集合不能够作为集合中的元素，这一点请大家一定要注意。

集合的特点

1. 无序性：一个集合中，每个元素的地位都是相同的，元素之间是无序的。
2. 互异性：一个集合中，任何两个元素都认为是不相同的，即每个元素只能出现一次。
3. 确定性：给定一个集合，任给一个元素，该元素或者属于或者不属于该集合，二者必居其一，不允许有模棱两可的情况出现。

#集合的无序性
set1 = {5, 2, 6, 3, 1, 4}
print(set1)              # {1, 2, 3, 4, 5, 6}

# 集合的互异性
set2 = {1, 2, 2, 3, 3, 3}
print(set2, len(set2))   #{1, 2, 3} 3

# 集合的确定性
set4 = {0, 1, 2, 3}
set5 = {1, 3}
print(5 in set4)         # False
print(3 in set5)         # True

集合的运算

交并差运算

Python中的集合跟数学上的集合一样，可以进行交集、并集、差集等运算，而且可以通过运算符和方法调用两种方式来进行操作，代码如下所示。

set4 = {0, 1, 2, 3}
set5 = {1, 4, 3, 5}

# 交集
# 方法一: 使用 & 运算符
print(set4 & set5)                       # {1, 3}
# 方法二: 使用intersection方法
print(set4.intersection(set5))           # {1, 3}

# 并集
# 方法一: 使用 | 运算符
print(set4 | set5)                       # {0, 1, 2, 3, 4, 5}
# 方法二: 使用union方法
print(set4.union(set5))                  # {0, 1, 2, 3, 4, 5}

# 差集
# 方法一: 使用 - 运算符
print(set4 - set5)                       # {0, 2}
# 方法二: 使用difference方法
print(set4.difference(set5))             # {0, 2}

# 对称差(并集-交集)
# 方法一: 使用 ^ 运算符
print(set4 ^ set5)                       # {0, 2, 4, 5}
# 方法二: 使用symmetric_difference方法
print(set4.symmetric_difference(set5))   # {0, 2, 4, 5}
# 方法三: 对称差相当于两个集合的并集减去交集
print((set4 | set5) - (set4 & set5))     # {0, 2, 4, 5}

比较运算

两个集合可以用==和!=进行相等性判断，如果两个集合中的元素完全相同，那么==比较的结果就是True，否则就是False。如果集合A的任意一个元素都是集合B的元素，那么集合A称为集合B的子集，即对于∀a∈A，均有a∈B，则A⊆B。A是B的子集，反过来也可以称B是A的超集。如果A是B的子集且A不等于B，那么A就是B的真子集。Python为集合类型提供了判断子集和超集的运算符，其实就是我们非常熟悉的<和>运算符，代码如下所示。

set1 = {1, 3, 5}
set2 = {1, 2, 3, 4, 5}
set3 = set2
# <运算符表示真子集，<=运算符表示子集
print(set1 < set2, set1 <= set2)    # True True
print(set2 < set3, set2 <= set3)    # False True
# 通过issubset方法也能进行子集判断
print(set1.issubset(set2))      # True

# 反过来可以用issuperset或>运算符进行超集判断
print(set2.issuperset(set1))    # True
print(set2 > set1)              # True

集合的方法

虽然集合不能有可变元素，但是集合本身是可变的。也就是说，可以添加或删除其中的元素。

可以使用add() 方法添加单个元素，使用 update()方法添加多个元素，update()可以使用元组、列表、字符串或其他集合作为参数。

set1 = {1, 2, 3}
set2 = {7, 5, 6}
# add() 方法
set1.add(4)
print(set1)           # {1, 2, 3, 4}

# update() 方法
set1.update(set2)
print(set1)           # {1, 2, 3, 4, 5, 6, 7}

可以使用discard()、pop()和 remove() 方法删除集合中特定的元素。

pop()方法可以从集合中随机删除一个元素并返回该元素；剩余两者之间唯一的区别在于：如果集合中不存在指定的元素，使用 discard()保持不变；但在这种情况下，remove()会引发 KeyError。

set1 = {1, 2, 3}
set2 = {7, 5, 6}
#  pop() 方法
print(set1.pop())      # 1

#  discard() 方法
set1.discard(4)
print(set1)            # {2, 3}
set2.discard(7)
print(set2)            # {5, 6}

#  remove() 方法
set2.remove(7)
print(set2)            # KeyError: 7
set2.remove(5)
print(set2)            # {6}

如果要判断两个集合有没有相同的元素可以使用isdisjoint方法，没有相同元素返回True，否则返回False，代码如下所示。

set1 = {'Java', 'Python', 'Go', 'Kotlin'}
set2 = {'Kotlin', 'Swift', 'Java', 'Objective-C', 'Dart'}
set3 = {'HTML', 'CSS', 'JavaScript'}
print(set1.isdisjoint(set2))    # False
print(set1.isdisjoint(set3))    # True

不可变集合

Python中还有一种不可变类型的集合，名字叫frozenset。set跟frozenset的区别就如同list跟tuple的区别，frozenset由于是不可变类型，能够计算出哈希码，因此它可以作为set中的元素。除了不能添加和删除元素，frozenset在其他方面跟set基本是一样的，下面的代码简单的展示了frozenset的用法。

set1 = frozenset({1, 3, 5, 7})
set2 = frozenset(range(1, 6))
print(set1 & set2)    # frozenset({1, 3, 5})
print(set1 | set2)    # frozenset({1, 2, 3, 4, 5, 7})
print(set1 - set2)    # frozenset({7})
print(set1 < set2)    # False

总结

Python中的集合底层使用了哈希存储的方式，集合是一种容器，元素必须是hashable类型，与列表不同的地方在于集合中的元素没有序、不能用索引运算、不能重复。

1. 集合底层使用哈希存储的存储方式（高效率的存储）
2. 哈希存储的关键是设计一个好的哈希函数，让不同的对象产生不同的哈希吗
3. 集合在元素查找时效率高于列表（因为集合是哈希存储而列表是顺序存储），不依赖问题的规模
4. 如果一个对象不能计算哈希码，就不能放入集合。（集合、字典、列表就无法计算哈希码）。

以上就是集合的基础知识，涉及到的方法很多，还需要多多练习呀。Get It！