Python基础——集合（set）

集合是一个无序不重复元素的序列，不能被切片、索引。

1.1 添加add/update()

a_set = {1,2,3,4}
# 添加
a_set.add(5)
a_set.update(4,5,[6,7])
print(a_set)  # 输出{1, 2, 3, 4, 5,[6,7]}

1.2 删除discard/remove()

#使用remove时，如果元素不存在，则会发生错误。

# 删除
a_set.discard(5)
a_set.remove(5)
print(a_set)  # 输出{1, 2, 3, 4}

1.3 集合快速运算

s = {1,2,3,4,5}
s2 = {3,4,5,6,7}
# & 交集运算——两者中都包含的元素
result = s & s2 # {3, 4, 5}

# | 并集运算——代表两者中全部元素聚在一起去重后的结果
result = s | s2 # {1,2,3,4,5,6,7}

# - 差集——代表前者中包含、后者中不包含的元素
result = s - s2 # {1, 2}

# ^ 异或集——不同时包含于两个集合中的元素
result = s ^ s2 # {1, 2, 6, 7}

# <= 检查一个集合是否是另一个集合的子集
a = {1,2,3}
b = {1,2,3,4,5}

result = a <= b # True
result = {1,2,3} <= {1,2,3} # True
result = {1,2,3,4,5} <= {1,2,3} # False

# < 检查一个集合是否是另一个集合的真子集
result = {1,2,3} < {1,2,3} # False
result = {1,2,3} < {1,2,3,4,5} # True

# >= 检查一个集合是否是另一个的超集
# > 检查一个集合是否是另一个的真超集

1.3集合的内置方法

1.3.1 交集——intersection(set1, set2 … etc)

• 用于返回两个或更多集合的交集，返回一个新的集合。

# 返回两个或者多个集合的交集
x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
z = x.intersection(y)
print(z)

#　返回三个集合的交集
x = {"a", "b", "c"}
y = {"c", "d", "e"}
z = {"f", "g", "c"}
result = x.intersection(y, z)
print('三个集合的差集是：%s' % result)

# 输出结果：
{'apple'}
两个集合的差集是：{'c'}

1.3.2 并集——union()

# 合并两个集合，重复元素只会出现一次：
x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
z = x.union(y) 
print(z)

#输出结果为：
{'cherry', 'runoob', 'google', 'banana', 'apple'}

# 合并多个集合：
x = {"a", "b", "c"}
y = {"f", "d", "a"}
z = {"c", "d", "e"}
result = x.union(y, z) 
print(result)
 
#输出结果为：
{'c', 'd', 'f', 'e', 'b', 'a'}

1.3.3 差集——difference()

返回的集合元素包含在第一个集合中，但不包含在第二个集合(方法的参数)中，返回一个新的集合。

实例：

# 求两个集合的差集，元素在 x 中不在 y 中
x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}

z = x.difference(y)
print('两个集合的差集是：%s' % z)

# 输出结果为：
{'cherry', 'banana'}

1.3.4 异或集——symmetric_difference()

• 返回两个集合中不重复的元素集合，结果返回一个新的集合。

# 返回两个集合组成的新集合，但会移除两个集合的重复元素：
x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}

z = x.symmetric_difference(y)

print(z)

输出结果：
{'banana', 'google', 'cherry', 'runoob'}

1.3.5 判断子集——issubset()

• 如果是则返回 True，否则返回 False。

# 判断集合 x 的所有元素是否都包含在集合 y 中：
x = {"a", "b", "c"}
y = {"f", "e", "d", "c", "b", "a"}
z = x.issubset(y) 
print(z)

#输出结果
True# 说明 集合 x 中的元素都包含在 y 中

#　集合 y 中只有元素 b 和 c ，执行结果为False 
x = {"a", "b", "c"}
y = {"f", "e", "d", "c", "b","y"}
z = x.issubset(y)
print(z)

#结果输出；
False

1.3.6 判断超集——issuperset()

• 判断指定集合的所有元素是否都包含在原始的集合中，如果是则返回 True，否则返回 False。

# 判断集合 y 的所有元素是否都包含在集合 x 中：
x = {"f", "e", "d", "c", "b", "a"}
y = {"a", "b", "c"}
z = x.issuperset(y) 
print(z)

#输出结果为：
True


# 如果没有全部包含返回 False：
x = {"f", "e", "d", "c", "b"}
y = {"a", "b", "c"}
z = x.issuperset(y) 
print(z)

#输出结果为：
False

1.3.7 是否包含相同的元素——isdisjoint()

• 如果没有返回 True，否则返回 False。

x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
z = {"google", "runoob", "baidu"}
#　判断集合 y 中是否包含集合 x 中的元素，如果没有返回 True, 有则返回 False
a = x.isdisjoint(y)
# 结果返回 False,说明集合 y 中有和 x 中相同的元素
print(a)

#　判断集合 y 中是否包含集合 x 中的元素，如果没有返回 True, 有则返回 False
a = x.isdisjoint(z)
# 结果返回 True,说明集合 z 中没有和 x 中相同的元素
print(a)

#输出结果：
False
True

1.3.8 更新为交集——intersection_update()

• intersection() 方法是返回一个新的交集集合，
• intersection_update() 方法是在原始的集合上移除不重叠的元素。

# 返回一个无返回值的集合交集
x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
x.intersection_update(y)
print(x)

x = {"a", "b", "c"}
y = {"c", "d", "e"}
z = {"f", "g", "c"}
x.intersection_update(y, z)
print(x)

#　输出结果：
{'apple'}
{'c'}

1.3.9 更新为差集——difference_update()

• difference()返回一个新的差集集合
• difference_update()直接在原来的集合中移除元素，没有返回值。

x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}

x.difference_update(y)

print(x)
结果为：
{'banana', 'cherry'}

1.3.10 更新为异或集——symmetric_difference_update()

• 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。

# 在原始集合 x 中移除与 y 集合中的重复元素，并将不重复的元素插入到集合 x 中：
x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
x.symmetric_difference_update(y)
print(x)

#输出结果：
{'runoob', 'cherry', 'banana', 'google'}