Python3 集合

集合是由不同元素组成，无序，集合中的元素必须是不可变类型（字符串，数字，元组），集合会去重，把重复的元素去掉，只留一个

s={1,2,3,3,5,6}
print(s)

运行结果：

{1, 2, 3, 5, 6}

集合内置函数：

#add 添加元素到集合，因为集合本身是无序的，所以添加位置也是随机

s={1,2,3,4,5,6}
s=set(s)
s.add("s")
s.add("3")
s.add(3)
print(s)

运行结果：

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

# clear 清空集合

s={1,2,3,4,5,6}
s=set(s)
s.clear()
print(s)

运行结果：

set()

#copy 复制集合

s={1,2,3,4,5,6}
s=set(s)
s1=s.copy()
print(s1)

运行结果：

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

#删除集合元素的三种方法：pop remove discard

#pop随机删，因为集合是无序的

s={1,2,3,4,5,6}
s=set(s)
s.pop()
print(s)

运行结果：

{2, 3, 4, 5, 6}

#remove discard指定删除

s={1,2,3,4,"sb",6,7}
s.remove('hellol') #删除元素不存在会报错
print(s)

运行结果：.

KeyError: 'hellol'

s={1,2,3,4,"sb",6,7}
s.discard('sbbbb')#删除元素不存在不会报错
print(s)

运行结果：

{1, 2, 3, 4, 6, 7, 'sb'}

集合的交集，即两个集合或者多个集合拥有的相同的元素

python_l=['lcg','szw','zjw','lcg']
linux_l=['lcg','szw','sb']
p_s=set(python_l)
l_s=set(linux_l)
# #求交集  及相同的元素
print(p_s,l_s)
print(p_s.intersection(l_s))
print(p_s&l_s) #相当于做与运算

运行结果：

{'zjw', 'lcg', 'szw'} {'lcg', 'szw', 'sb'}
{'lcg', 'szw'}
{'lcg', 'szw'}

并集即两个集合的所有的元素，相同的只取一个

python_l=['lcg','szw','zjw','lcg']
linux_l=['lcg','szw','sb']
p_s=set(python_l)
l_s=set(linux_l)
# #求交集  及相同的元素
print(p_s,l_s)
print(p_s.union(l_s))
print(p_s|l_s) #且运算

运行结果：

{'szw', 'lcg', 'zjw'} {'szw', 'lcg', 'sb'}
{'szw', 'lcg', 'sb', 'zjw'}
{'szw', 'lcg', 'sb', 'zjw'}

差集即A集合中B集合没有的元素

python_l=['lcg','szw','zjw','lcg']
linux_l=['lcg','szw','sb']
p_s=set(python_l)
l_s=set(linux_l)
# #求交集  及相同的元素
print(p_s,l_s)
print('差集',p_s-l_s)
print(p_s.difference(l_s))
print('差集',l_s-p_s)
print(l_s.difference(p_s))

运行结果：

{'zjw', 'lcg', 'szw'} {'sb', 'lcg', 'szw'}
差集 {'zjw'}
{'zjw'}
差集 {'sb'}
{'sb'}

交叉补集即剔除合集的相同元素，也可以理解为并集减去差值

python_l=['lcg','szw','zjw','lcg']
linux_l=['lcg','szw','sb']
p_s=set(python_l)
l_s=set(linux_l)
# #求交集  及相同的元素
print(p_s,l_s)
print('交叉补集',p_s.symmetric_difference(l_s))
print('交叉补集',p_s^l_s)

运行结果：

{'lcg', 'zjw', 'szw'} {'lcg', 'szw', 'sb'}
交叉补集 {'zjw', 'sb'}
交叉补集 {'zjw', 'sb'}

python_l=['lcg','szw','zjw','lcg']
linux_l=['lcg','szw','sb']
p_s=set(python_l)
l_s=set(linux_l)
print(p_s,l_s)
# print('差集',p_s-l_s)
# p_s=p_s-l_s
p_s.difference_update(l_s) #相当于p_s=p_s.difference(l_s)
print(p_s)
p_s.symmetric_difference_update(l_s) #相当于 a=a.symmetric_difference(b)
print(p_s)

运行结果

{'zjw', 'lcg', 'szw'} {'sb', 'lcg', 'szw'}
{'zjw'}
{'zjw', 'lcg', 'szw', 'sb'}

#集合的update基本上都是类似的，都是求了交集或并集之后赋值给原值

isdisjoint 判断两个集合的交集是否为空为空返回True，否则返回False

s1={1,2}
s2={2,3,5}
print(s1.isdisjoint(s2))

运行结果：

False

issubset 判断a是否是b的子集（b是否包涵a）

issuperset 判断a是否是b的父集

s1={1,2}
s2={1,2,3}
print(s1.issubset(s2))#s1 是s2 的子集
print(s2.issubset(s1))#False

print(s2.issuperset(s1))#s1 是s2 的父集

运行结果：

True
False
True

s1={1,2}
s2={1,2,3,4589}
s1.update(s2)
print(s1)#更新多个值 相当于求并集a1=a.union(b)

运行结果：

{1, 2, 3, 4589}

#集合是可变类型，因为可以更改，删除，增加，如果不想让别人更改集合可以使用forzenset方法，可以让集合变成不可变集合
s=frozenset('hello')
print(s)

##如何将集合转换为列表，借用list函数

names=['alex','alex','wupeiqi']
names=list(set(names))
print(names)

运行结果：

['alex', 'wupeiqi']

猜你喜欢