集合及其常用操作Xmind图
集合的定义
# set( )
# {0,1,2} //注意不能用空的大括号来定义集合
# set(可迭代对象) In [1]: s=set();type(s)
Out[1]: set In [2]: s={0,1,2};type(s)
Out[2]: set In [3]: s=set(range(5));type(s)
Out[3]: set
增加操作
1. add()
In [8]: s={0,1,2}
#在集合后添加单个元素
In [9]: s.add(3);s
Out[9]: {0, 1, 2, 3}
#增加已存在的元素时，集合不变
In [10]: s.add(3);s
Out[10]: {0, 1, 2, 3}
2. update()
In [12]: s={0,1,2}
#增加一个可迭代对象
In [13]: s.update(range(4,7));s
Out[13]: {0, 1, 2, 4, 5, 6}
In [14]: s.update(range(4,9));s
Out[14]: {0, 1, 2, 4, 5, 6, 7, 8}
删除操作
1. remove() 删除给定元素，元素不存在抛出KeyError
In [16]: s={0,1,2}
In [17]: s.remove(0);s
Out[17]: {1, 2}
In [18]: s.remove(10);s
KeyError: 10
2. discard() 删除给定元素，元素不存在什么都不做
In [27]: s=set(range(10));s
Out[27]: {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} In [29]: s.discard(4);s
Out[29]: {0, 1, 2, 3, 5, 6, 7, 8, 9} In [30]: s.discard(10);s
Out[30]: {0, 1, 2, 3, 5, 6, 7, 8, 9}
3. pop() 随机删除一个元素并返回该元素
In [19]: s={0,1,2}
In [21]: s.pop()
Out[21]: 0
In [22]: s.pop()
Out[22]: 1
In [24]: s.pop()
Out[24]: 2
In [25]: s
Out[25]: set()
In [26]: s.pop() //当集合为空时。报错KeyError
KeyError: 'pop from an empty set'
4. clear() 清空集合
In [31]: s=set(range(10));s
Out[31]: {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} In [32]: s.clear();s
Out[32]: set()
修改操作
集合不能修改单个元素
查找操作
集合不是一个线性结构，所以集合不能通过索引查找、集合也没有顺序、集合也没有访问单个元素的方法
集合运算
1. 交集运算
# intersection()求交集
In [1]: s1={1,2,3};s2={2,3,6} In [2]: s1.intersection(s2)
Out[2]: {2, 3} # intersection_update() 求交集并修改了s1
In [5]: s1.intersection_update(s2) In [6]: print(s1,s2)
{2, 3} {2, 3, 6} # set重载了‘&’作为求交集的运算符
In [9]: s1 & s2
Out[9]: {2, 3}
2. 差集运算
# difference()
In [10]: s1={1,2,3};s2={2,3,6} In [11]: s1.difference(s2)
Out[11]: {1} In [12]: s2.difference(s1)
Out[12]: {6} In [13]: print(s1,s2)
{1, 2, 3} {2, 3, 6} # difference_update()
In [14]: s1.difference_update(s2) In [15]: print(s1,s2)
{1} {2, 3, 6} # set重载了‘-’作为求差集的运算符
In [17]: s1-s2
Out[17]: {1} In [18]: s2-s1
Out[18]: {6}
3. 对称差集=交集的补集
# symmetric_difference()求对称差集
In [19]: s1={1,2,3};s2={2,3,6} In [20]: s1.symmetric_difference(s2)
Out[20]: {1, 6} # symmetric_difference_update()同理 # set重载了‘^’作为求对称差集的运算符
In [26]: s1^s2
Out[26]: {1, 6}
4. 并集运算
# union()求并集
In [27]: s1={1,2,3};s2={2,3,6} In [28]: s1.union(s2)
Out[28]: {1, 2, 3, 6} # update()就是并集的uptdate版本
In [29]: s1.update(s2) In [30]: print(s1,s2)
{1, 2, 3, 6} {2, 3, 6} # set重载了‘|’作为求并集的运算符
In [2]: s1|s2
Out[2]: {1, 2, 3, 6}
集合相关的判断
# A.issubset(B) 判断A是否是B的子集
In [1]: s1={1,2,3,4};s2={2,3} In [2]: s2.issubset(s1)
Out[2]: True In [3]: s1.issubset(s2)
Out[3]: False # A.issuperset(B) 判断A是否是B的超集
In [4]: s1.issuperset(s2)
Out[4]: True In [5]: s2.issuperset(s1)
Out[5]: False # isdisjoint()判断是否有交集，有交集返回False、无交集返回True
In [6]: s1={1,2,3,4};s2={2,3};s1.isdisjoint(s2)
Out[6]: False In [8]: s3={1,2};s4={6,3};s3.isdisjoint(s4)
Out[8]: True
集合的应用
1.去重
2.成员运算符时的效率提高（参见博文《[PY3]——基本语法中成员运算符的内容》）
3.场景一：有一个api它要有认证并且有一定权限才可以访问，例如要求满足权限A/B/C任意一项，有一个用户具有权限B、C、D，判断该用户是否有权限访问此API
4.场景二：有一个任务列表存储全部的任务，有一个列表存储已完成的任务，找出未完成的任务
集合的限制
总结来说：集合的元素必须是可Hash的(tuple、str、bytes等)
# list不可作为集合元素
In [10]: {[1,1,2],[6,6,8]}
TypeError: unhashable type: 'list' # bytearray不可作为集合元素
In [11]: {bytearray(b'abc')}
TypeError: unhashable type: 'bytearray' # set不可作为集合元素
In [12]: {{6,6,8}}
TypeError: unhashable type: 'set' # tuple可作为集合元素
In [13]: {(3,1,3)}
Out[13]: {(3, 1, 3)} # bytes可作为集合元素
In [14]: {b'abc'}
Out[14]: {b'abc'} # str可以作为集合元素
In [15]: {'b','a'}
Out[15]: {'a', 'b'}