集合(set)篇（二）

文章目录

[5.9 add()函数](#5.9 add()函数)
[5.10 clear()函数](#5.10 clear()函数)
[5.11 copy()函数](#5.11 copy()函数)
[5.12 difference()函数](#5.12 difference()函数)
[5.13 difference_update()函数](#5.13 difference_update()函数)
[5.14 discard()函数](#5.14 discard()函数)
[5.15 frozenset()函数](#5.15 frozenset()函数)
[5.16 intersection()函数](#5.16 intersection()函数)
[5.17 intersection_update()函数](#5.17 intersection_update()函数)
[5.18 issubset()函数](#5.18 issubset()函数)

5.9 add()函数

在Python中，集合（set）是一种无序且不包含重复元素的数据结构。要向集合中添加元素，你可以使用add()方法。add()方法接受一个元素作为参数，并将该元素添加到集合中。如果元素已经存在于集合中，add()方法不会有任何效果，也不会引发错误。

下面是一个使用add()方法向集合中添加元素的例子：

python 复制代码

# 创建一个空集合
my_set = set()

# 使用add()方法添加元素
my_set.add(1)
my_set.add(2)
my_set.add(3)

# 输出集合
print(my_set)  # 输出: {1, 2, 3}

# 尝试添加一个已存在的元素
my_set.add(2)

# 再次输出集合，注意元素2仍然只出现一次
print(my_set)  # 输出: {1, 2, 3}

在这个例子中，我们创建了一个空集合my_set，然后使用add()方法添加了元素1、2和3。尽管我们尝试再次添加元素2，但由于集合中不允许重复元素，因此集合的内容并没有改变。

需要注意的是，如果你尝试添加一个不可哈希（unhashable）的类型（如列表或字典）到集合中，将会引发TypeError。只有可哈希的类型（如整数、浮点数、字符串、元组等）才能作为集合的元素。

python 复制代码

# 尝试添加一个列表到集合中，将会引发错误
my_set.add([1, 2, 3])  # TypeError: unhashable type: 'list'

5.10 clear()函数

在Python中，clear() 是一个集合（set）对象的方法，用于移除集合中的所有元素，使其变为一个空集合。当你调用 clear() 方法时，集合中的所有元素都将被删除，集合将不再包含任何元素。

下面是一个使用 clear() 方法的例子：

python 复制代码

# 创建一个包含一些元素的集合
my_set = {1, 2, 3, 4, 5}

# 输出原始集合
print("原始集合:", my_set)  # 输出: 原始集合: {1, 2, 3, 4, 5}

# 调用 clear() 方法清空集合
my_set.clear()

# 输出清空后的集合
print("清空后的集合:", my_set)  # 输出: 清空后的集合: set()

在这个例子中，我们首先创建了一个包含五个元素的集合 my_set。然后，我们调用 clear() 方法来清空这个集合。最后，我们打印出清空后的集合，可以看到它现在是一个空集合。

需要注意的是，clear() 方法没有返回值（或者说返回 None），它直接修改了原集合对象。如果你想创建一个新的空集合，而不修改原集合，你可以使用 set() 函数来创建一个新的空集合实例。

5.11 copy()函数

在Python中，集合（set）是一种可变的数据类型，这意味着如果你对集合进行了修改（例如添加或删除元素），这些更改会直接影响到原始集合。如果你想要创建一个集合的副本，以便在不修改原始集合的情况下对其进行操作，你可以使用 copy() 方法。

copy() 方法返回集合的一个浅拷贝（shallow copy），这意味着如果集合中包含可变对象（如列表或字典），则拷贝中的这些对象将与原始集合中的对象相同（即它们是对同一个对象的引用），而不是这些对象的副本。

下面是一个使用 copy() 方法创建集合副本的例子：

python 复制代码

# 创建一个原始集合
original_set = {1, 2, 3, 4}

# 使用 copy() 方法创建集合的副本
copied_set = original_set.copy()

# 输出原始集合和副本
print("原始集合:", original_set)  # 输出: 原始集合: {1, 2, 3, 4}
print("集合副本:", copied_set)    # 输出: 集合副本: {1, 2, 3, 4}

# 修改原始集合
original_set.add(5)

# 再次输出原始集合和副本，以查看是否相互影响
print("修改后的原始集合:", original_set)  # 输出: 修改后的原始集合: {1, 2, 3, 4, 5}
print("副本集合:", copied_set)            # 输出: 副本集合: {1, 2, 3, 4}

在这个例子中，我们创建了一个名为 original_set 的原始集合，并使用 copy() 方法创建了一个名为 copied_set 的副本。然后，我们向原始集合中添加了一个新元素5。最后，我们输出了原始集合和副本集合，可以看到它们是不同的，修改原始集合并没有影响到副本集合。

如果你想要创建一个集合的深拷贝（deep copy），确保集合中的可变对象也被拷贝，你可以使用 copy 模块中的 deepcopy 函数：

python 复制代码

import copy

# 创建一个包含列表的集合
original_set = {1, 2, [3, 4], 5}

# 使用 deepcopy 创建深拷贝
deep_copied_set = copy.deepcopy(original_set)

# 修改原始集合中的列表
original_set.add(6)
original_set[2].append(7)

# 输出原始集合和深拷贝集合
print("原始集合:", original_set)  # 输出: 原始集合: {1, 2, [3, 4, 7], 5, 6}
print("深拷贝集合:", deep_copied_set)  # 输出: 深拷贝集合: {1, 2, [3, 4], 5}

在这个例子中，即使我们修改了原始集合中的一个列表元素，深拷贝集合中的对应列表也没有受到影响，因为 deepcopy 创建了列表中元素的副本。

5.12 difference()函数

在Python中，集合（set）的difference()方法用于返回两个集合的差集。也就是说，它会返回一个包含所有在第一个集合中但不在第二个集合中的元素的新集合。如果两个集合有相同的元素，那么这些元素将不会出现在差集中。

以下是difference()方法的一个使用示例：

python 复制代码

# 创建两个集合
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}

# 使用difference()方法计算差集
difference_set = set1.difference(set2)

# 输出差集
print(difference_set)  # 输出: {1, 2, 3}

在这个例子中，set1和set2分别包含了一些整数。当我们调用set1.difference(set2)时，Python会创建一个新的集合difference_set，它包含了所有在set1中但不在set2中的元素。因此，结果集合只包含1、2和3。

值得注意的是，difference()方法返回的是一个新的集合对象，原始集合不会被修改。

此外，你还可以使用减号（-）运算符来计算两个集合的差集，这是difference()方法的简写形式：

python 复制代码

# 使用减号运算符计算差集
difference_set = set1 - set2

# 输出差集
print(difference_set)  # 输出: {1, 2, 3}

减号运算符和difference()方法的功能是相同的，都是用来计算集合的差集。

5.13 difference_update()函数

在Python中，集合（set）的difference_update()方法用于移除集合中所有存在于另一个集合中的元素。这个方法不会返回一个新的集合，而是直接在原始集合上进行修改，移除那些也在指定集合中出现的元素。

以下是difference_update()方法的一个使用示例：

python 复制代码

# 创建两个集合
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}

# 使用difference_update()方法移除set1中所有也在set2中的元素
set1.difference_update(set2)

# 输出修改后的set1
print(set1)  # 输出: {1, 2, 3}

在这个例子中，set1和set2分别包含了一些整数。当我们调用set1.difference_update(set2)时，Python会移除set1中所有也在set2中出现的元素。因此，set1最终只包含1、2和3，因为这些是set1中独有的元素。

需要注意的是，difference_update()方法直接修改了原始集合，并且没有返回值。如果你想要保留原始集合并创建一个新的集合，你应该使用difference()方法，它返回一个新的集合，而原始集合不会被修改。

这里是如何使用difference()方法创建一个新的集合，而不修改原始集合：

python 复制代码

# 创建两个集合
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}

# 使用difference()方法创建一个新的集合，包含set1中独有的元素
new_set = set1.difference(set2)

# 输出原始集合和新集合
print("原始集合set1:", set1)  # 输出: 原始集合set1: {1, 2, 3, 4, 5}
print("新的集合new_set:", new_set)  # 输出: 新的集合new_set: {1, 2, 3}

在这个例子中，set1保持不变，而new_set是一个新的集合，包含了set1中独有的元素。

5.14 discard()函数

在Python中，集合（set）的discard()方法用于移除集合中的一个元素。如果元素存在于集合中，它会被移除；如果元素不存在于集合中，则discard()方法不会有任何效果，也不会引发错误。这与remove()方法不同，如果尝试使用remove()移除一个不存在的元素，将会引发KeyError异常。

discard()方法没有返回值（返回None），因为它直接在原始集合上进行操作，不创建新的集合。

下面是一个使用discard()方法的例子：

python 复制代码

# 创建一个集合
my_set = {1, 2, 3, 4, 5}

# 使用discard()方法移除一个存在的元素
my_set.discard(3)

# 输出修改后的集合
print(my_set)  # 输出: {1, 2, 4, 5}

# 尝试移除一个不存在的元素
my_set.discard(6)

# 再次输出集合，可以看到集合没有变化
print(my_set)  # 输出: {1, 2, 4, 5}

在这个例子中，我们首先创建了一个包含五个元素的集合my_set。然后，我们使用discard()方法移除了元素3，所以集合中不再包含3。接着，我们尝试使用discard()方法移除一个不存在的元素6，但集合my_set并没有发生变化，也没有引发任何错误。

discard()方法在处理可能不存在的元素时非常有用，因为它提供了一种安全的方式来移除元素，而不需要先检查元素是否存在于集合中。

5.15 frozenset()函数

在Python中，frozenset()函数用于创建一个不可变的（frozen，即不可修改的）集合对象。frozenset是set的一个不可变版本，这意味着一旦一个frozenset对象被创建，你就不能向其中添加或删除元素。这种不可变性使得frozenset对象可以用作字典的键或集合的元素，因为它们不会改变。

下面是如何使用frozenset()函数来创建一个不可变集合的例子：

python 复制代码

# 创建一个frozenset对象
fset = frozenset([1, 2, 3, 4, 5])

# 输出frozenset对象
print(fset)  # 输出: frozenset({1, 2, 3, 4, 5})

# 尝试修改frozenset对象（这将引发错误）
# fset.add(6)  # 这将引发AttributeError: 'frozenset' object has no attribute 'add'

# 尝试删除frozenset对象中的元素（这也将引发错误）
# fset.remove(3)  # 这将引发AttributeError: 'frozenset' object has no attribute 'remove'

# 因为frozenset是不可变的，所以它可以作为字典的键
dict_example = {fset: "这是一个frozenset示例"}

# 输出字典
print(dict_example)  # 输出: {frozenset({1, 2, 3, 4, 5}): '这是一个frozenset示例'}

在这个例子中，我们首先使用frozenset()函数和一个列表[1, 2, 3, 4, 5]来创建一个frozenset对象。然后，我们尝试使用add()和remove()方法来修改frozenset对象，但这会导致AttributeError，因为这些方法不适用于frozenset对象。最后，我们展示了如何将frozenset对象用作字典的键。

由于frozenset是不可变的，它们可以用作哈希表的键或在需要不变性的任何地方使用，比如在一个集合中作为另一个集合的元素。这是set对象无法做到的，因为set对象是可变的。

5.16 intersection()函数

在Python中，集合（set）的intersection()方法用于返回两个或多个集合的交集，即返回所有在这些集合中都存在的元素组成的新集合。如果集合之间没有公共元素，则返回一个空集合。

intersection()方法可以接受一个或多个集合作为参数，并返回这些集合的交集。如果传入多个集合，它将返回所有集合的交集。如果只传入一个集合，它将返回该集合的自身（因为单个集合的交集就是该集合本身）。

下面是一个使用intersection()方法的例子：

python 复制代码

# 创建两个集合
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}

# 使用intersection()方法获取两个集合的交集
intersection_set = set1.intersection(set2)

# 输出交集
print(intersection_set)  # 输出: {4, 5}

# 也可以传入多个集合来获取它们的交集
set3 = {7, 8, 9, 10}
intersection_set_multiple = set1.intersection(set2, set3)

# 输出多个集合的交集
print(intersection_set_multiple)  # 输出: set()，因为set1、set2和set3之间没有共同的元素

在这个例子中，set1和set2的交集是{4, 5}，因为这两个元素同时存在于两个集合中。然而，当我们尝试获取set1、set2和set3的交集时，结果是一个空集合，因为这三个集合没有共同的元素。

需要注意的是，intersection()方法返回的是一个新的集合，原始集合不会被修改。如果你想要修改原始集合，你可以使用intersection_update()方法，它会直接在原始集合上更新，移除不在交集中的元素。

5.17 intersection_update()函数

在Python中，集合（set）的intersection_update()方法用于更新集合，只保留与其他集合的交集部分。换句话说，它会移除当前集合中所有不在其他指定集合中的元素，只保留与其他集合共有的元素。如果其他集合中没有元素与当前集合有交集，那么当前集合将变为空集。

intersection_update()方法接受一个或多个集合作为参数，并直接在原始集合上进行修改，没有返回值（返回None）。

下面是一个使用intersection_update()方法的例子：

python 复制代码

# 创建两个集合
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}

# 使用intersection_update()方法更新set1，只保留与set2的交集部分
set1.intersection_update(set2)

# 输出更新后的set1
print(set1)  # 输出: {4, 5}

# 创建第三个集合
set3 = {7, 8, 9, 10}

# 使用intersection_update()方法更新set1，只保留与set2和set3的交集部分
set1.intersection_update(set2, set3)

# 输出更新后的set1
print(set1)  # 输出: set()，因为set2和set3没有共同元素

在这个例子中，我们首先创建了两个集合set1和set2。然后，我们使用intersection_update()方法更新了set1，只保留了与set2的交集部分，即{4, 5}。接着，我们创建了第三个集合set3，并再次使用intersection_update()方法更新了set1，这次只保留了与set2和set3的交集部分。由于set2和set3没有共同元素，所以set1最终变成了一个空集。

需要注意的是，intersection_update()方法会直接修改原始集合，如果你不希望改变原始集合，应该先创建一个集合的副本，然后在副本上调用intersection_update()方法。

5.18 issubset()函数

在Python中，issubset()函数用于判断一个集合是否是另一个集合的子集。如果集合A中的每一个元素都是集合B中的元素，那么A就是B的子集。

issubset()函数接受一个集合作为参数，并返回一个布尔值（True或False），指示当前集合是否是参数集合的子集。

下面是一个使用issubset()函数的例子：

python 复制代码

# 创建两个集合
set1 = {1, 2, 3}
set2 = {1, 2, 3, 4, 5}

# 判断set1是否是set2的子集
is_subset = set1.issubset(set2)

# 输出结果
print(is_subset)  # 输出: True

# 创建另一个集合
set3 = {6, 7, 8}

# 判断set1是否是set3的子集
is_subset = set1.issubset(set3)

# 输出结果
print(is_subset)  # 输出: False

在这个例子中，set1是{1, 2, 3}，set2是{1, 2, 3, 4, 5}。因为set1中的每个元素都是set2中的元素，所以set1是set2的子集，set1.issubset(set2)返回True。

另一方面，set3是{6, 7, 8}，set1中并非所有元素都是set3中的元素，所以set1不是set3的子集，set1.issubset(set3)返回False。

需要注意的是，issubset()函数不仅可以用于判断一个集合是否是另一个集合的子集，还可以用于判断一个集合是否是其自身的子集。例如，set1.issubset(set1)将始终返回True，因为任何集合都是其自身的子集。