集合 set
- 集合是可变的容器
- 集合内的数据对象是唯一的（不能重复多次的)
- 集合是无序的存储结构，集合中的数据没有先后关系
- 集合内的元素必须是不可变对象
- 集合是可迭代对象
- 集合是相当于只有键没有值的字典(键则是集合的数据)
集合的创建
# 创建非空集合
s1 = set()
# 创建非空集合
s2 = {1, 2, 3}
s3 = {1, 2, 3, 'a', 'B'}
集合的构造函数
set(iterable) 用可迭代对象创建一个新的集合对象
s1 = set("ABC") # s1 = {'A', 'C', 'B'}
s2 = set('ABCCBA') # s2 = {'A', 'B', 'C'}
dic = {1:"一", 2:'二', 5:'五'}
# 字典生成集合，默认情况下会以键作为集合的元素
s3 = set(dic) # s3 = {1, 2, 5}
# 以字典的值作为元素生成集合
s4 = set(dic.values()) # s4 = {'一', '五', '二'}
# 以字典的键值对作为元素生成集合
s5 = set(dic.items()) # s5 = {(2, '二'), (1, '一'), (5, '五')}
# 列表作为生成集合
s6 = set([1, 3.14, False]) # s6 = {False, 1, 3.14}
# 元组生成集合
s7 = set((2, 3, 5, 7)) # s7 = {2, 3, 5, 7}
s8 = set([1, 2, [3.1, 3.2], 4]) # 报错，[3.1, 3.2]是可变对象
集合的运算
集合之间也可进行数学集合运算，可用相应的操作符或方法来实现
交集
- 两个集合 A 和 B 的交集是既属于 A 又属于 B 的元素
- 使用
&操作符执行交集操作，也可使用方法intersection()方法
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = {3, 4, 5}
s4 = {7, 8, 9}
s5 = s1 & s2 # s5 = {2, 3}
s6 = s1 & s2 & s3 # s6 = {3}
s7 = s1 & s4 # s7 = set()
s8 = s1.intersection(s2) # s8 = {2, 3}
s9 = s1.intersection(s2).intersection(s3) # s9 = {3}
并集
- 并集是这些集合的所有元素构成的集合
- 使用操作符
|执行并集操作，也可使用方法union()方法
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = {3, 4, 5}
s4 = {7, 8, 9}
s5 = s1 | s2 # s5 = 1, 2, 3, 4}
s6 = s1 | s2 | s3 # s6 = {1, 2, 3, 4, 5}
s7 = s1.union(s2) # s7 = {1, 2, 3, 4}
s8 = s1.union(s2).union(s3) # s8 = {1, 2, 3, 4, 5}
补集
- 补集亦称差集，A 与 B 的差集是所有属于 A 且不属于 B 的元素构成的集合
- 使用操作符
-执行差集操作，也可使用方法difference()方法
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = {3, 4, 5}
s4 = {7, 8, 9}
s5 = s1 - s2 # s5 = {1}
s51 = s2 - s1 # s51 = {4}
s6 = s1 - s2 - s3 # s6 = {1}
s6 = s1.difference(s2) # s6 = {1}
s7 = s1.difference(s2).difference(s3) # s7 = {1}
对称补集
- 只属于其中一个集合，而不属于另一个集合的元素组成的集合
- 使用
^操作符执行差集操作也，可使用方法symmetric_difference()方法
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = {3, 4, 5}
s4 = {7, 8, 9}
s5 = s1 ^ s2 # s5 = {1,4}
s51 = s2 ^ s1 # s51 = {1,4}
s6 = s1 ^ s2 ^ s3 # s6 = {1, 3, 5}
s6 = s1.symmetric_difference(s2) # s6 = {1,4}
s7 = s1.symmetric_difference(s2).symmetric_difference(s3) # s7 = {1, 3, 5}
子集
- 子集，为某个集合中一部分的集合，故亦称部分集合
- 使用操作符
<执行子集操作，也可使用方法issubset()方法
s1 = {1, 2, 3}
s2 = {2, 3}
s3 = {7, 8, 9}
s4 = s2 < s1 # True
s5 = s3 < s1 # False
s6 = s2.issubset(s1) # True
s7 = s3.issubset(s1) # False
超集
- 集合A与B，若A包含B，则称A为B的超集
- 使用操作符
>执行超集操作，也可使用方法issuperset()方法
s1 = {1, 2, 3}
s2 = {2, 3}
s3 = {7, 8, 9}
s4 = s1 > s2 # True
s5 = s1 > s3 # False
s6 = s1.issuperset(s2) # True
s7 = s1.issuperset(s3) # False
相同与不相同
集合的相同是指集合的个数和元素均相同，与次序无关
s1 = {1, 2, 3}
s2 = {2, 3, 1}
s1 == s2 # True
s1 != s2 # False
in / not in 运算符
-
in运算符用于集合中，当某个值存在于集合中，则为真，否则为假 -
not in与in返回值相反
s = {1, 'Two', 3.14}
1 in s # True
2 in s # False
3.14 not in s # False
4 not in s # True
练习
s1 = {'曹操','刘备','周瑜'}
s2 = {'曹操','周瑜','张飞','赵云'}
print(s1 & s2) # {'曹操', '周瑜'}
print(s1 - s2) # {'刘备'}
print(s2 - s1) # {'赵云', '张飞'}
print('张飞' in s1) # False
print(s1 ^ s2) # {'赵云', '刘备', '张飞'}
print(s1 | s2) # {'周瑜', '赵云', '张飞', '刘备', '曹操'}
Python3中可用于集合的内置函数
len(x),max(x),min(x),sum(x),any(x),all(x)
集合的方法
-
s.add(e)向集合s中添加元素e -
s.remove(e)从集合s中删除一个元素，如果元素不存在于集合中，则会产生一个KeyError错误 -
s.discard(e)从集合s中移除一个元素e,在元素e不存在时什么都不做 -
s.clear()清空集合s内的所有元素 -
s.copy()将集合s进行一次浅拷贝 -
s.pop()从集合s中删除一个随机元素;如果此集合为空，则引发KeyError异常 -
s.update(s1)用s与s1得到的全集更新变量s -
s.difference(s2)用s - s2运算，返回存在于在s中，但不在s2中的所有元素的集合 -
s.difference_update(s2)等同于s = s - s2 -
s.intersection(s2)等同于s & s2 -
s.intersection_update(s2)等同于s = s & s2 -
s.isdisjoint(s2)如果s与s2交集为空返回True,非空则返回False -
s.issubset(s2)如果s与s2交集为非空返回True,空则返回False -
s.issuperset(...)如果s为s2的子集返回True,否则返回False -
s.symmetric_difference(s2)返回对称补集,等同于s ^ s2 -
s.symmetric_difference_update(s2)用s与s2的对称补集更新s -
s.union(s2)生成s与s2的全集
集合推导式
用可迭代对象来创建(生成)集合的表达式
语法
{ 表达式 for 变量 in 可迭代对象 [if 真值表达式] }
示例
L = [2, 3, 5, 7, 3, 5, 7, 11]
s = { x**2 for x in L} # s={4,9,25,49,121}
L = [2, 3, 5, 7, 3, 5, 7, 11]
s = { x**2 for x in L if x > 4} # s={25, 121, 49}
固定集合
固定集合是不可变的，无序的，含有唯一元素的集合
作用
固定集合可以作为字典的键，也可以作为集合的值（元素)
创建固定集合
# 创建空的固定集合
fs = frozenset() # fs = frozenset()
# 创建非空的固定集合
fs = frozenset([2,3,5,7]) # fs = frozenset({2, 3, 5, 7})
固定集合的运算
与集合的运算一致
固定集合的方法
相当于集合的全部方法去掉修改集合的方法
