Python 集合set操作

1
2
3
4
5
6
7
8
9
se = {11, 22, 33}
be = {22, 55}
temp1 = se.difference(be)        #找到se中存在，be中不存在的集合，返回新值
print(temp1)        #{33, 11}
print(se)        #{33, 11, 22}

temp2 = se.difference_update(be) #找到se中存在，be中不存在的集合，覆盖掉se
print(temp2)        #None
print(se)           #{33, 11},

1
2
3
4
5
6
7
8
9
10
11
12
13
14
se = {11, 22, 33}
se.discard(11)
se.discard(44)  # 移除不存的元素不会报错
print(se)

se = {11, 22, 33}
se.remove(11)
se.remove(44)  # 移除不存的元素会报错
print(se)

se = {11, 22, 33}  # 移除末尾元素并把移除的元素赋给新值
temp = se.pop()
print(temp)  # 33
print(se) # {11, 22}

1
2
3
4
5
6
7
8
9
10
se = {11, 22, 33}
be = {22, 55}

temp1 = se.intersection(be)             #取交集，赋给新值
print(temp1)  # 22
print(se)  # {11, 22, 33}

temp2 = se.intersection_update(be)      #取交集并更新自己
print(temp2)  # None
print(se)  # 22

1
2
3
4
5
6
se = {11, 22, 33}
be = {22}

print(se.isdisjoint(be))        #False，判断是否不存在交集（有交集False，无交集True）
print(se.issubset(be))          #False，判断se是否是be的子集合
print(se.issuperset(be))        #True，判断se是否是be的父集合

1
2
3
4
5
6
7
8
9
10
se = {11, 22, 33}
be = {22}

temp1 = se.symmetric_difference(be)  # 合并不同项，并赋新值
print(temp1)    #{33, 11}
print(se)       #{33, 11, 22}

temp2 = se.symmetric_difference_update(be)  # 合并不同项，并更新自己
print(temp2)    #None
print(se)             #{33, 11}

1
2
3
4
5
6
se = {11, 22, 33}
be = {22,44,55}

temp=se.union(be)   #取并集，并赋新值
print(se)       #{33, 11, 22}
print(temp)     #{33, 22, 55, 11, 44}

1
2
3
4
5
6
7
se = {11, 22, 33}
be = {22,44,55}

se.update(be)  # 把se和be合并，得出的值覆盖se
print(se)
se.update([66, 77])  # 可增加迭代项
print(se)

1
2
3
4
5
6
7
8
9
10
11
12
se = set(range(4))
li = list(se)
tu = tuple(se)
st = str(se)
print(li,type(li))
print(tu,type(tu))
print(st,type(st))

OUTPUT:
[0, 1, 2, 3] <class 'list'>
(0, 1, 2, 3) <class 'tuple'>
{0, 1, 2, 3} <class 'str'>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
t.add('x')            # 添加一项 s.update([10,37,42])  # 在s中添加多项


t.remove('H') # 删除一项

len(s)  # set 的长度

x in s # 测试 x 是否是 s 的成员 

x not in s   # 测试 x 是否不是 s 的成员 

s.issubset(t)  s <= t  # 测试是否 s 中的每一个元素都在 t 中 

s.issuperset(t)  s >= t  # 测试是否 t 中的每一个元素都在 s 中 

s.union(t)  s | t  # 返回一个新的 set 包含 s 和 t 中的每一个元素 

s.intersection(t)  s & t  # 返回一个新的 set 包含 s 和 t 中的公共元素 

s.difference(t)  s - t  # 返回一个新的 set 包含 s 中有但是 t 中没有的元素 

s.symmetric_difference(t)  s ^ t  # 返回一个新的 set 包含 s 和 t 中不重复的元素 

s.copy()  # 返回 set “s”的一个浅复制