第七章 集合

1. 【交集】“&”

语法参考

可以使用“&”符号来计算两个或更多集合的交集，即返回集合a和集合b中都包含的元素。其语法格式如下：

set_a & set_b           # 相当于set_a.intersection(set_b)

参数说明：

• set_a：集合a。

• set_b：集合b，参数可以是一个或多个集合。

• 返回值：返回集合的交集。

锦囊1 计算两个集合的交集

通过“&”计算两个集合的交集，示例代码如下：

# 创建集合
a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

# 返回集合的交集
print("a、b的交集：", a & b)               # 返回{3, 4}

锦囊2 计算多个集合的交集

通过“&”不仅可以计算两个集合的交集，还可以计算多个集合的交集，示例代码如下：

# 创建集合
surname1 = {'赵', '钱', '孙', '李'}
surname2 = {'周', '赵', '王', '孙'}
surname3 = {'赵', '孙', '褚', '陈'}

print('多个集合的交集为：', surname1 & surname2 & surname3 )

锦囊3 在集合中“&”不等于“and”

在python 中 “&”代表的是位运算符，而“and”代表的是逻辑运算符，当 set1 and set2的结果为True 时，返回的结果并不是True，而是运算结果的最后一位变量的值，这里返回的是set2的值。

当set1 & set2 时，则表示求set1和set2的交集（获取两个集合共同拥有的元素）。示例代码如下：

list1 = [1,3,5,7,9,9,1]   		# 列表数据1
list2 = [2,4,6,7,8,7,4]   		# 列表数据2
set1 = set(list1)         		# 将列表1转换为集合1
set2 = set(list2)         		# 将列表2转换为集合2

print('and结果为：',set1 and set2)
print('&结果为：',set1 & set2)

2. 【对称差集】“^”

语法参考

可以使用“^”符号来计算两个集合的对称差集。即返回由集合a和集合b中不重复的元素组成的集合。其语法格式如下：

set_a ^ set_b               # 相当于set_a.symmetric_difference(set_b)

参数说明：

• set_a：集合a。

• set_b：集合b。

• 返回值：返回对称差集。

锦囊1 计算集合的对称差集

通过“^”计算集合的对称差集，示例代码如下：

# 创建集合
a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
c = {1, 3, 10}

# 返回集合的对称差集
print("a、b的对称差集：", a ^ b)                           	# 返回{1, 2, 5, 6}
print("a、c的对称差集：", a ^ c)                           	# 返回{2, 4, 10}
print("b、c的对称差集：", b.symmetric_difference(c))     		# 返回{1, 4, 5, 6, 10}

3. 【直接创建集合】“{}”

语法参考

在Python中，创建set集合也可以像列表、元组和字典一样，直接将集合赋值给变量从而实现创建集合，即直接使用大括号“{}”创建。语法格式如下：

setname = {element 1,element 2,element 3,…,element n}

参数说明：

• setname：表示集合名称，可以是任何符合Python命名规则的标识符；

• kelemnet 1、elemnet 2、elemnet 3、elemnet n：表示集合中的元素，个数没有限制，并且只要是Python支持的不可变数据类型（如字符串、数字、元组及布尔类型的True或者False等，但不能是列表、字典等）就可以。

注意：在创建集合时，如果输入了重复的元素，Python会自动只保留一个。

锦囊1 直接创建集合并输出

使用“{}”直接创建集合并输出，示例代码如下：

# 创建10以内奇数的集合
set1 = {1,3,5,7,9} 
print('set1：', set1)

# 部分大写英文字母的集合
set2 = {'A','B','C','D','E'}
print('set2：', set2)

# 手机品牌名称字符的集合
set3 = {'华为','vivo','OPPO','小米' }
print('set3：', set3)

# 不同类型数据的集合
set4 = {'Python', 28, ('人生苦短', '我用Python')} 
print('set4：', set4)

# 保存学生信息元组的集合
set5 = {('1001','无语',98,100,96),('1002','琦琦',100,96,97)} 
print('set6：', set5)

set6 = {'a', 'b', 'c', 'a' , 'd', True}
print('set6：', set6)

说明：由于Python中的set集合是无序的，所以每次输出时元素的排列顺序可能都不相同。

锦囊2 循环遍历集合中的元素

创建集合，并使用for循环遍历集合中的元素，示例代码如下：

# 直接创建集合
url = {"www.sohu.com", "www.sina.com", "www.baidu.com", "www.taobao.com"}

# 输出集合元素
for i in url:
    print(i)       					

锦囊3 通过列表、字典等可变对象作为集合元素

集合中的元素，不能是列表、字典等可变对象。否则将提示TypeError错误。示例代码如下：

# 集合中的元素，不能是列表、字典等可变对象
set1 = {88, [75, 66.5], 62}   			# 提示TypeError: unhashable type: 'list'
set2 = {1, {"one":1}, 2}     			# 提示TypeError: unhashable type: 'dict'

4. 【并集】“|”

语法参考

可以使用“&”符号来计算两个或更多集合的交集，即返回集合a和集合b中都包含的元素。其语法格式如下：

set_a | set_b              # 相当于set_a.union(set_b)

参数说明：

• set_a：集合a。

• set_b：集合b，参数可以是一个或多个集合。

• 返回值：返回集合的并集。

提示：集合的并集操作，也可以使用union()方法。

提示：执行集合的并集操作时，重复的元素会自动保留一个。

锦囊1 计算集合的并集

通过“|”计算集合的并集，示例代码如下：

# 创建集合
a = {1, 2}
b = {3, 4, 5, 6}
c = {1, 3, 10}

# 返回集合的并集
print("a、b的并集：", a | b)          		# 返回{1, 2, 3, 4, 5, 6}
print("a、b、c的并集：", a | b | c)   		# 返回{1, 2, 3, 4, 5, 6, 10}
print("a、c的并集：", a.union(c))     		# 返回{1, 2, 3, 10}

锦囊2 在集合中“|”不等于“or”

在python 中 “|”代表的是位运算符，而“or”代表的是逻辑运算符，当 set1 or set2 的结果为True的时候，将返回第一个真的变量值，这里返回的是set1。

当set1 |set2 时，则表示求set1和set2的并集（相当于合并两个集合，去除重复元素）。示例代码如下：

a = 'python'      							# 字符数据a
b = 'pycharm'     							# 字符数据b

set1 = set(a)     							# 将字符a转换为集合1
set2 = set(b)     							# 将字符b转换为集合2

print('or结果为：',set1 or set2)
print('|结果为：',set1|set2)

5. 【差集】“-”

语法参考

可以使用“-”符号来计算两个或更多集合的差集。即集合元素包含在集合a中，但不包含在集合b中。其语法格式如下：

set_a - set_b               # 相当于set_a.difference(set_b)

参数说明：

• set_a：集合a。

• set_b：集合b，参数可以是一个或多个集合。

• 返回值：返回集合的差集。

锦囊1 计算集合的差集

通过“-”计算集合的差集，示例代码如下：

# 创建集合
a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
c = {1, 3, 10}

# 返回集合的差集
print("a与b的差集：", a - b)              		# 返回{1, 2}
print("a与c的差集：", a - c)              		# 返回{2, 4}
print("a与b、c的差集：", a - b - c)       		# 返回{2}
print("b与c的差集：", b.difference(c))    		# 返回{4, 5, 6}
print("c与b的差集：", c.difference(b))    		# 返回{1, 10}

6. 【判断当前集合是否为另一个集合的子集】“<=”

语法参考

可以使用“<=”运算符判断当前集合是否为另一个集合的子集，即判断集合a中的所有元素是否都包含在集合b中。其语法格式如下：

set_a <= set_b           # 相当于set_a.issubset(set_b)

参数说明：

• set_a：集合a。

• set_b：集合b。

• 返回值：返回布尔值，如果集合a中的所有元素都包含在集合b中，则返回True，否则返回False。

锦囊1 判断一个集合是否为另一个集合的子集

使用“<=”运算符判断当前集合是否为另一个集合的子集，示例代码如下：

# 创建集合
a = {1, 2, 3, 4}
b = {1, 3, 4, 5, 6}
c = {1, 3}
d = {3, 1}

# 判断集合是否为另一个集合的子集
print("a<=b返回：", a <= b)                      		# 返回False
print("c<=a返回：",c <= a)                       		# 返回True
print("c<=d返回：",c <= d)                       		# 返回True
print("c.issubset(b)返回：", c.issubset(b))      		# 返回True

锦囊2 使用“<”运算符判断当前集合是否为另一个集合的真子集

可以使用“<”运算符判断当前集合是否为另一个集合的真子集，语法格式如下：

set_a < set_b            # 真子集

子集就是一个集合中的全部元素是另一个集合中的元素，有可能与另一个集合相等；真子集就是一个集合中的元素全部是另一个集合中的元素，但不存在相等。代码如下：

# 创建集合
a = {"Python", "Java"}
b = {"Java", "Python"}
c = {"Java","PHP","C#"}

# 判断一个集合是否为另一个集合的子集
print("a<=b返回：",a <= b)             		# 返回True
print("a<=c返回：",a <= c)             		# 返回False

# 判断一个集合是否为另一个集合的真子集
print("a<b返回：", a < b)              		# 返回False
print("a<c返回：", a < c)              		# 返回False

7. 【判断两个集合是否相等】“==”

语法参考

可以使用“==”运算符判断两个集合是否相等（包含相同的元素），即判断集合a和集合b中的元素是否相同。其语法格式如下：

set_a == set_b

参数说明：

• set_a：集合a。

• set_b：集合b。

• 返回值：返回布尔值，如果集合a和集合b中的元素相同，则返回True，否则返回False。

提示：!=与==刚好相反，如果集合a和集合b中的元素相同，则返回False，否则返回True。

锦囊1 判断两个集合是否相等

使用“==”运算符判断两个集合是否相等，示例代码如下：

# 创建集合
a = {"刀", "枪", "剑", "戟"}
b = {"戟", "剑", "枪", "刀"}
c = {"斧", "钺", "钩", "叉"}

# 判断两个集合是否相等
print("a==b返回：", a == b)       		# 返回True
print("a==c返回：", a == c)       		# 返回False
print("a!=b返回：", a != b)       		# 返回False
print("a!=c返回：", a != c)       		# 返回True

8. 【判断当前集合是否为另一个集合的超集】“>=”

语法参考

可以使用“>=”运算符判断当前集合是否为另一个集合的超集，即判断集合b中的所有元素是否都包含在集合a中。其语法格式如下：

set_a >= set_b           # 相当于set_a.issuperset(set_b)

参数说明：

• set_a：集合a。

• set_b：集合b。

• 返回值：返回布尔值，如果集合b中的所有元素都包含在集合a中，则返回True，否则返回False。

锦囊1 判断一个集合是否为另一个集合的超集

使用“>=”运算符判断当前集合是否为另一个集合的超集，示例代码如下：

# 创建集合
a = {'赵','钱','孙','李'}
b = {'赵','孙','李','周','吴'}
c = {'赵','孙'}
d = {'王','郑'}

# 判断集合是否为另一个集合的超集
print("a>=b返回：", a >= b)                        		# 返回False
print("b>=c返回：", b >= c)                        		# 返回True
print("a>=c返回：", a >= c)                        		# 返回True
print("a.issuperset(d)返回：", a.issuperset(d))    		# 返回False

锦囊2 使用“>”运算符判断当前集合是否为另一个集合的真超集

可以使用“>”运算符判断当前集合是否为另一个集合的真超集，语法格式如下：

set_a > set_b            # 真超集

如果集合b中的每一个元素都在集合a中，且集合a中可能包含集合b中没有的元素，则集合a就是集合b的超集（有可能与另一个集合相等）；若集合a中一定有集合b中没有的元素，则集合a是集合b的真超集（不存在相等）。示例代码如下：

# 创建集合
a = {"001", "003", "005"}
b = {"003", "005"}
c = {"005", "003"}

# 判断一个集合是否为另一个集合的超集
print("a>=b返回：",a >= b)           		# 返回True
print("b>=c返回：",b >= c)           		# 返回True

# 判断一个集合是否为另一个集合的真超集
print("a>b返回：", a > b)           			# 返回True
print("b>c返回：", b > c)           			# 返回False

9. 【向集合中添加元素】add()方法

语法参考

集合中的add()方法用于向集合中添加元素，如果添加的元素在集合中已存在，则不执行任何操作。其语法格式如下：

set.add(element)

参数说明：

• set：表示要添加元素的集合。

• element：表示要添加的元素内容，只能使用字符串、数字、元组及布尔类型的True或者False等不可变对象，但不能使用列表、字典等可变对象。

锦囊1 将指定元素添加到集合当中

使用add()方法将指定元素添加到集合中，示例代码如下：

university = {"麻省理工学院","斯坦福大学","哈佛大学","加州理工学院",}
print("添加元素前：", university)

university.add("牛津大学")            		# 添加一个元素
print("添加元素后：", university)

锦囊2 向集合中添加已经存在的元素

使用集合的add()方法时，如果要添加的元素在集合中已存在，则不执行添加操作，示例代码如下：

language_set = {'Python','C','C++','Java','PHP'}    	# 集合数据
print('添加元素前：',language_set)

language_set.add('Python')                          	# 向集合中添加已经存在的元素
print('添加已存在元素后：',language_set)

注意：集合add()方法的element参数只能使用字符串、数字、元组及布尔类型的True或者False等不可变对象，但不能使用列表、字典等可变对象。否则将提示TypeError错误。

10. 【删除集合中的全部元素】clear()方法

语法参考

集合中的clear()方法用于删除集合中的全部元素，使其变为空集合。其语法格式如下：

set.clear()

锦囊1 删除集合中的全部元素

使用clear()方法删除集合中的全部元素，示例代码如下：

song = set(['Forever', 'I Need You', 'Hello'])   	# 使用set()函数将列表转换为集合
print("清空元素前：", song)

song.clear()                    					# 清空集合
print("清空元素后：", song)     						# 空集合

提示：我们可以使用del set命令删除整个集合。但del语句在实际开发时，并不常用。因为Python自带的垃圾回收机制会自动销毁不用的集合，所以即使我们不手动将其删除，Python也会自动将其回收。

11. 【复制一个集合】copy()方法

语法参考

集合中的copy()方法用于复制一个集合。其语法格式如下：

set.copy()

参数说明：

• set：表示需要复制的集合。

• 返回值：返回复制后的新集合。

锦囊1 复制一个集合

使用copy()方法复制一个集合，示例代码如下：

old_num = set(["0002", "0001", "0003"])     		# 将列表转换为集合
new_num = old_num.copy()                     		# 复制集合
print(new_num)

锦囊2 直接赋值和copy()方法的区别

使用“=”直接赋值，是引用赋值，更改一个，另一个同样会变。copy()方法复制一个副本，原值和新复制的变量互不影响。代码如下：

a = {1, 2, 3, 4, 5}              # 创建集合a
b = a                            # 直接赋值
c = a.copy()                     # 复制一个集合

print("a：", a,)
print("b：", b,)
print("c：", c, "\n")

a.add("Python")                  # 添加指定元素到集合a
print("a：", a,)
print("b：", b,)
print("c：", c, "\n")

b.discard(5)                     # 移除b中的指定元素
print("a：", a,)
print("b：", b,)
print("c：", c, "\n")

c.clear()                       # 清空集合c
print("a：", a,)
print("b：", b,)
print("c：", c,)

12. 【返回集合的差集】difference()方法

语法参考

difference() 方法用于返回集合的差集，即返回的集合元素包含在第一个集合中，但不包含在第二个集合(方法的参数)中。其语法格式如下：

set_a.difference(set_b)                # 相当于set_a - set_b

参数说明：

• set_a：集合a。

• set_b：集合b，参数可以是集合或其他的可迭代对象（如列表、元组、字典等），可以是一个或多个可迭代对象，多个可迭代对象之间用逗号隔开。

• 返回值：返回集合的差集。

锦囊1 返回集合的差集

使用difference()方法返回集合的差集，示例代码如下：

x = {1, 2, 3, 4, 5, 6, 7, 8, 9}     				# 创建集合x
y = {0, 2, 4, 6, 8, 10, 12}          				# 创建集合y
z = [9, 10, 50, 100]                 				# 创建列表z

#  返回集合的差集
print("属于x且不属于y的元素：", x.difference(y))
print("属于y且不属于x的元素：", y.difference(x))
print("属于y且不属于x和z的元素：", y.difference(x,z))

锦囊2 通过集合间接获取列表的差集

首先将列表转换为集合，再使用difference()方法获取集合的差集，再将结果转换为列表，从而间接实现获取列表的差集，示例代码如下：

def difference(a, b):
    set_a = set(a)  							# 转化为集合
    set_b = set(b)  							# 转化为集合
    comparison = set_a.difference(set_b) 		# 返回集合的差集
    return list(comparison) 					# 返回集合

print(difference([1,2,3], [1,2,4]))

13. 【将原集合更新为两个集合的差集】difference_update()方法

语法参考

集合中的difference_update()方法用于将原集合更新为两个集合的差集，即把集合a更新为集合a与集合b的差集（集合元素包含在集合a中，但不包含在集合b中），但不改变集合b。其语法格式如下：

set_a.difference_update(set_b)

参数说明：

• set_a：集合a。

• set_b：集合b，参数可以是集合或其他的可迭代对象（如列表、元组、字典等），可以是一个或多个可迭代对象，多个可迭代对象之间用逗号隔开。

• 返回值：None。

锦囊1 将原集合更新为两个或多个集合的差集

使用difference_update()方法将原集合更新为两个或多个集合的差集，代码如下：

a = {1, 2, 3, 4}                 	# 创建集合a
b = {0, 2, 4, 9}                 	# 创建集合b
c = [0, 9, 10, 50]               	# 创建列表c
print("更新前的集合a：", a)

a.difference_update(b,c)         	# 更新a为a与b、c的差集
print("更新后的集合a：", a)
print("更新前的集合b：", b)

b.difference_update(c)           	# 更新b为b与c的差集
print("更新后的集合b：", b)

锦囊2 difference()方法和difference_update()方法的区别

集合中difference()方法和difference_update()方法都是将多个可迭代的集合取差集，但是返回的结果和对原集合的影响却不一样。difference()方法将集合a和集合b取差集（返回的集合元素包含在集合a中，但不包含在集合b中），并将差集作为一个新的集合返回，但是不改变原集合a和原集合b。difference_update()方法将集合a和集合b取差集，并将结果更新到集合a中，但不改变集合b，该方法没有返回值。代码如下：

print("*********** difference()方法 ***********")
a = {"赵", "钱", "孙", "李", "周"}        	# 创建集合a
b = {"孙", "李"}                          	# 创建集合b

print("取差集前的集合a：", a)
print("取差集前的集合b：", b)

a.difference(b)                            	# 返回集合的差集
print("返回：", a.difference(b))         	# 生成集合的差集并返回
print("取差集后的集合a：", a)             	# 不改变集合a
print("取差集后的集合b：", b)             	# 不改变集合b

 

print("\n******** difference_update()方法 ********")
a = {"赵", "钱", "孙", "李", "周"}        	# 创建集合a
b = {"孙", "李"}                           	# 创建集合b

print("更新前的集合a：", a)
print("更新前的集合b：", b)

a.difference_update(b)                     	# 更新原集合为两个集合的差集
print("返回：", a.difference_update(b))   	# 返回None
print("更新后的集合a：", a)                	# 更新集合a
print("更新后的集合b：", b)                	# 不改变集合b

14. 【删除集合中的指定元素】discard()方法

语法参考

集合中的discard()方法用于删除集合中的指定元素。如果要删除的指定元素不存在，不会报错。其语法格式如下：

set.discard(element)

参数说明：

• set：表示要删除指定元素的集合。

• element：集合中指定要删除的元素。

锦囊1 删除集合中的指定元素

使用discard()方法删除集合中的指定元素，示例代码如下：

language = {"Java", "C", "C++", "Python"}    		# 创建集合
print("删除指定元素前：", language)

language.discard("Java")         					# 删除"Java"元素
print("删除指定元素后：", language)

锦囊2 discard()方法与remove()方法的区别

集合discard()方法与remove()方法类似，都可以删除集合中的指定元素，二者的不同在于，当删除一个不存在的元素时，remove()方法会抛出KeyError异常，而discard()方法不会报错。代码如下：

s = {"Java", "C", "Python"}    		# 创建集合
# 要删除的指定元素不在集合中

s.remove("PHP")                		# remove()方法会抛出KeyError异常，提示KeyError: 'PHP'
s.discard("PHP")               		# discard()方法不会报错

15.【将可迭代对象转换为不可变集合】frozenset()函数

语法参考

frozenset()函数根据传入的可迭代对象创建一个新的不可变集合（冻结集合），一旦创建后就无法增加、删除和修改任何元素。其语法格式如下：

frozenset([iterable])

参数说明：

• iterable：可迭代的对象，如列表、字符串、元组、range对象等；

• 返回值：返回一个新的不可以变集合对象，如果不提供任何参数，默认会生成空的不可变集合。

锦囊1 创建一个新的不可变集合

根据传入的参数创建一个新的不可变集合，示例代码如下：

print(frozenset())                  	# 不传入参数，生成空的不可变集合
print(frozenset('Happy'))         		# 将字符串转换为不可变集合，返回不重复字符的集合
print(frozenset(range(15)))        		# 将range对象转换为不可变集合
print(frozenset([0,1,2,3,4,5]))    		# 将列表转换为不可变集合

锦囊2 对比两个不可变集合对象的创建顺序

通过指定的字符串创建不可变集合对象，同时再创建0到9的不可变集合对象，最后对比输出两个不可变集合对象的创建顺序，示例代码如下：

s="mingrisoft"
fs=frozenset(s)      					# 将字符串转换为不可变集合
flistnum=frozenset([0,1,2,3,4,5,6,7,8,9])
fliststr=frozenset(['m','i','n','g','r','i','s','o','f','t'])

print(str(fs))
print(str(flistnum))

16. 【返回集合的交集】intersection()方法

语法参考

集合intersection()方法用于返回集合的交集，即返回集合a和集合b中都包含的元素。但是不改变原集合a和原集合b。其语法格式如下：

set_a.intersection(set_b)           # 相当于set_a & set_b

参数说明：

• set_a：集合a。

• set_b：集合b，可以是集合或其他的可迭代对象（如列表、元组、字典等），可以是一个或多个可迭代对象，多个可迭代对象之间用逗号隔开。

• 返回值：将多个集合取交集，并将交集作为一个新的集合返回。

锦囊1 返回两个或多个集合中都包含的元素

使用intersection()方法返回两个或多个集合中都包含的元素。示例代码如下：

n1 = {0,1,2,3,4,5,6,7,8,9}             							# 创建集合
n2 = (2,11,20,9)                        						# 创建元组
n3 = [50,100,1,8,9]                     						# 创建列表
n4 = []                                  						# 创建空列表

# 返回集合的交集
print("n1、n2的交集：", n1.intersection(n2))
print("n1、n3的交集：", n1.intersection(n3))
print("n1、n2、n3的交集：", n1.intersection(n2, n3))
print("n1、n2、n3、n4的交集：", n1.intersection(n2, n3, n4))     	# 返回空集合

17. 【更新原集合为两个集合的交集】intersection_update()方法

语法参考

集合中的intersection_update()方法用于更新原集合为两个集合的交集，即把集合a更新为集合a与集合b的交集，但不改变集合b。其语法格式如下：

set_a.intersection_update(set_b)

参数说明：

• set_a：集合a。

• set_b：集合b，参数可以是集合或其他的可迭代对象（如列表、元组、字典等），可以是一个或多个可迭代对象，多个可迭代对象之间用逗号隔开。

• 返回值：None。

锦囊1 将指定集合更新为两个或多个集合的交集

使用intersection_update()方法将指定集合更新为两个或多个集合的交集。示例代码如下：

n1 = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}     		# 创建集合n1
n2 = {1, 2, 9, 11, 20}                  		# 创建集合n2
n3 = [1, 8, 9, 20, 50, 100]             		# 创建列表n3
print("更新前的集合n1：", n1)

n1.intersection_update(n2, n3)          		# 更新n1为n1、n2、n3的交集
print("更新后的集合n1：", n1)
print("更新前的集合n2：", n2)

n2.intersection_update(n3)              		# 更新n2为n2与n3的交集
print("更新后的集合n2：", n2)

锦囊2 intersection()方法和intersection_update()方法的区别

集合intersection()方法和intersection_update()方法都是将多个可迭代的集合取交集，但是返回的结果和对原集合的影响却不一样。intersection()方法将集合a和集合b取交集，并将交集作为一个新的集合返回，但是不改变原集合a和原集合b。intersection_update()方法将集合a和集合b取交集，并将结果更新到（添加到）集合a中，但不改变集合b，该方法没有返回值。示例代码如下：

print("*********** intersection()方法 ***********")
a = {1, 2, 3, 4, 5}                    		# 创建集合a
b = {5, 6, 7, 8}                       		# 创建集合b
print("取交集前的集合a：", a)
print("取交集前的集合b：", b)

a.intersection(b)                        	# 返回集合的交集
print("返回：", a.intersection(b))      		# 生成集合的交集并返回
print("取交集后的集合a：", a)           		# 不改变集合a
print("取交集后的集合b：", b)           		# 不改变集合b

 

print("\n******** intersection_update()方法 ********")
a = {1, 2, 3, 4, 5}                      	# 创建集合a
b = {5, 6, 7, 8}                         	# 创建集合b
print("更新前的集合a：", a)
print("更新前的集合b：", b)

a.intersection_update(b)                  	# 更新原集合为两个集合的交集
print("返回：", a.intersection_update(b))   	# 返回None
print("更新后的集合a：", a)              		# 更新集合a
print("更新后的集合b：", b)              		# 不改变集合b

18. 【判断两个集合是否包含相同的元素】isdisjoint()方法

语法参考

集合中的isdisjoint()方法用于判断两个集合是否包含相同的元素，如果两个集合没有相同元素则返回True，有相同元素则返回False。其语法格式如下：

set_a.isdisjoint(set_b)

参数说明：

• set_a：集合a。

• set_b：集合b，可以是一个集合或其他的可迭代对象（如列表、元组、字典等）。

• 返回值：返回布尔值，如果两个集合没有相同元素则返回True，否则返回 False。

锦囊1 判断两个集合是否包含相同的元素

使用isdisjoint()方法判断两个集合是否包含相同的元素，示例代码如下：

x = {"one", "two", "three", "four"}     		# 创建集合x
y = {"three", "four", "five"}           		# 创建集合y
z = ("zero", 1, 2, 3)                   		# 创建元组z

print(x.isdisjoint(y))                  		# x和y中有相同的元素，返回False
print(x.isdisjoint(z))                  		# x和z中没有相同的元素，返回True
print(y.isdisjoint(z))                  		# y和z中没有相同的元素，返回True

19. 【判断一个集合是否为另一个集合的子集】issubset()方法

语法参考

集合中的issubset()方法用于判断一个集合是否为另一个集合的子集，即判断集合a中的所有元素是否都包含在集合b中。如果都包含在集合b中，则返回True，否则返回False。其语法格式如下：

set_a.issubset(set_b)               # 相当于set_a < set_b

参数说明：

• set_a：集合a。

• set_b：集合b，可以是一个集合或其他的可迭代对象（如列表、元组、字典等）。

• 返回值：返回布尔值，如果集合a中的所有元素都包含在集合b中则返回True，否则返回False。

锦囊1 判断一个集合是否为另一个集合的子集

使用issubset()方法判断一个集合是否为另一个集合的子集。示例代码如下：

s1 = {"Java", "C"}                 						# 创建集合s1
s2 = {"PHP", "C++", "Python"}      						# 创建集合s2
s3 = ["Java", "C", "PHP", "C++", "Python", "C#"]   		# 创建列表s3

# 判断集合是否为另一个集合的子集
print(s1.issubset(s2))             						# s1不是s2的子集
print(s1.issubset(s3))             						# s1是s3的子集
print(s2.issubset(s3))             						# s2是s3的子集

20. 【判断一个集合是否为另一个集合的超集】issuperset()方法

语法参考

集合中的issuperset()方法用于判断一个集合是否为另一个集合的超集，即判断集合b中的所有元素是否都包含在集合a中。如果都包含在集合a中，则返回True，否则返回False。其语法格式如下：

set_a.issuperset(set_b)

参数说明：

• set_a：集合a。

• set_b：集合b，可以是一个集合或其他的可迭代对象（如列表、元组、字典等）。

• 返回值：返回布尔值，如果集合b中的所有元素都包含在集合a中则返回True，否则返回False。

锦囊1 判断一个集合是否为另一个集合的超集

使用issuperset()方法判断一个集合是否为另一个集合的超集，示例代码如下：

m1 = {"战狼2", "流浪地球", "红海行动", "美人鱼"}      		# 创建集合m1
m2 = {"红海行动", "美人鱼"}                           	# 创建集合m2
m3 = ("我不是药神", "速度与激情8")                    	# 创建元组m3
m4 = ["美人鱼"]                                       	# 创建列表m4

print("m1.issuperset(m2)：", m1.issuperset(m2))       	# m1是m2的超集
print("m1.issuperset(m3)：", m1.issuperset(m3))       	# m1不是m3的超集
print("m2.issuperset(m3)：", m2.issuperset(m3))       	# m2不是m3的超集
print("m2.issuperset(m4)：", m2.issuperset(m4))       	# m2是m4的超集

21. 【随机删除集合中的一个元素并返回该元素】pop()方法

语法参考

集合中的pop()方法用于随机删除集合中的一个元素并返回该元素。其语法格式如下：

set.pop()

参数说明：

• set：表示集合对象。

• 返回值：返回随机删除的元素。

锦囊1 随机删除集合中的一个元素

使用pop()方法随机删除集合中的一个元素，示例代码如下：

digital = {"手机","平板电脑","数码相机","摄像机","耳机"}  		# 创建集合

print("删除前：", digital)
print("随机删除的元素为：", digital.pop())    				# 随机删除集合中的元素并返回
print("随机删除的元素为：", digital.pop())
print("删除后：",digital)

注意：如果集合为空，却调用了pop()方法，会抛出KeyError异常。

22. 【删除集合中的指定元素】remove()方法

语法参考

集合remove()方法用于从集合中删除指定元素，如果要删除的指定元素不存在，将抛出KeyError异常。其语法格式如下：

set.remove(element)

参数说明：

• set：表示要删除指定元素的集合。

• element：集合中指定要删除的元素。

锦囊1 从集合中删除指定元素

使用remove()方法从集合中删除指定元素，示例代码如下：

poem = {"少年易老学难成","一寸光阴不可轻","未觉池塘春草梦","阶前梧叶已秋声"}    	# 创建集合
print("删除前", poem)

poem.remove("未觉池塘春草梦")                									# 删除集合中的指定元素
poem.remove("阶前梧叶已秋声")
print("删除后", poem)

注意：使用集合的remove()方法时，如果要删除的指定元素不在集合中，将抛出KeyError异常。

锦囊2 通过for循环删除集合中不是中文的字符元素

集合是不可以通过迭代的方式移除指定条件的元素，所以在循环是需要将集合这个迭代对象转换为列表，然后再遍历每个元素，当元素不是一个中文字符时，就可以通过remove()方法删除这个元素即可。示例代码如下：

idiom_set = {"王侯将相","相忍为国","国富民强","强作解人","1234","rmwq"}   	# 字符类型数据的字典

for i in list(idiom_set):                								# 循环遍历元素
    if not '\u4e00' <= i <= '\u9fff':   								# 判断元素是否为中文
        idiom_set.remove(i)               								# 删除不是中文的元素

print("删除元素后的字典为：",idiom_set)   								# 打印删除元素后的集合

23. 【将可迭代对象转换为可变集合】set()函数

示例

set()函数用于将可迭代对象转换为一个无序不重复元素的可变集合，返回的集合是可以修改的，我们可以对集合元素进行添加或删除等，还可以进行交集、并集、差集等操作。

例如，将字典对象转换为可变集合时，会将字典中的key键作为元素产生一个集合对象。示例代码如下：

s1 = set({"baidu":"百度", "sohu":"搜狐", "sina":"新浪"})  # 字典，只作用于key键
print('字典转换为集合：',s1)

24. 【返回集合的对称差集】symmetric_difference()方法

语法参考

集合symmetric_difference()方法用于返回两个集合的对称差集，即返回由集合a和集合b中不重复的元素组成的集合。但是不改变原集合a和原集合b。其语法格式如下：

set_a.symmetric_difference(set_b)         # 相当于set_a ^ set_b

参数说明：

• set_a：集合a。

• set_b：集合b，可以是一个集合或其他的可迭代对象（如列表、元组、字典等）。

• 返回值：返回对称差集。

锦囊1 返回两个集合中不重复的元素集合

使用symmetric_difference()方法返回两个集合中不重复的元素集合，示例代码如下：

x = {"0001", "0002", "0003"}            					# 创建集合x
y = {"0001", "0002", "0005", "0008"}    					# 创建集合y
z = ["0001", "0002"]                    					# 创建列表z

# 返回由两个集合中不重复的元素组成的集合
print("x和y中不重复的元素：", x.symmetric_difference(y))
print("x和z中不重复的元素：", x.symmetric_difference(z))
print("y和z中不重复的元素：", y.symmetric_difference(z))

25. 【更新原集合为两个集合的对称差集】symmetric_difference_update()方法

语法参考

集合中的symmetric_difference_update()方法用于将原集合更新为两个集合的对称差集，即把集合a更新为集合a与集合b的对称差集（由集合a和集合b中不重复的元素组成的集合），但是不改变原集合b。其语法格式如下：

set_a.symmetric_difference_update(set_b)

参数说明：

• set_a：集合a。

• set_b：集合b，可以是一个集合或其他的可迭代对象（如列表、元组、字典等）。

• 返回值：None。

锦囊1 将原集合更新为两个集合的对称差集

使用symmetric_difference_update()方法更新原集合为两个集合的对称差集，示例代码如下：

a = {0, 1, 2, 3, 4}                			# 创建集合a
b = {0, 2, 4}                       		# 创建集合b
c = (0, 9, 10, 50)                 			# 创建元组c
print("更新前的集合a：", a)

a.symmetric_difference_update(b)   			# 更新a为a与b的对称差集
print("更新后的集合a：", a)
print("更新前的集合b：", b)

b.symmetric_difference_update(c)   			# 更新b为b与c的对称差集
print("更新后的集合b：", b)

锦囊2 symmetric_difference()方法和symmetric_difference_update()方法的区别

集合中symmetric_difference()方法和symmetric_difference_update()方法都是将多个可迭代的集合取对称差集，但是返回的结果和对原集合的影响却不一样。symmetric_difference()方法将集合a和集合b取对称差集（由集合a和集合b中不重复的元素组成的集合），并将对称差集作为一个新的集合返回，但是不改变原集合a和原集合b。symmetric_difference_update()方法将集合a和集合b取对称差集，将集合a更新为集合a与集合b的对称差集，但是不改变原集合b。示例代码如下：

print("*********** symmetric_difference()方法 ***********")
a = {1, 2, 3, 4, 5}                           		# 创建集合a
b = {3, 4, 5}                                  		# 创建集合b

print("取对称差集前的集合a：", a)
print("取对称差集前的集合b：", b)
print("返回：", a.symmetric_difference(b))    		# 返回集合的对称差集
print("取对称差集后的集合a：", a)             		# 不改变集合a
print("取对称差集后的集合b：", b)             		# 不改变集合b


print("\n******** symmetric_difference_update()方法 ********")
a = {1, 2, 3, 4, 5}                           		# 创建集合a
b = {3, 4, 5}                                 		# 创建集合b

print("更新前的集合a：", a)
print("更新前的集合b：", b)

a.symmetric_difference_update(b)              		# 更新原集合为两个集合的对称差集
print("更新后的集合a：", a)                  			# 更新集合a
print("更新后的集合b：", b)                  			# 不改变集合b

26. 【返回集合的并集】union()方法

语法参考

集合中的union()方法用于返回集合的并集，即将集合a和集合b取并集，并将并集作为一个新的集合返回，但是不改变原集合a和原集合b。其语法格式如下：

set_a.union(set_b)              # 相当于set_a | set_b

参数说明：

• set_a：集合a。

• set_b：集合b，参数可以是集合或其他的可迭代对象（如列表、元组、字典等），可以是一个或多个可迭代对象，多个可迭代对象之间用逗号隔开。

• 返回值：返回集合的并集。

提示：使用union()方法合并两个或多个集合时，重复的元素会自动保留一个。

锦囊1 返回多个集合的并集元素

使用union()方法返回多个集合的并集元素，示例代码如下：

a = {"上海市", "重庆市"}                        	# 创建集合a
b = {"北京市", "天津市"}                        	# 创建集合b
c = ["广东省", "湖南省","湖北省", "海南省"]     	# 创建列表c
d = ("云南省","贵州省","四川省")                	# 创建元组d

# 返回集合的并集
print("a、b的并集：", a.union(b))
print("a、c的并集：", a.union(c))
print("a、b、d的并集：", a.union(b,d))         	# 多个可迭代对象之间使用逗号隔开

27. 【更新原集合为两个集合的并集】update()方法

语法参考

集合中的update()方法用于更新原集合为两个集合的并集，即将集合a和集合b取并集，并将结果更新到（添加到）集合a中，但不改变集合b。该方法无返回值。其语法格式如下：

set_a.update(set_b)

参数说明：

• set_a：表示需要更新的集合a。

• set_b：集合b，可以是集合或其他的可迭代对象（如列表、元组、字典等），可以是一个或多个可迭代对象，多个可迭代对象之间用逗号隔开。

• 返回值：None。

提示：如果添加的元素在原集合中已存在，则该元素只会出现一次，重复的会被忽略。

锦囊1 更新当前集合

使用update()方法更新当前集合，示例代码如下：

surname1 = set("赵钱孙李")             		# 将字符串转换为集合
surname2 = set("周吴郑王")             		# 将字符串转换为集合
print("更新前的集合", surname1)

surname1.update(surname2)              		# 参数为集合
surname1.update("冯陈")                		# 参数为字符串
surname1.update(("楮","卫"))           		# 参数为元组

# update()方法的参数不能为数字，否则将提示TypeError: 'int' object is not iterable
# surname1.update(1)
print("更新后的集合", surname1)

锦囊2 将多个可迭代对象同时更新到集合中

使用update()方法将多个可迭代对象同时更新到集合中，示例代码如下：

num1 = set(range(1,10,2))                		# 将range对象转换为集合
num2 = (2,11,20,9)                       		# 创建元组
num3 = [50,100]                          		# 创建列表
num4 = {"0001":"Tom", "0002":"Jony"}     		# 创建字典
print("更新前的集合num1：", num1)

# 将元组num2、列表num3、字典num4添加到集合num1中
# 提示：字典类型作用的是key
num1.update(num2, num3, num4)          			# 参数为多个对象
print("更新后的集合num1：", num1)

锦囊3 update()方法与union()方法的区别

集合中update()方法和union()方法都是将多个可迭代的集合合并，但是返回的结果和对原集合的影响却不一样。update()方法将集合a和集合b取并集，并将结果更新到（添加到）集合a中，但不改变集合b，该方法没有返回值。union()方法将集合a和集合b取并集，并将并集作为一个新的集合返回，但是不改变原集合a和原集合b。代码如下：

print("************* update()方法 ************* ")
a = {1, 2, 3, 4, 5}                  		# 创建集合a
b = {5, 6, 7, 8}                     		# 创建集合b

print("更新前的集合a：", a)
print("更新前的集合b：", b)

a.update(b)                           		# 更新原集合为两个集合的并集
print("返回：", a.update(b))         		# 返回None
print("更新后的集合a：", a)          			# 更新集合a
print("更新后的集合b：", b)          			# 不改变集合b


print("\n************** union()方法 ************** ")
a = {1, 2, 3, 4, 5}                  		# 创建集合a
b = {5, 6, 7, 8}                     		# 创建集合b

print("合并前的集合a：", a)
print("合并前的集合b：", b)

a.union(b)                             		# 返回集合的并集
print("返回：", a.union(b))           		# 生成集合的并集并返回
print("合并后的集合a：", a)           		# 不改变集合a
print("合并后的集合b：", b)           		# 不改变集合b