python从入门到就业-数据类型-集合

概念

无序的 ，不可随机访问的，不可重复的元素
和数学中的集合定义类似，可以进行交、并、差、补等逻辑运算

分为可变集合和不可变集合
set : 可变集合 可以增、删、改
frozenset ：不可变集合，创造好之后，无法增删改

集合的定义

可变集合

#可变集合
#方式1
s = {1, 2, 3}
print(type(s), s) #<class 'set'> {1, 2, 3}

#方式2 
#set(iterable) iterable必须为可迭代元素集合
s = set("abc") #无顺序的！
print(s, type(s)) #{'a', 'c', 'b'} <class 'set'>
s = set([1, 2, 3])
print(s, type(s)) #{1, 2, 3} <class 'set'>
s = set((1, 2, 3))
print(s, type(s)) #{1, 2, 3} <class 'set'>
#字典，仅仅只根据key生成
s = set({"name" : "yw", "age" : 18})
print(s, type(s)) #{'age', 'name'} <class 'set'> 

#方式3 集合推导式子
s = set(x for x in range(5) if x != 0)
print(s, type(s)) {1, 2, 3, 4} <class 'set'>
s = {x for x in range(5)}
print(s, type(s)) #{0, 1, 2, 3, 4} <class 'set'>

不可变集合

#s = frozenset(iterable) 可迭代元素可以是字符串、列表、元组、字典等
#可迭代元素是字典时，只会取其中的key来组成集合
s = frozenset("abc")
print(s, type(s)) #frozenset({'a', 'c', 'b'}) <class 'frozenset'>
s = frozenset({"name" : "hello", "age" : 19})
print(s, type(s)) #frozenset({'age', 'name'}) <class 'frozenset'>

#集合推导式 不能用{} {}默认是可变
s = frozenset(x**2 for x in range(5) if x%2 == 0)
print(s, type(s))#frozenset({0, 16, 4}) <class 'frozenset'>

注意！

1 创建空的集合时候，可以使用set() 或者frozenset{}而不能使用s={}， 会被识别成字典

s = {}
print(type(s)) #<class 'dict'>
s = set()
print(type(s)) #<class 'set'>

2 集合中的元素， 必须是可以哈希的值
可哈希：如果一个对象在自己的生命周期当中有一个哈希值是不可改变的，那么这个对象是可哈希的
可以简单理解为不可变类型

s = {1, 2, 3, [1, 2]} 
print(s) #TypeError: unhashable type: 'list'

如果集合中的元素重复出现， 则会被合并成一个
可以给列表去重！

s = {1, 1, 1, 1, 2}
print(s) #{1, 2}

l = [3, 2, 3, 2]
print(list(set(l))) #[2, 3]

常用操作

单一集合操作

可变集合

增加

#s.add(element) 
#新增操作
s = {1, 2, 3}
s.add(4)
print(s) #{1, 2, 3, 4}
s.add([1, 2])
print(s) #TypeError: unhashable type: 'list'

删除

#s.remove(element)
#删除s中指定的元素 如果元素不存在 返回错误
s = {1, 2, 3}
print(s.remove(1), s) #None {2, 3}
#print(s.remove(4)) #KeyError: 4

#s.discard(element)
#删除s中指定的元素， 如果s不存在 什么都不做
s = {1, 2, 3}
print(s.discard(1), s) #None {2, 3}
print(s.discard(4), s) #None {2, 3}

#s.pop()
#随机删除并返回集合中的元素 
#若集合为空 则返回一个错误
s = {1, 2, 3}
print(s.pop(), s) #1 {2, 3}

#s.clear()
#清空一个集合中的所有元素
s = {1, 2, 3}
print(s.clear(), s) #None set()

修改

内部的元素都是不可变类型，也就是不能里面的元素

查找

无法通过索引或者key进行查询

不可变集合

不能增删改

共同操作

#for in 遍历
sets = {1, 2, 3, 4}
for i in sets:
    print(i) #1 2 3 4

#利用迭代器来迭代 越界会报错
sets = {1, 2, 3, 4}
iter_set = iter(sets)
print(next(iter_set)) #1

iter_set = iter(sets)
for i in iter_set:
    print(i) #1 2 3 4

集合之间的操作

交集

可变与不可变集合的混合运算，返回结果类型以运算符左侧为主

#s1.intersection(Iterable)
s1 = {1, 2, 3, 4, 5}
s2 = {2, 3, 4, 5, 6}
print(s1.intersection(s2)) #{2, 3, 4, 5}
print(s1, s2) #{1, 2, 3, 4, 5} {2, 3, 4, 5, 6}
#交集结果的类型，谁在前面就以谁为基准
s1 = frozenset({1, 2, 3, 4, 5})
s2 = {2, 3, 4, 5, 6}
print(s1.intersection(s2)) #frozenset({2, 3, 4, 5})
print(s1, s2) #frozenset({1, 2, 3, 4, 5}1 & 6}
#可以遍历的元素 list、dict、tuple都可以求交集 字典则是键
s1 = {"a", "b", "c"}
print(s1.intersection("ab")) #{'a', 'b'} #会先转集合再求交集  所以必须哈希
d = {"a" : 1, "b": 2}
print(s1.intersection(d)) #{'a', 'b'}
print(s1.intersection([1, 2, [1, 2]])) #TypeError: unhashable type: 'list'
#&
#交集结果的类型，谁在前面就以谁为基准
s1 = {1, 2, 3, 4, 5}
s2 = {2, 3, 4, 5, 6}
print(s1 & s2) #{2, 3, 4, 5}
print(s1, s2)#{1, 2, 3, 4, 5} {2, 3, 4, 5, 6}

#s1.intersection_update(s2)
#直接修改s1
#s1必须为可变集合
s1 = {1, 2, 3, 4, 5}
s2 = {2, 3, 4, 5, 6}
print(s1.intersection_update(s2))#None
print(s1, s2) #{2, 3, 4, 5} {2, 3, 4, 5, 6}

并集

#s1.union(iterable) 
s1 = {1, 2, 3}
s2 = {3, 4, 5}
print(s1.union(s2), s1, s2) #{1, 2, 3, 4, 5} {1, 2, 3} {3, 4, 5}

#|
print(s1 | s2, s1, s2) #{1, 2, 3, 4, 5} {1, 2, 3} {3, 4, 5}

#s1.update(s2) s1本身会发生变化
s1 = {1, 2, 3}
s2 = {3, 4, 5}
print(s1.update(s2), s1, s2) #None {1, 2, 3, 4, 5} {3, 4, 5}

差集

#s1.difference(s2)
s1 = {1, 2, 3}
s2 = {3, 4, 5}
print(s1.difference(s2), s1, s2) #{1, 2} {1, 2, 3} {3, 4, 5}

#s1 - s2
print(s1 - s2, s1, s2) #{1, 2} {1, 2, 3} {3, 4, 5}

#s1.difference_update(s2) 会修改s1
print(s1.difference_update(s2), s1, s2) #None {1, 2} {3, 4, 5}

判断(相交、包含、子集

#s1.isdisjoint(s2)
#俩个集合不相交
s1 = {1, 2, 3}
s2 = {3, 4, 5}
print(s1.isdisjoint(s2)) #False

#s1.issuperset(s2)
#s1是否包含s2
print(s1.issuperset(s2))#False
print(s1.issuperset({1, 2}))#True

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