set集合操作

 

1. set集合是一个无序且不重复的集合

注意: 

(1)由不同元素组成,且每个元素不能重复

(2)无序的(在Python2是无序的,在Python3中是有序的)

(3)集合中的元素必须是不可变类型(不可变类型指的是集合中的元素不可以修改,因此常用来作为字典的键)

(4)集合没有切片操作

 

2. 创建集合

(1)直接创建

s = {1,2,3,4,5,6,7,8}

(2)定义可变集合: set集合中的元素可以动态的增加或删除

set_test = set('hello')

>>> set_test

{'e', 'h', 'l', 'o'}    # 由此可见集合中的元素不可重复，都是不同的

(3)定义不可变集合: frozenset不可变集合中的元素不可改变

n_set_test = frozenset('hello')

>>> n_set_test

frozenset({'e', 'h', 'l', 'o'})

注意:

对于并集,交集,差集等的返回值,与最左边的操作数具有相同的类型.例如s&t取交集, s集合是一个set类型的集合,t集合是一个frozenset类型的集合,则返回

的结果将是set类型的集合.

3. 集合运算

采用相应的操作符或方法来实现.

(1)子集: 使用操作符 < 判断是否是子集, 也可使用issubset( )

A = set('abcd')

B = set('cdef')

C = set("ab")

>>> C < A

True

>>> C < B

False

>>> C.issubset(A)

True

(2)并集: 使用操作符 | 求并集, 也可使用union( )

>>> A | B

{'a', 'b', 'c', 'd', 'e', 'f'}

>>> A.union(B)

{'a', 'b', 'c', 'd', 'e', 'f'}

(3)交集: 使用操作符 & 求交集, 也可使用intersection( )

>>> A & B

{'c', 'd'}

>>> A.intersection(B)

{'c', 'd'}

(4)差集: A与B的差集是所有属于A且不属于B的元素构成的集合

使用操作符 - 求差集, 也可以使用difference( )

>>> A - B

{'a', 'b'}

>>> A.difference(B)

{'a', 'b'}

(5)对称差: 两个集合的对称差是只属于其中一个集合,而不属于另一个集合的元素组成的集合

使用操作符 ^ 求对称差集, 也可以使用symmetric_difference( )

>>> A ^ B

{'a', 'b', 'e', 'f'}

>>> A.symmetric_difference(B)

{'a', 'b', 'e', 'f'}

 

4. 集合方法

(1)add向集合中添加元素

>>> s = {1, 2, 3, 4, 5, 6}

>>> s.add("s")

>>> s

{1, 2, 3, 4, 5, 6, 's'}

(2)clear清空集合

>>> s = {1, 2, 3, 4, 5, 6}

>>> s.clear()

>>> s

set()

(3)copy返回集合的浅拷贝

>>> s = {1, 2, 3, 4, 5, 6}

>>> new_s = s.copy()

>>> new_s

{1, 2, 3, 4, 5, 6}

new_s.add('s')

>>> new_s

{1, 2, 3, 4, 5, 6, 's'}

>>> s

{1, 2, 3, 4, 5, 6}

(4)pop删除并返回任意的集合元素(如果集合为空,会引发KeyError)

>>> s = {1, 2, 3, 4, 5, 6}

>>> s.pop()　　# pop删除时是无序的随机删除

1

>>> s

{2, 3, 4, 5, 6}

(5)remove删除集合中的一个元素(如果元素不存在,会引发KeyError)

>>> s = {1, 2, 3, 4, 5, 6}

>>> s.remove(3)

>>> s

{1, 2, 4, 5, 6}

(6)discard删除集合中的一个元素(如果元素不存在,则不执行任何操作)

>>> s = {1, 2, 3, 4, 5, 6}

>>> s.discard("sb")

>>> s

{1, 2, 3, 4, 5, 6}

(7)intersection将两个集合的交集作为一个新的集合返回

>>> 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将集合的并集作为一个新集合返回

>>> 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将两个或多个集合的差集作为一个新集合返回

>>> 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将两个集合的对称差作为一个新集合返回(两个集合合并删除相同部分,其余保留)

>>> s = {1, 2, 3, 4, 5, 6}

>>> s2 = {3, 4, 5, 6, 7, 8}

>>> s.symmetric_difference(s2)

{1, 2, 7, 8}

(11)update用自己和另一个的并集来更新这个集合

>>> s = {'p', 'y'}

>>> s.update(['t', 'h', 'o', 'n']) # 添加多个元素, s = s | s2

>>> 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( ) 用自己和另一个的交集来更新这个集合

>>> s = {'a', 'b', 'c', 'd', 'q'}

>>> s2 = {'c', 'd', 'e', 'f'}

>>> s.intersection_update(s2) # 相当于s = s - s2

>>> s

{'c', 'd'}

(13)isdisjoint( ) 如果两个集合有一个空交集,返回True

>>> 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

>>> 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

>>> 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( ) 从这个集合中删除另一个集合的所有元素

>>> 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( ) 用自己和另一个的对称差来更新这个集合

>>> 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}

 

5 集合与内置函数

all( )          如果集合中的所有元素都是True(或者集合为空), 则返回True

any( )        如果集合中有元素为True, 则返回True; 如果集合为空,则返回False

enumerate( )     返回一个枚举对象,其中包含了集合中所有元素的索引和值(配对)

len( )      返回集合的长度

max( )    返回集合的最大值

min( )     返回集合的最小值

sorted( )    从集合的元素返回新的排序列表(不排序集合本身),返回的是列表, sort( )函数不能用于集合排序,因为其实list内置方法

sum( )      返回集合的所有元素之和

仅适用于可变集合set的函数:

s.add(x)

s.clear()

s.discard(value)

s.remove(value)

s.pop()

s.difference_update(x) 

s.update(x)

s.symmetric_difference_update(x) 

s.intersection_update(x)

总结: 对于可变集合set和不可变集合frozenset, 后者由于不能改变,所以对内部元素修改的方法后者没有,也不能update

 

转载 https://www.cnblogs.com/suendanny/p/8597596.html