在 Python 中使用集合的5个层次

引言

集合是元素唯一的无序集合。它是计算机科学中最核心的数据结构之一。像其他编程语言一样，Python也具有集合及其操作函数的内置实现。

1.了解集合的基本特征

Python中集合的性质由数学中的集合论决定。其基本特征如下：

· 集合中的元素是无序的

· 集合不能包含重复的元素

· 集合上有3种基本运算: 并运算、交运算和补运算

因此，Python中的集合只能包含不可变的对象，重复的元素将被删除。

s = {1, 2, 2, 2, 3}
print(s)  # duplicate numbers were removed
# {1, 2, 3}


s = {1, 2, (3, 4)} # tuple is an immutable type
print(s)
# {1, 2, (3, 4)}


s = {1, 2, [3, 4]}  # can't contain a mutable type
# TypeError: unhashable type: 'list'

如上所述，集合将丢弃重复的数字，即使我们定义了它们。

另一方面，不可变类型的元组可以是集合的元素，但可变类型的列表则不能。否则将引发TypeError。

顺便说一句，使用集合是删除列表中重复项的常用方法。

leaders = ["Yang Zhou", "Elon Mask", "Yang Zhou"]
unique_leaders = list(set(leaders))
print(unique_leaders)
# ['Yang Zhou', 'Elon Mask']

2.三种方法创建集合

有三种方法可以在Python中创建集合：

直接用大括号定义

>>> s = {1,2,3,4}
>>> type(s)
<class 'set'>

这是定义set对象的一种直观方法。正如前面提到的，如果有一些重复的元素，那么就会丢弃它们。

使用set方法

>>> s = set([1,2,3,4])
>>> type(s)
<class 'set'>

这个方法最多只能接收一个参数，这个参数必须是可迭代的。如果没有参数，将生成一个新的空集。

· set(): 获取一个新的空 set 对象

· set(iterable): 获取一个新集合，该集合的元素来自可迭代对象

任何迭代都可以用来生成一个 set 对象。当使用字典时，我们应该注意它的键或值是否会被应用。

d = {1: "Y", 2: "A", 3: "N", 4: "G"}
s = set(d) # Use its keys by default
print(s)
# {1, 2, 3, 4}
s2 = set(d.values())
print(s2)
# {'A', 'G', 'N', 'Y'}

使用集合解析

这是一种生成集合的优雅方式:

s = {i for i in range(10)}
print(s)
# {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

3.巧妙地修改集合

创建集合后，我们可以使用内置函数对其进行修改。常用方法如下：

· add():向集合中添加一个元素。如果已经包含该元素，则没有效果

· remove():删除一个元素。如果元素不是成员，将引发一个KeyError。

· pop():删除并返回一个任意元素。如果集合为空，将引发KeyError。

· discard():丢弃元素。如果元素不是成员，则无效。

· clear():丢弃集合中的所有元素

s = {1, 2, 3, 4, 5, 6}
s.add(9)
print(s)
# {1, 2, 3, 4, 5, 6, 9}
s.remove(1)
print(s)
# {2, 3, 4, 5, 6, 9}
s.discard(100)  # no effect
print(s)
# {2, 3, 4, 5, 6, 9}
s.discard(9)
print(s)
# {2, 3, 4, 5, 6}
s.pop()
print(s)
# {3, 4, 5, 6}
s.clear()
print(s)
# set()
# s.remove(100)
# KeyError: 100

4.掌握集合的运算

如上所述，集合上有3种基本操作：并集，交集和补集。它们可以通过维恩图进行演示，如下所示：

我们可以通过Python集合中的内置运算符或方法来实现它们。

获得多个集合的并集

集A和集B的并集定义为一个新集，它由属于集A或集B（或两者）的所有元素组成。

有3种方法可以得到两个集合的并集：

A = {1, 2, 3}
B = {3, 4, 5}


C = A.union(B)
print(C, A, B)
# {1, 2, 3, 4, 5} {1, 2, 3} {3, 4, 5}


C = A | B
print(C, A, B)
# {1, 2, 3, 4, 5} {1, 2, 3} {3, 4, 5}


A.update(B)
print(A, B)
# {1, 2, 3, 4, 5} {3, 4, 5}

如上所示，我们可以使用|运算符，union()或update()方法来获取联合集。区别如下：

· union()函数或|运算符返回一个新的并集,并且不会对集合A产生影响

· update()函数不返回任何内容，而是在集合A上进行更改。

如果我们要对多个集合进行操作，则方法类似，只需添加更多参数即可。如下所示：

D = A.union(B, C)
A.update(B, C)
D = A | B | C

得到多个集合的交集

集A和集B的交集定义为一个集合，该集合由同时属于A和B的所有元素组成。

与并集类似，也有三种计算交集的方法：

A = {1, 2, 3}
B = {3, 4, 5}


C = A.interp(B)
print(C, A, B)
# {3} {1, 2, 3} {3, 4, 5}


C = A & B
print(C, A, B)
# {3} {1, 2, 3} {3, 4, 5}


A.interp_update(B)
print(A, B)
# {3} {3, 4, 5}

得到集合的补集和差值

数学集合论中对补和差的定义如下：

集合A的补集是一个集合，其所有元素都在给定的总集合U中，但不在集合A中。

集合A和集合B的相对补或差是一个集合，其所有元素都在A中，但不在B中。

简而言之，总集合是包含集合A的更大集合。因此，补集和差值操作本质上是相同的。唯一的区别是：

· 补集是针对一个集合（集合A的补集）

· 差值是针对多个集合（集合A和集合B的差值）

Python同样提供了三种方法来获得补集或差值：

A = {1, 2, 3}
B = {3, 4, 5}


C = A.difference(B)
print(C, A, B)
# {1, 2} {1, 2, 3} {3, 4, 5}


C = A - B
print(C, A, B)
# {1, 2} {1, 2, 3} {3, 4, 5}


A.difference_update(B)
print(A, B)
# {1, 2} {3, 4, 5}

5.正确使用冻结集

正如元组是不可变的列表，冻结的集合也是不可变的集合。Python 以这种方式定义它的数据结构，给我们更多的灵活性。虽然这看起来不常见，但有时我们确实需要使用集合的不可变版本。

例如，如果我们想使用集合作为字典的键:

frozen_s1 = frozenset({1, 2, 3})
frozen_s2 = frozenset({4, 5, 6})
D = {frozen_s1: "Yang", frozen_s2: "Zhou"}
print(D)
# {frozenset({1, 2, 3}): 'Yang', frozenset({4, 5, 6}): 'Zhou'}


s1 = {1, 2, 3}
s2 = {4, 5, 6}
D = {s1: "Yang", s2: "Zhou"}
# TypeError: unhashable type: 'set'

如上所述，我们可以使用不可变的冻结集而不是普通集合作为字典的键。

由于冻结集是不可变的，因此无法使用3中提到的方法来修改冻结集。

frozen_s1 = frozenset({1, 2, 3})
frozen_s1.add(4)
# AttributeError: 'frozenset' object has no attribute 'add'

总结

集合不仅仅是数学中的重要概念，在计算机科学中同样重要，由于它的特殊性，我们应该熟练掌握并应用它。

·  END  ·

HAPPY LIFE