Python-集合

---

一、集合是什么？

无序 不可随机访问 不可重复
与数学中集合的概念类似，可对其进行交、并、差、补等逻辑运算
分为可变集合（set）不可变集合（frozenset）

二、定义

可变集合set
s = {1,2,3,4}
s = set(iterable)
其中iterable可以是字符串、列表、元组、字典等
但是为dict时，只会获取提Key作为set的元素
集合推导式
s = set(x**2 for x in range(1, 10) if x % 2 == 0)
s = {推导式}

s={1,2,3}
a="abc"
b=[1,2,3,a]
t=(1,2,a)
d={1:"1",2:"2",3:'3'}
st=set(x for x in range(0,10))
st1={x for x in range(0,10)}
print(s,type(s))
print(set(a),type(set(a)))
print(set(b), type(set(b)))
print(set(t),(type(set(t))))
print(set(t),type(set(d)))
print(st,type(st))
print(st1,type(st1))
结果：
{'a', 'b', 'c'} <class 'set'>
{'abc', 1, 2, 3} <class 'set'>
{'abc', 1, 2} <class 'set'>
{'abc', 1, 2} <class 'set'>
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} <class 'set'>
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} <class 'set'>

不可变集合frozenset（与可变集合相比仅仅少了第一种，直接写花括号可以认为花括号指可变集合）
fs = frozenset(iterable)
其中iterable可以是字符串、列表、元组、字典等
但是为dict时，只会获取提Key作为set的元素
集合推导式
s = frozenset(x**2 for x in range(1, 10) if x % 2 == 0)

a="abc"
fs=frozenset(a)
fss=frozenset(x for x in range(0,10))
print(fs,type(fs))
print(fss,type(fss))
结果：
frozenset({'a', 'b', 'c'}) <class 'frozenset'>
frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9}) <class 'frozenset'>

注意
1. 创建一个空集合时, 需要使用set() 或者 frozenset(), 不能使用 s = {}
会被识别成为字典
2. 集合中的元素, 必须是可哈希的值
如果一个对象在自己的生命周期中有一哈希值（hash value）是不可改变的，
那么它就是可哈希的（hashable）的
暂时理解为 不可变类型
3. 如果集合中的元素值出现重复, 则会被合并为1个

三、常用操作

1.单一集合操作

	可变集合
		增
			s.add(element)
			注意:
				必须保证添加的元素是可哈希的值
		删
			s.remove(element)
				指定删除set对象中的一个元素
				如果集合中没有这个元素，则返回一个错误
			s.discard(element)
				指定删除集合中的一个元素
				若没有这个元素，则do nothing
			s.pop()
				随机删除并返回一个集合中的元素（每次都弹出第一个元素）
				若集合为空，则返回一个错误
			s.clear()
				清空一个集合中的所有元素
		改
			元素为不可变类型, 不能修改
		查
			无法通过索引或key进行查询
			1. 通过 for in 进行遍历
			2. 通过迭代器进行访问
	不可变集合
		不能增删改
		查
			1. 通过 for in 进行遍历
			2. 通过迭代器进行访问

s={1,2,3,4,5,6,7,8,9,10}
a="abc"
fs=frozenset(a)
s.add(fs)
s.remove(3)
print(s.pop())
print(s)
its=iter(s)
print(next(its))
print("------")
for v in its:
 print(v)
 结果：
 1
{2, 4, 5, 6, 7, 8, 9, 10, frozenset({'c', 'a', 'b'})}
2（迭代器不会重新开始，上下两种迭代用的是同一个迭代器，所以 for in 接着第一次next遍历后）
------
4
5
6
7
8
9
10
frozenset({'c', 'a', 'b'})

2.集合之间操作

	交集
		intersection(Iterable)
			字符串
				只判定字符串中的非数字
			列表
			元组
			字典
				值判定key
			集合
			...
		逻辑与 '&'
		intersection_update(…)
			交集计算完毕后, 会再次赋值给原对象
				会更改原对象
				所以, 只适用于可变集合

a=[1,2,3,4,5,6,7,8,9]
s3=frozenset(a)
s1={1,2,3,4,5,6}
s2={4,5,8}
result=s1.intersection(s3)
result1=s1&s2
result2=s1.intersection_update(s2)
print(result,type(result))
print(s1,s3)
print(result1,type(result1))
print(s1,s2)
print(result2,type(result2))
print(s1,s2)
结果：
{1, 2, 3, 4, 5, 6} <class 'set'>
{4, 5} frozenset({1, 2, 3, 4, 5, 6, 7, 8, 9})
{4, 5} <class 'set'>
{4, 5} {8, 4, 5}
None <class 'NoneType'>
{4, 5} {8, 4, 5}

	并集
		union()
			返回并集
		逻辑或 '|'
			返回并集
		update()
			更新并集

s1={1,2,3}
s2=frozenset([1,2,3,4])
s3={2,5,6}
s4={7,8}
result=s1.union(s2)
result1=s1|s3
result2=s3.update(s4)
print(result,type(result))
print(result1,type(result1))
print(s3,result2,type(result2))
结果：
{1, 2, 3, 4} <class 'set'>
{1, 2, 3, 5, 6} <class 'set'>
{2, 5, 6, 7, 8} None <class 'NoneType'>

	差集
		difference()
		算术运算符减 ‘-‘
		difference_update()

s1={1,2,3}
s2=frozenset([1,2,3,4])
s3={2,5,6}
s4={7,8,6,2}
result=s2.difference(s1)
result1=s1-s3
result2=s3.difference_update(s4)
print(result,type(result))
print(result1,type(result1))
print(s3,result2,type(result2))
结果:
frozenset({4}) <class 'frozenset'>
{1, 3} <class 'set'>
{5} None <class 'NoneType'>

	判定
		isdisjoint()两个集合不相交
		issuperset()一个集合包含另一个集合
		issubset()一个集合包含于另一个集合

s1={1,2,3}
s2=frozenset([1,2,3,4])
s3={2,5,6}
s4={7,8,6,2}
print(s1.isdisjoint(s2))
print(s3.issuperset(s1))
print(s1.issubset(s2))
结果：
False
False
True

注意

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