[PY3]——内置数据结构(6)——集合及其常用操作

集合及其常用操作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'}