定义:
1.不同元素组成
2.无序
3.集合中的元素必须是不可变类型
创建集合
1
|
s = { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 } |
1.定义可变集合
1
2
3
|
>>> set_test = set ( 'hello' ) >>> set_test { 'h' , 'l' , 'e' , 'o' } |
2.定义不可变集合
1
2
3
4
5
6
|
>>> set_test = set ( 'hello' ) >>> set_test { 'h' , 'l' , 'e' , 'o' } # 由此可见集合中的元素不可重复,都是不同的 >>> n_set_test = frozenset (set_test) >>> n_set_test frozenset ({ 'h' , 'l' , 'e' , 'o' }) |
集合运算
集合之间也可进行数学集合运算(例如:并集、交集等),可用相应的操作符或方法来实现。
子集
子集,为某个集合中一部分的集合,故亦称部分集合。
使用操作符 <
执行子集操作,同样地,也可使用方法 issubset() 完成。
1
2
3
4
5
6
7
8
9
|
>>> A = set ( 'abcd' ) >>> B = set ( 'cdef' ) >>> C = set ( "ab" ) >>> C < A True # C 是 A 的子集 >>> C < B False >>> C.issubset(A) True |
并集
一组集合的并集是这些集合的所有元素构成的集合,而不包含其他元素。
使用操作符 |
执行并集操作,同样地,也可使用方法 union() 完成。
1
2
3
4
|
>>> A | B { 'c' , 'b' , 'f' , 'd' , 'e' , 'a' } >>> A.union(B) { 'c' , 'b' , 'f' , 'd' , 'e' , 'a' } |
交集
两个集合 A 和 B 的交集是含有所有既属于 A 又属于 B 的元素,而没有其他元素的集合。
使用 &
操作符执行交集操作,同样地,也可使用方法 intersection() 完成。
1
2
3
4
|
>>> A & B { 'c' , 'd' } >>> A.intersection(B) { 'c' , 'd' } |
差集
A 与 B 的差集是所有属于 A 且不属于 B 的元素构成的集合
使用操作符 -
执行差集操作,同样地,也可使用方法 difference() 完成。
1
2
3
4
|
>>> A - B { 'b' , 'a' } >>> A.difference(B) { 'b' , 'a' } |
对称差
两个集合的对称差是只属于其中一个集合,而不属于另一个集合的元素组成的集合。
使用 ^
操作符执行差集操作,同样地,也可使用方法 symmetric_difference() 完成。
1
2
3
4
|
>>> A ^ B { 'b' , 'f' , 'e' , 'a' } >>> A.symmetric_difference(B) { 'b' , 'f' , 'e' , 'a' } |
集合方法
1.add 向集合中添加元素
1
2
3
4
|
>>> s = { 1 , 2 , 3 , 4 , 5 , 6 } >>> s.add( "s" ) >>> s { 1 , 2 , 3 , 4 , 5 , 6 , 's' } |
2.clear 清空集合
1
2
3
4
|
>>> s = { 1 , 2 , 3 , 4 , 5 , 6 } >>> s.clear() >>> s set () |
3.copy 返回集合的浅拷贝
1
2
3
4
|
>>> s = { 1 , 2 , 3 , 4 , 5 , 6 } >>> new_s = s.copy() >>> new_s { 1 , 2 , 3 , 4 , 5 , 6 } |
4.pop 删除并返回任意的集合元素(如果集合为空,会引发 KeyError)
1
2
3
4
5
|
>>> s = { 1 , 2 , 3 , 4 , 5 , 6 } >>> s.pop() # pop删除时是无序的随机删除 1 >>> s { 2 , 3 , 4 , 5 , 6 } |
5.remove 删除集合中的一个元素(如果元素不存在,会引发 KeyError)
1
2
3
4
|
>>> s = { 1 , 2 , 3 , 4 , 5 , 6 } >>> s.remove( 3 ) >>> s { 1 , 2 , 4 , 5 , 6 } |
6.discard 删除集合中的一个元素(如果元素不存在,则不执行任何操作)
1
2
3
4
|
>>> s = { 1 , 2 , 3 , 4 , 5 , 6 } >>> s.discard( "sb" ) >>> s { 1 , 2 , 3 , 4 , 5 , 6 } |
7.intersection 将两个集合的交集作为一个新集合返回
1
2
3
4
5
6
|
>>> s = { 1 , 2 , 3 , 4 , 5 , 6 } >>> s2 = { 3 , 4 , 5 , 6 , 7 , 8 } >>> s.intersection(s2) { 3 , 4 , 5 , 6 } >>> s&s2 # 可以达到相同的效果 { 3 , 4 , 5 , 6 } |
8.union 将集合的并集作为一个新集合返回
1
2
3
4
5
6
|
>>> s = { 1 , 2 , 3 , 4 , 5 , 6 } >>> s2 = { 3 , 4 , 5 , 6 , 7 , 8 } >>> print (s.union(s2)) { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 } >>> print (s|s2) # 用 | 可以达到相同效果 { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 } |
9.difference 将两个或多个集合的差集作为一个新集合返回
1
2
3
4
5
6
7
8
9
10
|
>>> s = { 1 , 2 , 3 , 4 , 5 , 6 } >>> s2 = { 3 , 4 , 5 , 6 , 7 , 8 } >>> print ( "差集:" ,s.difference(s2)) # 去除s和s2中相同元素,删除s2 保留s中剩余元素 差集: { 1 , 2 } >>> print ( "差集:" ,s2.difference(s)) # 去除s和s2中相同元素,删除s2 保留s2中剩余元素<br> 差集: { 8 , 7 } >>> print ( "差集:" ,s - s2) # 符号 - 可以达到相同结果 差集: { 1 , 2 } >>> print ( "差集:" ,s2 - s) # 符号 - 可以达到相同结果 差集: { 8 , 7 } |
10. symmetric_difference 将两个集合的对称差作为一个新集合返回(两个集合合并删除相同部分,其余保留)
1
2
3
4
|
>>> s = { 1 , 2 , 3 , 4 , 5 , 6 } >>> s2 = { 3 , 4 , 5 , 6 , 7 , 8 } >>> s.symmetric_difference(s2) { 1 , 2 , 7 , 8 } |
11.update 用自己和另一个的并集来更新这个集合
1
2
3
4
5
6
7
|
>>> s = { 'p' , 'y' } >>> s.update([ 't' , 'h' , 'o' , 'n' ]) # 添加多个元素 >>> s { 'p' , 't' , 'o' , 'y' , 'h' , 'n' } >>> s.update([ 'H' , 'e' ], { 'l' , 'l' , 'o' }) # 添加列表和集合 >>> s { 'p' , 'H' , 't' , 'l' , 'o' , 'y' , 'e' , 'h' , 'n' } |
12.intersection_update() 用自己和另一个的交集来更新这个集合
1
2
3
4
5
|
>>> s = { 'a' , 'b' , 'c' , 'd' , 'q' } >>> s2 = { 'c' , 'd' , 'e' , 'f' } >>> s.intersection_update(s2) # 相当于s = s - s2 >>> s { 'c' , 'd' } |
13.isdisjoint() 如果两个集合有一个空交集,返回 True
1
2
3
4
5
6
7
|
>>> s = { 1 , 2 } >>> s1 = { 3 , 4 } >>> s2 = { 2 , 3 } >>> s.isdisjoint(s1) True # s 和 s1 两个集合的交集为空返回 True >>> s.isdisjoint(s2) False # s 和 s2 两个集合的交集为 2 不是空 所有返回False |
14.issubset() 如果另一个集合包含这个集合,返回 True
1
2
3
4
5
6
7
|
>>> s = { 1 , 2 , 3 } >>> s1 = { 1 , 2 , 3 , 4 } >>> s2 = { 2 , 3 } >>> s.issubset(s1) True # 因为 s1 集合 包含 s 集合 >>> s.issubset(s2) False # s2 集合 不包含 s 集合 |
15.issuperset() 如果这个集合包含另一个集合,返回 True
1
2
3
4
5
6
7
|
>>> s = { 1 , 2 , 3 } >>> s1 = { 1 , 2 , 3 , 4 } >>> s2 = { 2 , 3 } >>> s.issuperset(s1) False # s 集合不包含 s1 集合 >>> s.issuperset(s2) True # s 集合包含 s2 集合 |
16.difference_update() 从这个集合中删除另一个集合的所有元素
1
2
3
4
5
6
7
8
9
|
>>> s = { 1 , 2 , 3 } >>> s1 = { 1 , 2 , 3 , 4 } >>> s2 = { 2 , 3 } >>> s.difference_update(s2) >>> s { 1 } # s2中的2,3 s集合中也有2,3 所以保留1 >>> s1.difference_update(s2) >>> s1 { 1 , 4 } |
17.symmetric_difference_update() 用自己和另一个的对称差来更新这个集合
1
2
3
4
5
6
7
8
9
10
11
12
|
>>> s = { 1 , 2 , 3 } >>> s1 = { 1 , 2 , 3 , 4 } >>> s2 = { 2 , 3 } >>> s1.symmetric_difference_update(s) >>> s1 { 4 } >>> s1.symmetric_difference_update(s2) >>> s1 { 2 , 3 , 4 } >>> s.symmetric_difference_update(s2) >>> s { 1 } |
集合与内置函数
下述内置函数通常作用于集合,来执行不同的任务。
函数 | 描述 |
all() | 如果集合中的所有元素都是 True(或者集合为空),则返回 True。 |
any() | 如果集合中的所有元素都是 True,则返回 True;如果集合为空,则返回 False。 |
enumerate() | 返回一个枚举对象,其中包含了集合中所有元素的索引和值(配对)。 |
len() | 返回集合的长度(元素个数) |
max() | 返回集合中的最大项 |
min() | 返回集合中的最小项 |
sorted() | 从集合中的元素返回新的排序列表(不排序集合本身) |
sum() | 返回集合的所有元素之和 |