在Python中的集合：带有代码示例的完整指南

在本教程中，您将学习Python集合的基础知识以及您可以使用的各种集合方法来修改Python集合。

集合是Python中的一种内置数据结构。当您需要使用非重复元素的集合时，可以使用集合作为首选数据结构。

在接下来的几个部分中，我们将介绍Python集合的基础知识以及您可以使用的集合方法来处理它们。然后，我们将学习如何在Python中执行常见的集合操作。

让我们开始吧！

Python集合的基础知识

在Python中，集合是一个无序的非重复元素集合。这意味着集合中的元素应该都是不同的。

您可以向集合中添加和删除元素，因此集合是一个可变的集合。它可以包含不同数据类型的元素。但是，集合中的各个元素应该是hashable。

在Python中，如果一个对象的哈希值永远不会改变，那么该对象被称为可哈希的。大多数不可变对象，如Python strings、元组和dictionaries都是可哈希的。

我们将详细学习如何创建集合。现在，考虑以下两个集合：

py_set = {0,1,2,(2,3,4),'Cool!'}
py_set = {0,1,2,[2,3,4],'Oops!'}

# 输出
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
 in ()
----> 1 py_set = {0,1,2,[2,3,4],'Oops!'}

TypeError: unhashable type: 'list'

第一个集合包含三个数字、一个元组和一个字符串。集合初始化运行正常。而第二个集合包含一个列表而不是元组。列表是一个可变的集合，它不能被哈希化，因此初始化引发了TypeError。

📑总而言之，我们可以将Python集合定义为一个可变的不同和可哈希元素的集合。

如何创建Python集合

我们将首先学习如何在Python中创建集合。

#1. 使用显式初始化

您可以通过指定集合的元素，用逗号(,)分隔并用一对花括号{}括起来，创建一个集合。

py_set1 = {'Python','C','C++','JavaScript'}
type(py_set1)

# 输出
set

如果您之前使用过Python lists，那么您知道[]初始化一个空列表。即使Python集合用一对花括号{}括起来，您也不能使用一对{}括号来初始化一个集合。这是因为{} it初始化了一个Python dictionary而不是Python集合。

py_set2 = {}
type(py_set2)

# 输出
dict

您可以再次调用type()函数来验证py_set是一个字典(dict)。

#2. 使用set()函数

如果您想初始化一个空集合，然后向其添加元素，可以使用set()函数。

py_set3 = set()
type(py_set3)

# 输出
set

#3. 将其他可迭代对象转换为集合

创建集合的另一种方法是将其他可迭代对象，如列表和元组，转换为集合，使用set(iterable)。

py_list = ['Python','C','C++','JavaScript','C']
py_set4 = set(py_list)
print(py_set4)
# {'C++', 'C', 'JavaScript', 'Python'} # 重复元素'C'被删除
type(py_set4)
# set

在上面的例子中，py_list包含两个‘C’。但在py_set4中，‘C’只出现一次，因为集合是不同元素的集合。将其转换为集合的这种技术通常用于remove duplicates from Python lists。

如何向Python集合中添加元素

让我们首先创建一个空集py_set并在本教程的剩余部分中使用它。

py_set = set()
len(py_set) # 返回集合的长度
# 输出
0

#1. 使用.add()方法

要向集合添加元素，可以使用.add()方法。 set.add(element)将元素添加到集合中。

为了清楚起见，我们将向Python集合中添加元素，并在每个步骤中打印出集合。

▶️让我们将字符串‘Python’作为一个元素添加到py_set中。

py_set.add('Python')
print(py_set)

# 输出
{'Python'}

接下来，我们将添加另一个元素。

py_set.add('C++')
print(py_set)

# 输出
{'Python', 'C++'}

重要的是要理解，.add()方法仅在集合中不存在时才向集合添加元素。如果集合已经包含了要添加的元素，则添加操作无效。

为了验证这一点，让我们尝试将‘C++’添加到py_set中。

py_set.add('C++')
print(py_set)

# 输出
{'Python', 'C++'}

集合包含‘C++’，所以添加操作没有效果。

▶️让我们向集合中添加几个元素。

py_set.add('C')
print(py_set)
py_set.add('JavaScript')
print(py_set)
py_set.add('Rust')
print(py_set)

# 输出
{'Python', 'C++', 'C'}
{'JavaScript', 'Python', 'C++', 'C'}
{'Rust', 'JavaScript', 'Python', 'C++', 'C'}

#2. 使用.update()方法

到目前为止，我们已经学习了如何向现有集合中添加元素-一次添加一个元素。

如果要向一系列元素添加多个元素呢？

您可以使用.update()方法以set.update(collection)的语法将collection中的元素添加到集合中。 collection可以是列表、元组、字典等。

py_set.update(['Julia','Ruby','Scala','Java'])
print(py_set)

# 输出
{'C', 'C++', 'Java', 'JavaScript', 'Julia', 'Python', 'Ruby', 'Rust', 'Scala'}

当您想向集合中添加一系列元素而不在内存中创建另一个对象时，这个方法非常有用。

在下一节中，让我们学习如何从集合中删除元素。

从Python集合中删除元素

让我们考虑以下集合（在进行更新操作之前的py_set）。

py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}

#1. 使用.pop()方法

set.pop()随机从集合中删除一个元素并返回它。让我们在py_set上调用pop方法并看看它返回什么。

py_set.pop()

# 输出
'Rust'

这一次，调用.pop()方法返回了字符串‘Rust’。

注意：因为.pop()方法以随机方式返回一个元素，所以当您在您的代码中运行时，您可能会得到另一个元素。

当我们检查集合时，‘Rust’不再存在于集合中。

print(py_set)

# 输出
{'JavaScript', 'Python', 'C++', 'C'}

#2. 使用.remove()和discard()方法

在实践中，您可能希望从集合中删除特定的元素。要做到这一点，您可以使用.remove()和.discard()方法。

set.remove(element)从集合中删除元素。

py_set.remove('C')
print(py_set)

# 输出
{'JavaScript', 'Python', 'C++'}

如果我们尝试删除集合中不存在的元素，我们将遇到一个关键错误。

将英文翻译成简体中文，保留，及HTML标签。

py_set.remove('Scala')

# 输出
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
 in ()
----> 1 py_set.remove('Scala')

KeyError: 'Scala'

让我们再次查看一下py_set。现在我们有三个元素。

print(py_set)

# 输出
{'JavaScript', 'Python', 'C++'}

使用语法set.discard(element)，.discard()方法也可以从集合中删除元素。

py_set.discard('C++')
print(py_set)

# 输出
{'JavaScript', 'Python'}

然而，它与.remove()方法不同之处在于，当我们尝试删除不存在的元素时，它不会引发KeyError错误。

如果我们试图使用.discard()方法从列表中删除“Scala”（不存在的元素），我们不会看到错误。

py_set.discard('Scala') ＃没有错误！
print(py_set)

# 输出
{'JavaScript', 'Python'}

访问Python集合的元素

到目前为止，我们已经学习了如何向Python集合添加和删除元素。但是，我们还没有看到如何访问集合中的单个元素。

由于集合是一个无序集合，它不能通过索引访问。因此，如果您尝试使用索引访问集合的元素，您将遇到错误，如下所示。

py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}

print(py_set[0])

# 输出
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
 in ()
----> 1 print(py_set[0])

TypeError: 'set' object is not subscriptable

那么如何访问集合中的元素呢？

有两种常见的方法：

• 遍历集合并访问每个元素
• 检查特定元素是否是集合的成员

▶️ 使用for循环遍历集合并访问元素。

for elt in py_set:
  print(elt)

# 输出
C++
JavaScript
Python
Rust
C

在实际操作中，您可能希望使用in运算符检查集合中是否存在给定的元素。

注意：element in set如果元素在集合中存在，则返回True；否则返回False。

在这个例子中，py_set包含“C++”，不包含“Julia”，in运算符分别返回True和False。

'C++' in py_set
# True
'Julia' in py_set
# False

查找Python集合的长度

如前所述，您可以使用len()函数获取集合中元素的数量。

py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
len(py_set)

# 输出：5

如何清空Python集合

要通过删除所有元素来清除集合，您可以使用.clear()方法。

让我们在py_set上调用.clear()方法。

py_set.clear()

如果您尝试打印它，您将得到set() – 表示集合为空。您还可以调用len()函数验证集合的长度为零。

print(py_set)
# set()
print(len(py_set))
# 0

到目前为止，我们已经学习了如何在Python集合上执行基本的CRUD操作：

• 创建：使用set()函数、类型转换和初始化
• 读取：使用循环和in操作符访问集合的元素进行成员测试
• 更新：向集合中添加、删除元素和更新集合
• 删除：通过从集合中删除所有元素来清空集合

用Python代码解释常见的集合操作

Python集合还允许我们执行基本的集合操作。我们将在本节中学习它们。

#1. 集合的并集

在集合论中，两个集合的并集是至少在两个集合中的元素的集合。如果有两个集合A和B，则并集包含仅在A中存在、仅在B中存在以及同时在A和B中存在的元素。

要找到集合的并集，可以使用|操作符或.union()方法，语法为setA.union(setB)。

setA = {1,3,5,7,9}
setB = {2,4,6,8,9}

print(setA | setB)
# 输出
{1, 2, 3, 4, 5, 6, 7, 8, 9}

setA.union(setB)

# 输出
{1, 2, 3, 4, 5, 6, 7, 8, 9}

集合的并集是一个可交换的操作，所以A U B与B U A相同。让我们通过在.union()方法调用中交换setA和setB的位置来验证这一点。

setB.union(setA)

# 输出
{1, 2, 3, 4, 5, 6, 7, 8, 9}

#2. 集合的交集

另一个共同的集合操作是两个集合A和B的交集。交集操作返回一个包含同时在A和B中存在的所有元素的集合。

要计算交集，可以使用&操作符或.intersection()方法，如下面的代码片段所示。

print(setA & setB)

# 输出
{9}

setA.intersection(setB)

# 输出
{9}

在此示例中，元素9同时存在于setA和setB中，因此交集只包含此元素。

与集合的并集一样，集合的交集也是一种可交换的操作。

setB.intersection(setA)

# 输出
{9}

#3. 集合的差集

给定任意两个集合，联合和交集帮助我们找到同时在两个集合中存在和至少在一个集合中存在的元素。另一方面，集合的差集帮助我们找到在一个集合中存在但不在另一个集合中存在的元素。

– setA.difference(setB)给出了仅在setA中存在而不在setB中存在的元素的集合。

– setB.difference(setA)给出了仅在setB中存在而不在setA中存在的元素的集合。

print(setA - setB)

print(setB - setA)

# 输出
{1, 3, 5, 7}
{8, 2, 4, 6}

显然，AB与BA不相同，所以集合的差集不是一个可交换的操作。

setA.difference(setB)
# {1, 3, 5, 7}

setB.difference(setA)
# {2, 4, 6, 8}

#4. 对称差集

在集合的交集中，我们得到的是同时存在于两个集合中的元素，而对称差集返回的是只存在于其中一个集合中的元素的集合。

考虑以下示例。

setA = {1,3,5,7,10,12}
setB = {2,4,6,8,10,12}

要计算对称差集，可以使用^操作符或.symmetric_difference()方法。

print(setA ^ setB)

# 输出
{1, 2, 3, 4, 5, 6, 7, 8}

元素10和12都出现在setA和setB中。因此它们不在对称差集中。

setA.symmetric_difference(setB)

＃输出
{1, 2, 3, 4, 5, 6, 7, 8}

由于对称差集操作收集出现在两个集合中的元素，无论元素收集的顺序如何，结果集都是相同的。因此，对称差集是一种可交换的操作。

setB.symmetric_difference(setA)

＃输出
{1, 2, 3, 4, 5, 6, 7, 8}

#5. 子集和超集

在集合论中，子集和超集有助于理解两个集合之间的关系。

给定两个集合A和B，如果集合B中的所有元素也在集合A中，则集合B是集合A的子集。而集合A是集合B的超集。

考虑两个集合languages和languages_extended的例子。

languages = {'Python', 'JavaScript','C','C++'}
languages_extended = {'Python', 'JavaScript','C','C++','Rust','Go','Scala'}

在Python中，您可以使用.issubset()方法检查给定的集合是否是另一个集合的子集。

setA.issubset(setB)如果setA是setB的子集，则返回True；否则返回False。

在这个例子中，languages是languages_extended的子集。

languages.issubset(languages_extended)
＃输出
True

类似地，您可以使用.issuperset()方法检查给定的集合是否是另一个集合的超集。

setA.issuperset(setB)如果setA是setB的超集，则返回True；否则返回False。

languages_extended.issuperset(languages)
＃输出
True

由于languages_extended是languages的超集，所以languages_extended.issuperset(languages)返回True，如上所示。

结论

希望本教程能帮助您理解Python集合的工作原理，以及用于CRUD操作的集合方法和常见集合操作。作为下一步，您可以尝试在您的应用程序中使用它们。

您可以查看其他深入的教程。祝学习愉快！