集合

Python 中set与dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。

注意，key为不可变类型，即可哈希的值。

【例子】

num = {}
print(type(num))  # <class 'dict'>
num = {1, 2, 3, 4}
print(type(num))  # <class 'set'>

代码展示了在 Python 中创建空字典和集合的方式。

首先，创建了一个空字典 num = {}。通过 type(num)，打印出 num 的类型，输出结果为 <class 'dict'>，表示 num 是一个字典类型。

接着，重新赋值给 num，将其定义为一个包含元素 1、2、3 和 4 的集合，即 num = {1, 2, 3, 4}。再次通过 type(num) 打印 num 的类型，输出结果为 <class 'set'>，表示 num 是一个集合类型。

需要注意的是，在 Python 中可以使用花括号 {} 来创建字典和集合。当花括号中有键值对或者只有元素时，会被解释为字典；当花括号中只有元素时，会被解释为集合。

一、 集合的创建

1

• 先创建对象再加入元素。
• 在创建空集合的时候只能使用s = set()，因为s = {}创建的是空字典。

【例子】

basket = set()
basket.add('apple')
basket.add('banana')
print(basket)  # {'banana', 'apple'}

该代码创建了一个空集合 basket，然后使用 add() 方法向集合中添加了两个元素 'apple' 和 'banana'。最后，通过打印 basket 的内容，输出结果为 {'banana', 'apple'}。

在集合中，元素的顺序是不确定的，所以输出结果中的元素顺序可能与添加顺序不完全相同。

2

• 直接把一堆元素用花括号括起来{元素1, 元素2, ..., 元素n}。
• 重复元素在set中会被自动被过滤。

【例子】

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(basket)  # {'banana', 'apple', 'pear', 'orange'}

这段代码创建了一个集合 basket，其中包含了多个水果元素，包括 'apple'、'orange'、'pear' 和 'banana'。需要注意的是，集合是无序且不允许有重复元素的数据结构。

在打印 basket 的内容时，输出结果为 {'banana', 'apple', 'pear', 'orange'}。由于集合的性质，重复的元素被自动去除，并且元素的顺序是不确定的。

3

• 使用set(value)工厂函数，把列表或元组转换成集合。

【例子】

a = set('abracadabra')
print(a)  
# {'r', 'b', 'd', 'c', 'a'}

b = set(("Google", "Lsgogroup", "Taobao", "Taobao"))
print(b)  
# {'Taobao', 'Lsgogroup', 'Google'}

c = set(["Google", "Lsgogroup", "Taobao", "Google"])
print(c)  
# {'Taobao', 'Lsgogroup', 'Google'}

这段代码展示了使用不同方式创建集合的例子，并打印出集合的内容。

首先，通过 a = set('abracadabra') 创建了一个包含字符串 'abracadabra' 中所有不重复字母的集合。打印变量 a 的内容，输出结果为 {'r', 'b', 'd', 'c', 'a'}。

接着，通过 b = set(("Google", "Lsgogroup", "Taobao", "Taobao")) 创建了一个包含元组 ("Google", "Lsgogroup", "Taobao", "Taobao") 中所有不重复元素的集合。打印变量 b 的内容，输出结果为 {'Taobao', 'Lsgogroup', 'Google'}。

最后，通过 c = set(["Google", "Lsgogroup", "Taobao", "Google"]) 创建了一个包含列表 ["Google", "Lsgogroup", "Taobao", "Google"] 中所有不重复元素的集合。打印变量 c 的内容，输出结果为 {'Taobao', 'Lsgogroup', 'Google'}。

需要注意的是，集合是无序且不允许有重复元素的数据结构。

4

【例子】去掉列表中重复的元素

lst = [0, 1, 2, 3, 4, 5, 5, 3, 1]

temp = []
for item in lst:
    if item not in temp:
        temp.append(item)

print(temp)  # [0, 1, 2, 3, 4, 5]

a = set(lst)
print(list(a))  # [0, 1, 2, 3, 4, 5]

这段代码展示了去除列表中重复元素的两种方法，并打印出结果。

首先，使用循环遍历列表 lst 中的每个元素。如果元素不在临时列表 temp 中，就将其添加到 temp 中。最后，打印变量 temp 的内容，输出结果为 [0, 1, 2, 3, 4, 5]。这种方法通过遍历和判断来实现去重。

接着，使用集合的特性来创建一个新的集合 a，其中包含列表 lst 中的所有不重复元素。然后，将集合 a 转换为列表，并打印出结果。输出结果也为 [0, 1, 2, 3, 4, 5]。这种方法利用了集合中不允许有重复元素的特性来去除重复项。

两种方法都可以实现去除列表中重复元素的效果，选择使用哪种方法取决于具体需求和代码的简洁性。

从结果发现集合的两个特点：无序 (unordered) 和唯一 (unique)。

由于 set 存储的是无序集合，所以我们不可以为集合创建索引或执行切片(slice)操作，也没有键(keys)可用来获取集合中元素的值，但是可以判断一个元素是否在集合中。

二、 访问集合中的值

1

• 可以使用len()內建函数得到集合的大小。

【例子】

s = set(['Google', 'Baidu', 'Taobao'])
print(len(s))  # 3

这段代码展示了如何计算集合中元素的数量，并打印出结果。

首先，定义了一个集合 s，其中包含了三个元素 'Google'、'Baidu' 和 'Taobao'。

然后，使用 len(s) 来获取集合 s 中元素的数量。len() 是一个内置函数，用于返回集合、列表、字符串等对象中元素的数量。在这里，输出结果为 3，表示集合 s 中有三个元素。

2

• 可以使用for把集合中的数据一个个读取出来。

【例子】

s = set(['Google', 'Baidu', 'Taobao'])
for item in s:
    print(item)
    
# Baidu
# Google
# Taobao

这段代码展示了如何使用 for 循环遍历集合中的元素，并逐个打印出来。

首先，定义了一个集合 s，其中包含了三个元素 'Google'、'Baidu' 和 'Taobao'。

然后，使用 for item in s: 循环遍历集合 s 中的每个元素。在每次循环中，将当前元素赋值给变量 item，并执行循环体内的代码。在这里，循环体内使用 print(item) 打印出当前元素的值。

根据集合的无序性质，循环并不保证按照特定顺序遍历集合中的元素。所以输出结果可能是顺序不同的，但都会包含集合中的所有元素。

在这个例子中，可能的输出结果是：

Baidu
Google
Taobao

3

• 可以通过in或not in判断一个元素是否在集合中已经存在

【例子】

s = set(['Google', 'Baidu', 'Taobao'])
print('Taobao' in s)  # True
print('Facebook' not in s)  # True

这段代码展示了如何使用 in 和 not in 运算符来检查元素是否存在于集合中，并打印出结果。

首先，定义了一个集合 s，其中包含了三个元素 'Google'、'Baidu' 和 'Taobao'。

然后，使用 print('Taobao' in s) 来检查字符串 'Taobao' 是否存在于集合 s 中。in 运算符用于判断某个元素是否属于某个集合。如果 'Taobao' 存在于集合 s 中，则条件成立，输出结果为 True。

接着，使用 print('Facebook' not in s) 来检查字符串 'Facebook' 是否不存在于集合 s 中。not in 运算符用于判断某个元素是否不属于某个集合。如果 'Facebook' 不存在于集合 s 中，则条件成立，输出结果为 True。

这里的输出结果都为 True，表示 'Taobao' 存在于集合 s 中，而 'Facebook' 不存在于集合 s 中。

三、 集合的内置方法

1

• set.add(elmnt)用于给集合添加元素，如果添加的元素在集合中已存在，则不执行任何操作。

【例子】

fruits = {"apple", "banana", "cherry"}
fruits.add("orange")
print(fruits)  
# {'orange', 'cherry', 'banana', 'apple'}

fruits.add("apple")
print(fruits)  
# {'orange', 'cherry', 'banana', 'apple'}

这段代码展示了如何向集合中添加元素，并使用 add() 方法实现。

首先，定义了一个名为 fruits 的集合，其中包含了三个元素 "apple"、"banana" 和 "cherry"。

然后，使用 fruits.add("orange") 将字符串 "orange" 添加到集合 fruits 中。add() 是集合对象的方法，用于向集合中添加元素。在这里，将 "orange" 添加到集合 fruits 中。

接着，使用 print(fruits) 打印出集合 fruits 的内容，输出结果为 {'orange', 'cherry', 'banana', 'apple'}。可以看到，集合中的元素无序且唯一，包括了添加的新元素 "orange"。

最后，使用 fruits.add("apple") 尝试将字符串 "apple" 再次添加到集合中。由于集合中的元素必须唯一，因此重复添加的元素不会改变集合的内容。所以第二次添加元素 "apple" 并没有改变集合 fruits 的内容。

使用 add() 方法可以向集合中添加元素，但重复的元素不会被添加进去。

2

• set.update(set)用于修改当前集合，可以添加新的元素或集合到当前集合中，如果添加的元素在集合中已存在，则该元素只会出现一次，重复的会忽略。

【例子】

x = {"apple", "banana", "cherry"}
y = {"google", "baidu", "apple"}
x.update(y)
print(x)
# {'cherry', 'banana', 'apple', 'google', 'baidu'}

y.update(["lsgo", "dreamtech"])
print(y)
# {'lsgo', 'baidu', 'dreamtech', 'apple', 'google'}

这段代码展示了如何使用 update() 方法将一个集合的元素添加到另一个集合中。

首先，定义了两个集合 x 和 y。集合 x 包含了三个元素 "apple"、"banana" 和 "cherry"，集合 y 包含了三个元素 "google"、"baidu" 和 "apple"。

然后，使用 x.update(y) 将集合 y 的元素添加到集合 x 中。update() 是集合对象的方法，用于将指定集合的元素添加到当前集合中。在这里，将集合 y 的元素添加到集合 x 中，因此集合 x 的内容变为 {'cherry', 'banana', 'apple', 'google', 'baidu'}。

接着，使用 print(x) 打印出集合 x 的内容，输出结果为 {'cherry', 'banana', 'apple', 'google', 'baidu'}。可以看到，集合 x 包含了集合 y 的元素，并且元素的顺序是无序的。

然后，使用 y.update(["lsgo", "dreamtech"]) 将列表 ["lsgo", "dreamtech"] 的元素添加到集合 y 中。update() 方法可以接受多种类型的集合作为参数，包括列表。在这里，将列表 ["lsgo", "dreamtech"] 的元素添加到集合 y 中，因此集合 y 的内容变为 {'lsgo', 'baidu', 'dreamtech', 'apple', 'google'}。

最后，使用 print(y) 打印出集合 y 的内容，输出结果为 {'lsgo', 'baidu', 'dreamtech', 'apple', 'google'}。可以看到，集合 y 包含了列表的元素，并且元素的顺序是无序的。

使用 update() 方法可以将一个集合中的元素添加到另一个集合中，并且可以接受多种类型的集合作为参数。

3

• set.remove(item) 用于移除集合中的指定元素。如果元素不存在，则会发生错误。

【例子】

fruits = {"apple", "banana", "cherry"}
fruits.remove("banana")
print(fruits)  # {'apple', 'cherry'}

这段代码展示了如何使用 remove() 方法从集合中移除指定的元素。

首先，定义了一个名为 fruits 的集合，其中包含了三个元素 "apple"、"banana" 和 "cherry"。

然后，使用 fruits.remove("banana") 从集合 fruits 中移除元素 "banana"。remove() 是集合对象的方法，用于从集合中移除指定的元素。在这里，移除了集合 fruits 中的 "banana" 元素。

接着，使用 print(fruits) 打印出集合 fruits 的内容，输出结果为 {'apple', 'cherry'}。可以看到，集合 fruits 中已经没有了被移除的元素 "banana"。

使用 remove() 方法可以从集合中移除指定的元素。

4

• set.discard(value) 用于移除指定的集合元素。remove() 方法在移除一个不存在的元素时会发生错误，而 discard() 方法不会。

【例子】

fruits = {"apple", "banana", "cherry"}
fruits.discard("banana")
print(fruits)  # {'apple', 'cherry'}

这段代码展示了如何使用 discard() 方法从集合中移除指定的元素。

首先，定义了一个名为 fruits 的集合，其中包含了三个元素 "apple"、"banana" 和 "cherry"。

然后，使用 fruits.discard("banana") 从集合 fruits 中移除元素 "banana"。discard() 是集合对象的方法，用于从集合中移除指定的元素。与 remove() 方法不同的是，当要移除的元素不存在时，discard() 方法不会引发错误，而是保持集合原样。在这里，移除了集合 fruits 中的 "banana" 元素。

接着，使用 print(fruits) 打印出集合 fruits 的内容，输出结果为 {'apple', 'cherry'}。可以看到，集合 fruits 中已经没有了被移除的元素 "banana"。

使用 discard() 方法可以从集合中移除指定的元素，如果元素不存在也不会引发错误。

5

• set.pop() 用于随机移除一个元素。

【例子】

fruits = {"apple", "banana", "cherry"}
x = fruits.pop()
print(fruits)  # {'cherry', 'apple'}
print(x)  # banana

这段代码展示了如何使用 pop() 方法从集合中弹出一个元素。

首先，定义了一个名为 fruits 的集合，其中包含了三个元素 "apple"、"banana" 和 "cherry"。

然后，使用 x = fruits.pop() 将集合 fruits 中的一个元素弹出，并将其赋值给变量 x。pop() 是集合对象的方法，用于弹出集合中的一个元素。在这里，弹出了集合 fruits 中的一个元素，并将其赋值给变量 x。

接着，使用 print(fruits) 打印出集合 fruits 的内容，输出结果为 {'cherry', 'apple'}。可以看到，集合 fruits 中已经没有了被弹出的元素 "banana"。

然后，使用 print(x) 打印出变量 x 的值，输出结果为 banana。可以看到，变量 x 中保存了被弹出的元素 "banana"。

使用 pop() 方法可以从集合中弹出一个元素，并返回被弹出的元素的值。

6

由于 set 是无序和无重复元素的集合，所以两个或多个 set 可以做数学意义上的集合操作。

• set.intersection(set1, set2) 返回两个集合的交集。
• set1 & set2 返回两个集合的交集。
• set.intersection_update(set1, set2) 交集，在原始的集合上移除不重叠的元素。

【例子】

a = set('abracadabra')
b = set('alacazam')
print(a)  # {'r', 'a', 'c', 'b', 'd'}
print(b)  # {'c', 'a', 'l', 'm', 'z'}

c = a.intersection(b)
print(c)  # {'a', 'c'}
print(a & b)  # {'c', 'a'}
print(a)  # {'a', 'r', 'c', 'b', 'd'}

a.intersection_update(b)
print(a)  # {'a', 'c'}

这段代码展示了集合的交集操作和交集更新操作。

首先，定义了两个集合 a 和 b，分别包含了一些字符。集合是无序且不重复的数据结构，因此每个元素只会出现一次。

然后，使用 print(a) 打印出集合 a 的内容，输出结果为 {'r', 'a', 'c', 'b', 'd'}。可以看到，集合 a 中包含了字母 "a"、"b"、"c"、"d" 和 "r"。

接着，使用 print(b) 打印出集合 b 的内容，输出结果为 {'c', 'a', 'l', 'm', 'z'}。可以看到，集合 b 中包含了字母 "a"、"c"、"l"、"m" 和 "z"。

使用 intersection() 方法或操作符 & 可以获取集合 a 和 b 的交集。交集是指同时存在于两个集合中的元素。

• 使用 c = a.intersection(b) 获取集合 a 和 b 的交集，并将结果赋值给变量 c。打印 c 的内容，输出结果为 {'a', 'c'}，即集合 a 和 b 中同时存在的元素。

• 使用 print(a & b) 打印集合 a 和 b 的交集，输出结果同样为 {'a', 'c'}。

使用交集操作不会改变原始的集合 a 和 b。

接下来，使用 a.intersection_update(b) 将集合 a 更新为 a 和 b 的交集。intersection_update() 是集合对象的方法，用于修改原始集合，仅保留和另一个指定集合相交的元素。

使用 print(a) 打印更新后的集合 a 的内容，输出结果为 {'a', 'c'}。可以看到，集合 a 已经被更新为 a 和 b 的交集。

7

• set.union(set1, set2) 返回两个集合的并集。
• set1 | set2 返回两个集合的并集。

【例子】

a = set('abracadabra')
b = set('alacazam')
print(a)  # {'r', 'a', 'c', 'b', 'd'}
print(b)  # {'c', 'a', 'l', 'm', 'z'}

print(a | b)  
# {'l', 'd', 'm', 'b', 'a', 'r', 'z', 'c'}

c = a.union(b)
print(c)  
# {'c', 'a', 'd', 'm', 'r', 'b', 'z', 'l'}

这段代码展示了集合的并集操作。

首先，定义了两个集合 a 和 b，分别包含了一些字符。

然后，使用 print(a) 打印出集合 a 的内容，输出结果为 {'r', 'a', 'c', 'b', 'd'}。

接着，使用 print(b) 打印出集合 b 的内容，输出结果为 {'c', 'a', 'l', 'm', 'z'}。

使用 | 操作符或 union() 方法可以获取集合 a 和 b 的并集。并集是指合并两个集合中的所有元素，去除重复项。

• 使用 print(a | b) 打印集合 a 和 b 的并集，输出结果为 {'l', 'd', 'm', 'b', 'a', 'r', 'z', 'c'}。可以看到，输出的结果包含了集合 a 和 b 中的所有元素，去除了重复项。

• 使用 c = a.union(b) 将集合 a 和 b 的并集赋值给变量 c。使用 print(c) 打印变量 c 的内容，输出结果为 {'c', 'a', 'd', 'm', 'r', 'b', 'z', 'l'}。可以看到，输出的结果同样是集合 a 和 b 中的所有元素，去除了重复项。

注意，使用并集操作或 union() 方法不会改变原始的集合 a 和 b。

8

• set.difference(set) 返回集合的差集。
• set1 - set2 返回集合的差集。
• set.difference_update(set) 集合的差集，直接在原来的集合中移除元素，没有返回值。

【例子】

a = set('abracadabra')
b = set('alacazam')
print(a)  # {'r', 'a', 'c', 'b', 'd'}
print(b)  # {'c', 'a', 'l', 'm', 'z'}

c = a.difference(b)
print(c)  # {'b', 'd', 'r'}
print(a - b)  # {'d', 'b', 'r'}

print(a)  # {'r', 'd', 'c', 'a', 'b'}
a.difference_update(b)
print(a)  # {'d', 'r', 'b'}

这段代码展示了集合的差集操作和差集更新操作。

首先，定义了两个集合 a 和 b，分别包含了一些字符。

然后，使用 print(a) 打印出集合 a 的内容，输出结果为 {'r', 'a', 'c', 'b', 'd'}。

接着，使用 print(b) 打印出集合 b 的内容，输出结果为 {'c', 'a', 'l', 'm', 'z'}。

使用 difference() 方法或操作符 - 可以获取集合 a 相对于集合 b 的差集。差集是指在集合 a 中存在，但不在集合 b 中的元素。

• 使用 c = a.difference(b) 获取集合 a 相对于集合 b 的差集，并将结果赋值给变量 c。使用 print(c) 打印变量 c 的内容，输出结果为 {'b', 'd', 'r'}。可以看到，输出的结果包含了集合 a 中存在但集合 b 中不存在的元素。

• 使用 print(a - b) 打印集合 a 相对于集合 b 的差集，输出结果同样为 {'b', 'd', 'r'}。

使用差集操作不会改变原始的集合 a 和 b。

接下来，使用 a.difference_update(b) 将集合 a 更新为相对于集合 b 的差集。difference_update() 是集合对象的方法，用于修改原始集合，仅保留在原始集合中存在但不在指定集合中的元素。

使用 print(a) 打印更新后的集合 a 的内容，输出结果为 {'d', 'r', 'b'}。可以看到，集合 a 已经被更新为相对于集合 b 的差集。

9

• set.symmetric_difference(set)返回集合的异或。
• set1 ^ set2 返回集合的异或。
• set.symmetric_difference_update(set)移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。

【例子】

a = set('abracadabra')
b = set('alacazam')
print(a)  # {'r', 'a', 'c', 'b', 'd'}
print(b)  # {'c', 'a', 'l', 'm', 'z'}

c = a.symmetric_difference(b)
print(c)  # {'m', 'r', 'l', 'b', 'z', 'd'}
print(a ^ b)  # {'m', 'r', 'l', 'b', 'z', 'd'}

print(a)  # {'r', 'd', 'c', 'a', 'b'}
a.symmetric_difference_update(b)
print(a)  # {'r', 'b', 'm', 'l', 'z', 'd'}

这段代码展示了集合的对称差集操作和对称差集更新操作。

首先，定义了两个集合 a 和 b，分别包含了一些字符。

然后，使用 print(a) 打印出集合 a 的内容，输出结果为 {'r', 'a', 'c', 'b', 'd'}。

接着，使用 print(b) 打印出集合 b 的内容，输出结果为 {'c', 'a', 'l', 'm', 'z'}。

使用 symmetric_difference() 方法或操作符 ^ 可以获取集合 a 和集合 b 的对称差集。对称差集是指只在一个集合中出现，而不同时出现在两个集合中的元素。

• 使用 c = a.symmetric_difference(b) 获取集合 a 和集合 b 的对称差集，并将结果赋值给变量 c。使用 print(c) 打印变量 c 的内容，输出结果为 {'m', 'r', 'l', 'b', 'z', 'd'}。可以看到，输出的结果包含了只在集合 a 或集合 b 中出现的元素。

• 使用 print(a ^ b) 打印集合 a 和集合 b 的对称差集，输出结果同样为 {'m', 'r', 'l', 'b', 'z', 'd'}。

使用对称差集操作不会改变原始的集合 a 和 b。

接下来，使用 a.symmetric_difference_update(b) 将集合 a 更新为集合 a 和集合 b 的对称差集。symmetric_difference_update() 是集合对象的方法，用于修改原始集合，仅保留只在一个集合中出现的元素。

使用 print(a) 打印更新后的集合 a 的内容，输出结果为 {'r', 'b', 'm', 'l', 'z', 'd'}。可以看到，集合 a 已经被更新为集合 a 和集合 b 的对称差集。

10

• set.issubset(set)判断集合是不是被其他集合包含，如果是则返回 True，否则返回 False。
• set1 <= set2 判断集合是不是被其他集合包含，如果是则返回 True，否则返回 False。

【例子】

x = {"a", "b", "c"}
y = {"f", "e", "d", "c", "b", "a"}
z = x.issubset(y)
print(z)  # True
print(x <= y)  # True

x = {"a", "b", "c"}
y = {"f", "e", "d", "c", "b"}
z = x.issubset(y)
print(z)  # False
print(x <= y)  # False

这段代码展示了集合的子集操作。

首先，定义了两个集合 x 和 y，分别包含了一些元素。

然后，使用 issubset() 方法或操作符 <= 可以判断一个集合是否是另一个集合的子集。

• 使用 z = x.issubset(y) 将集合 x 是否是集合 y 的子集的结果赋值给变量 z。使用 print(z) 打印变量 z 的内容，输出结果为 True。可以看到，集合 x 是集合 y 的子集。

• 使用 print(x <= y) 打印集合 x 是否是集合 y 的子集，输出结果同样为 True。

如果集合 x 中的所有元素都存在于集合 y 中，则集合 x 是集合 y 的子集。

接下来，重新定义了集合 x 和 y，包含了一些不同的元素。

使用 issubset() 方法或操作符 <= 再次判断集合 x 是否是集合 y 的子集。

• 使用 z = x.issubset(y) 将集合 x 是否是集合 y 的子集的结果赋值给变量 z。使用 print(z) 打印变量 z 的内容，输出结果为 False。可以看到，集合 x 不是集合 y 的子集。

• 使用 print(x <= y) 打印集合 x 是否是集合 y 的子集，输出结果同样为 False。

如果集合 x 中的某些元素不存在于集合 y 中，则集合 x 不是集合 y 的子集。

11

• set.issuperset(set)用于判断集合是不是包含其他集合，如果是则返回 True，否则返回 False。
• set1 >= set2 判断集合是不是包含其他集合，如果是则返回 True，否则返回 False。

【例子】

x = {"f", "e", "d", "c", "b", "a"}
y = {"a", "b", "c"}
z = x.issuperset(y)
print(z)  # True
print(x >= y)  # True

x = {"f", "e", "d", "c", "b"}
y = {"a", "b", "c"}
z = x.issuperset(y)
print(z)  # False
print(x >= y)  # False

这段代码展示了集合的超集操作。

首先，定义了两个集合 x 和 y，分别包含了一些元素。

然后，使用 issuperset() 方法或操作符 >= 可以判断一个集合是否是另一个集合的超集。

• 使用 z = x.issuperset(y) 将集合 x 是否是集合 y 的超集的结果赋值给变量 z。使用 print(z) 打印变量 z 的内容，输出结果为 True。可以看到，集合 x 是集合 y 的超集。

• 使用 print(x >= y) 打印集合 x 是否是集合 y 的超集，输出结果同样为 True。

如果集合 y 中的所有元素都存在于集合 x 中，则集合 x 是集合 y 的超集。

接下来，重新定义了集合 x 和 y，包含了一些不同的元素。

使用 issuperset() 方法或操作符 >= 再次判断集合 x 是否是集合 y 的超集。

• 使用 z = x.issuperset(y) 将集合 x 是否是集合 y 的超集的结果赋值给变量 z。使用 print(z) 打印变量 z 的内容，输出结果为 False。可以看到，集合 x 不是集合 y 的超集。

• 使用 print(x >= y) 打印集合 x 是否是集合 y 的超集，输出结果同样为 False。

如果集合 y 中的某些元素不存在于集合 x 中，则集合 x 不是集合 y 的超集。

12

• set.isdisjoint(set) 用于判断两个集合是不是不相交，如果是返回 True，否则返回 False。

【例子】

x = {"f", "e", "d", "c", "b"}
y = {"a", "b", "c"}
z = x.isdisjoint(y)
print(z)  # False

x = {"f", "e", "d", "m", "g"}
y = {"a", "b", "c"}
z = x.isdisjoint(y)
print(z)  # True

这段代码展示了集合的不相交操作。

首先，定义了两个集合 x 和 y，分别包含了一些元素。

然后，使用 isdisjoint() 方法可以判断两个集合是否没有交集，即是否不存在相同的元素。

• 使用 z = x.isdisjoint(y) 将判断集合 x 和 y 是否不相交的结果赋值给变量 z。使用 print(z) 打印变量 z 的内容，输出结果为 False。可以看到，集合 x 和集合 y 存在相同的元素，因此它们不是不相交的。

接下来，重新定义了集合 x 和 y，包含了一些不同的元素。

使用 isdisjoint() 方法再次判断集合 x 和 y 是否不相交。

• 使用 z = x.isdisjoint(y) 将判断集合 x 和 y 是否不相交的结果赋值给变量 z。使用 print(z) 打印变量 z 的内容，输出结果为 True。可以看到，集合 x 和集合 y 不存在相同的元素，因此它们是不相交的。

如果两个集合没有任何相同的元素，则它们被认为是不相交的。

四、 集合的转换

【例子】

se = set(range(4))
li = list(se)
tu = tuple(se)

print(se, type(se))  # {0, 1, 2, 3} <class 'set'>
print(li, type(li))  # [0, 1, 2, 3] <class 'list'>
print(tu, type(tu))  # (0, 1, 2, 3) <class 'tuple'>

这段代码展示了将集合转换为列表和元组的操作。

首先，使用 set() 函数创建了一个集合 se，包含了数字 0、1、2 和 3。

然后，分别使用 list() 函数和 tuple() 函数将集合 se 转换为列表和元组。

• 使用 li = list(se) 将集合 se 转换为列表，并将结果赋值给变量 li。
• 使用 tu = tuple(se) 将集合 se 转换为元组，并将结果赋值给变量 tu。

接下来，使用 print() 函数分别打印了集合、列表和元组的内容以及它们的类型。

• 使用 print(se, type(se)) 打印集合 se 的内容和类型，输出结果为 {0, 1, 2, 3} <class 'set'>。可以看到，集合保留了不重复的元素，并且类型为 set。
• 使用 print(li, type(li)) 打印列表 li 的内容和类型，输出结果为 [0, 1, 2, 3] <class 'list'>。可以看到，列表按照顺序包含了集合中的元素，并且类型为 list。
• 使用 print(tu, type(tu)) 打印元组 tu 的内容和类型，输出结果为 (0, 1, 2, 3) <class 'tuple'>。可以看到，元组按照顺序包含了集合中的元素，并且类型为 tuple。

这些操作可以用于将集合转换为其他数据类型的序列，进而进行更多的操作和处理。

五、 不可变集合

Python 提供了不能改变元素的集合的实现版本，即不能增加或删除元素，类型名叫frozenset。需要注意的是frozenset仍然可以进行集合操作，只是不能用带有update的方法。

• frozenset([iterable]) 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

【例子】

a = frozenset(range(10))  # 生成一个新的不可变集合
print(a)  
# frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})

b = frozenset('lsgogroup')
print(b)  
# frozenset({'g', 's', 'p', 'r', 'u', 'o', 'l'})

这段代码展示了如何创建和使用不可变集合（frozenset）。

首先，使用 frozenset() 函数创建了一个新的不可变集合 a，包含了数字 0 到 9。

• 使用 frozenset(range(10)) 创建一个不可变集合，并将结果赋值给变量 a。由于集合是不可变的，因此无法对其进行修改或添加/删除元素。

接下来，使用 print() 函数打印了不可变集合 a 的内容。

• 使用 print(a) 打印不可变集合 a 的内容，输出结果为 frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})。可以看到，不可变集合按照顺序包含了数字 0 到 9。

然后，使用 frozenset() 函数创建了另一个新的不可变集合 b，包含了字符串 'lsgogroup' 中的字符。

• 使用 frozenset('lsgogroup') 创建一个不可变集合，并将结果赋值给变量 b。同样地，由于集合是不可变的，无法对其进行修改或添加/删除元素。

最后，使用 print() 函数打印了不可变集合 b 的内容。

• 使用 print(b) 打印不可变集合 b 的内容，输出结果为 frozenset({'g', 's', 'p', 'r', 'u', 'o', 'l'})。可以看到，不可变集合按照顺序包含了字符串 'lsgogroup' 中的不重复字符。

不可变集合是无法进行修改的，但可以用于作为字典的键或其他需要不可变性的场景。

如有错误欢迎指正，谢谢！