集合

  • 定义
  • 集合的特点
  • 集合的基本操作和常规函数
  • 基本操作
  • 检测集合中的值是否存在
  • 遍历访问集合
  • 常规函数
  • len()
  • add()
  • pop()
  • remove()
  • discard()
  • update()
  • copy()
  • clear()
  • 集合推导式
  • 冰冻集合
  • 冰冻集合的定义
  • 冰冻集合的遍历
  • 冰冻集合的推导式
  • 集合的主要运算
  • 运算符号
  • 运算函数
  • 交集运算函数
  • 并集运算函数
  • 差集运算函数
  • 对称差集运算函数
  • 检测 超集 | 子集
  • 检测两个集合是否相交


定义

  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}
  1. 带有条件表达式的推导式
varset = {1,2,3,4}

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

#(输出) {16, 4}
  1. 多循环的集合推导式
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

pytorch 集合相减_bc

运算函数

交集运算函数
  • 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