1、两个集合是否相等==或!=

语法格式：set1 == set2 如果set1集合和set2集合相等，则返回True，否则返回False。

s1 = {10,20,30,40}
s2 = {20,30,10,40}
print(s1 == s2)     # True
print(s1 != s2)     # False

2、issubset() —-> 子集

语法格式：set1.issubset(set2)

方法说明：等价于set1 < set2。用于判断 set1 是否是 set2 的子集，即 set1 中的元素都是 set2 的成员：如果是返回 True，否则返回 False。

s1 = {20,40,30,10}
s2 = {10,20,30,40,50,60}
s3 = {10,40,90}

print('s1：',s1)
print('s2：',s2)
print('s3：',s3)

print(s1.issubset(s2))  # True

# 90不在s2里
print(s3.issubset(s2))  # False

3、issuperset() —-> 超集

语法格式：set1.issuperset(set2)

返回值：布尔型，是超集则返回 True，否则返回 False。

方法说明：等价于 set1>set2，用于判断 set1 是否是 set2 的超集，也就是说集合 set1 包含集合 set2 中所有元素。

s1 = {10,20,30,40,50,60}
s2 = {20,40,30,10}
s3 = {10,40,90}

print(s1.issuperset(s2))    # True

# s1不包含s3中的90
print(s1.issuperset(s3))    # False

4、isdisjoint() —-> 交集

语法格式：set1.isdisjoint(set2)

返回值：布尔型。

方法说明：判断两个集合是否有交集，即set1 集合和 set2 集合有相同元素，如果没有交集返回True，有交集返回False。

s1 = {10,20,30,40,50,60}
s3 = {10,40,90}
s4 = {22,99,33,44}

# 有交集{10,40}，返回False
print(s1.isdisjoint(s3))    # False

# 没有交集，返回True
print(s1.isdisjoint(s4))    # True

5、intersection() —-> 交集

语法格式：set1.intersection(set2)

返回值：返回两个集合相同元素组成的新集合。

方法说明：等价于 set1 & set2。返回两个集合的交集，也就是两个集合中相同元素组成的集合。得到新集合，原集合不发生改变。

s1 = {10,20,30,40,50,60}
s2 = {20,40,88,99,30,10}

print(s1.intersection(s2))  # {40, 10, 20, 30}

new_set = s1 & s2

print(new_set)

6、intersection_update() —-> 交集

语法格式：set1.intersection_update(set2)

方法说明：取两个集合的交集，和 intersection 不同的是，intersection 得到的是一个新的集合，而 intersection_update() 是在原集合 set1 的基础上去掉和 set2 不重叠的元素。在原集合的基础上操作。

s1 = {10,20,30,40,50,60}
s2 = {20,40,88,99,30,10}

# 取交集，在集合s1的基础上去除与s2不重叠的元素，留下重复的元素
s1.intersection_update(s2)

print(s1)     # {40, 10, 20, 30}

isdisjoint() 、intersection() 和 intersection_update 的区别：

isdisjoint() ：判断两个集合是否有交集，返回值是布尔型。

intersection() ：取两个集合的交集，返回值是一个新集合。

intersection_update()：取两个集合的交集，无返回值，是在原集合的基础上操作的。

7、union() —-> 并集

语法格式：set1.union(set2, set3 …)

参数说明：用于取并集的集合。

返回值：返回两个或多个集合中所有元素组成的新集合。如果不传参，则返回的是这个集合的浅拷贝。

方法说明：等价于 set1 | set2。返回两个或多个集合的所有元素组成的集合，称为并集，重复的元素只取一次。

s1 = {10,40,70,30}
s2 = {20,30,50,60}

# 合并两个集合
s3 = s1.union(s2)
print(s3)   # {70, 40, 10, 50, 20, 60, 30}

# 取三个集合的并集
s = {88,10,90,666}
print(s1.union(s,s2))   # {70, 40, 10, 50, 20, 666, 88, 90, 60, 30}

# 合并列表，返回的是一个集合
s4 = ['hello','python']
print(s1.union(s4)) # {70, 40, 10, 'python', 'hello', 30}

如果不传参数，union 返回的就是这个集合的浅拷贝。

s1 = {10,40,70,30}
s2 = {20,30,50,60}
print(s1,id(s1))    # {40, 10, 70, 30} 2708661478880

# 不传参，返回的是集合的浅拷贝
ss = s1.union()

print(ss,id(ss))    # {40, 10, 70, 30} 2708664425760

8、difference() —-> 差集

语法格式：set1.difference(set2)

返回值：返回一个删除相同元素后的新集合。

方法说明：返回集合的差集，即集合 set1 减去两个集合的交集，等价于 set1 – set2 。得到的那个集合是第一个集合减去和第二个集合重叠的部分所剩下的元素（在 set1 中存在，而在 set2 中不存在的元素）。原集合不发生改变。

s1 = {10,20,30,40,50,60,70}
s2 = {20,33,40,50,88}

# 返回一个删除相同元素后的新集合，即元素在s1中存在，在s2中不存在
new_set = s1.difference(s2)
print(new_set)    # {10, 60, 70, 30}

# 相当于s1 - s2
s3 = s1 - s2
print(s3)

9、difference_update() —-> 差集

语法格式：set1.difference_update(set2)

方法说明：差集。删除 set1 集合中两个集合都存在的元素，直接在原来的集合中进行操作的，无返回值。

s1 = {10,20,30,40,50,60,70}
s2 = {20,33,40,50,88}

print('s1：',s1,id(s1))

# 无返回值，直接在s1上操作的
s1.difference_update(s2)

print('difference_update后的集合：',s1,id(s1))       # {70, 10, 60, 30}

10、symmetric_difference() —-> 对称差集

语法格式：set1.symmetric_difference(set2)

返回值：返回一个包含两个集合中不重复的元素组成的新集合。

方法说明：返回两个集合的对称差集（两个集合的并集减去交集，得到对称差集。），得到的这个新集合是两个集合中不重复的元素组成的，就是除去了两个集合重复的元素。

s1 = {10,20,30,40,50,60,70}
s2 = {20,33,40,50,88}

s3 = s1.symmetric_difference(s2)

print(s3)   # {33, 70, 10, 88, 60, 30}

11、symmetric_difference_update() —-> 对称差集

语法格式：set1.symmetric_difference_update(set2)

方法说明：获得对称差集。删除 set1 集合中，和 set2 集合重复的元素，并将 set2 集合中不同的元素插入到当前集合 set1 中。在 set1 集合中操作的，所以无返回值。

s1 = {10,20,30,40,50,60,70}
s2 = {20,33,40,50,88}

s1.symmetric_difference_update(s2)

print(s1)   # {33, 70, 88, 10, 60, 30}

小总结