Day11 集合详解（冰冻集合，集合运算）——python学习之路

定义

1. 直接使用 {} 来定义集合
2. 使用set()进行集合的定义和转换
3. 使用集合推导式

• 注意：集合中的元素不能重复，集合中可以存放的数据：Number，String，Tuple，冰冻集合

集合的特点

1. 无序：集合中的元素没有顺序
2. 在集合中：False == 0 True == 1，即元素False与元素0不能共存于一个集合中
3. 元素的值不重复

集合的基本操作和常规函数

基本操作

检测集合中的值是否存在

vars = {False, True, 'love', 3.1415, (1, 2, 3), (1, 3, 2), 'abc', 123}
# in | not in
print('123' in vars)		#(输出) True
print('cat' not in vars)	#(输出) True

遍历访问集合

vars = {False, True, 'love', 3.1415, (1, 2, 3), (1, 3, 2), 'abc', 123}

for i in vars:
    print(i)

常规函数

len()

获取集合中元素的个数

vars = {False, True, 'love', 3.1415, (1, 2, 3), (1, 3, 2), 'abc', 123}

res = len(vars)
print(res)		#(输出) 8

add()

向集合中追加元素

vars = {False, True, 'love', 3.1415, (1, 2, 3), (1, 3, 2), 'abc', 123}

vars.add('def')
print(vars)

#(输出) {False, True, 3.1415, 'abc', (1, 3, 2), 123, (1, 2, 3), 'def', 'love'}

pop()

从集合中移除并返回任意一个元素，集合为空报错 KeyError

vars = {False, True, 'love', 3.1415, (1, 2, 3), (1, 3, 2), 'abc', 123}

print(vars.pop())     #(输出) False

remove()

指定删除集合中的元素，没有则报错 KeyError

vars = {False, True, 'love', 3.1415, (1, 2, 3), (1, 3, 2), 'abc', 123}

vars.remove('abc')
print(vars)         #(输出) {False, True, 'love', 3.1415, (1, 3, 2), (1, 2, 3), 123}

discard()

指定删除集合中的元素，没有不会报错

vars = {False, True, 'love', 3.1415, (1, 2, 3), (1, 3, 2), 'abc', 123}

vars.discard('abc')

update()

update(others) 更新集合, 添加来自 others 中的所有元素

vars = {False, True, 'love', 3.1415, (1, 2, 3), (1, 3, 2), 'abc', 123}

vars.update({'bbc','fox'})
print(vars)

#(输出) {False, True, 'love', 3.1415, 'fox', (1, 3, 2), 'abc', (1, 2, 3), 'bbc', 123}

copy()

• 返回原集合的浅拷贝，不用担心深拷贝的问题
  当前集合中的浅拷贝并不存在 深拷贝的问题
  因为集合中的元素都是不可变, 包括元组和冰冻集合
  不存在拷贝后, 对集合中不可变的二级容器进行操作的问题

clear()

清空集合

集合推导式

1. 普通推导式

varset = {1,2,3,4}

newset = {i**2 for i in varset}
print(newset)

#(输出) {16, 1, 4, 9}

2. 带有条件表达式的推导式

varset = {1,2,3,4}

newset = {i**2 for i in varset if i%2 ==0}
print(newset)

#(输出) {16, 4}

3. 多循环的集合推导式

newset = {i*j for i in range(3) for j in range(3,6)}
print(newset)

#(输出) {0, 3, 4, 5, 6, 8, 10}

冰冻集合

冰冻集合的定义

• 定义冰冻集合, 只能使用 frozenset() 函数进行冰冻集合的定义
  冰冻集合一旦定义不能修改！
  冰冻集合只能做集合相关的运算：求交集, 差集。。。
  frozenset() 本身就是一个强制转换类的函数，可以把其它任何容器类型的数据转为冰冻集合

# 1.
vars = frozenset()  # 空的冰冻集合
# 2.
vars = frozenset({1,2,3})	# 将集合转为冰冻集合
# 3.
vars = frozenset([1,2,3])	# 将列表转为冰冻集合

print(vars)		#(输出) frozenset({1, 2, 3})

冰冻集合的遍历

vars = frozenset({1,2,3})
for i in vars:
    print(i)

冰冻集合的推导式

res = frozenset({i**2 for i in range(6)})
print(res)

#(输出) frozenset({0, 1, 16, 4, 9, 25})

集合的主要运算

运算符号

• 交集：&      set1 & set2
• 并集：|      set1 | set2
• 差集：-      set1 - set2
• 对称差集：^    set1 ^ set2

运算函数

交集运算函数

• set.intersection() 返回交集的结果 新的集合
• set.intersection_update() 计算两个集合的相交部分，把计算结果重新赋值给第一个集合

x = {'apple', 'banana', 'cherry'}
y = {'google', 'runoob', 'apple'}

# set.intersection() 返回交集的结果 新的集合
res = x.intersection(y)
print(res)      #(输出) {'apple'}

# set.intersection_update() 计算两个集合的相交部分, 把计算结果重新赋值给第一个集合
x.intersection_update(y)
print(x)        #(输出) {'apple'}

并集运算函数

• set.union() 返回并集结果，新的集合
• set.update() 求并集运算，并且把结果赋值给第一个集合

x = {'apple', 'banana', 'cherry'}
y = {'google', 'runoob', 'apple'}

# set.union() 返回并集结果, 新的集合
res = x.union(y)
print(res)      #(输出) {'banana', 'google', 'runoob', 'cherry', 'apple'}

# set.update() 求并集运算, 并且把结果赋值给第一个集合
x.update(y)
print(x)        #(输出) {'runoob', 'cherry', 'google', 'apple', 'banana'}

差集运算函数

• set.difference() 返回差集结果，新的集合
• set.difference_update 求差集运算，并且把结果赋值给第一个集合

x = {'apple', 'banana', 'cherry'}
y = {'google', 'runoob', 'apple'}

# set.difference() 返回差集结果, 新的集合
res = x.difference(y)
print(res)          #(输出) {'cherry', 'banana'}

# set.difference_update 求差集运算, 并且把结果赋值给第一个集合
x.difference_update(y)
print(y)            #(输出) {'apple', 'runoob', 'google'}

对称差集运算函数

• set.symmetric_difference 返回对称差集结果，新的集合
• set.symmetric_difference_update 求对称差集运算，并且把结果赋值给第一个集合

x = {'apple', 'banana', 'cherry'}
y = {'google', 'runoob', 'apple'}

# set.symmetric_difference 返回对称差集结果, 新的集合
res = x.symmetric_difference(y)
print(res)			#(输出) {'google', 'runoob', 'cherry', 'banana'}

# set.symmetric_difference_update 求对称差集运算, 并且把结果赋值给第一个集合
x.symmetric_difference_update(y)
print(x)			#(输出) {'google', 'runoob', 'cherry', 'banana'}

检测 超集 | 子集

• set.issuperset() 检测是否为超集
• set.issubset() 检测是否为子集

x = {1,2,3,4,5,6}
y = {1,2,3}

# set.issuperset() 检测是否为超集
print(x.issuperset(y))      #(输出) True, x 是 y 的超集

# set.issubset() 检测是否为子集
print(y.issubset(x))        #(输出) True, y 是 x 的子集

检测两个集合是否相交

isdisjoint 检测是否不相交，不想交返回True, 相交则返回False

x = {1,2,3}
y = {4,5,6}

# isdisjoint 检测是否不相交, 不想交返回True, 相交则返回False
print(x.isdisjoint(y))      #(输出) True