python基础 ---核心数据结构之（集合）

集合也叫哈希表，是由有限个互不相同且可改变的元素组成的一个无序的列表
由此可见，集合主要有以下特点：
（1）集合元素不可重复
（2）集合元素都是可哈希的数据类型，因此集合元素可改变指的是可以进行元素的增删
（3）集合是非线性结构
另外：集合是不可hash的

初始化

集合的初始化使用关键字set

set()
set(iterable)  #最多一个参数

s1=set()
s2=set(1)  ##报错，整型不是iterable对象
s3=set([1,2,3])
s4=set({'a','b','c'})
s5=set('abcdefg')

#直接使用赋值的方式
s1={11}
s2={1,'a'}
s3={[1],2,3}  #列表不能hash，因此此语句报错，去掉元素[1]即可
s4={1,(2,)}  
s5={}  ##这是字典的初始化方式，因此s5是个字典
print(type(s5))
<class 'dict'>

增加元素

元素增加的方式有add和update这两个函数
add(elem) #直接添加元素，元素必须是可哈希类型
update(*others)#可以合并其他集合或者是可迭代对象中的元素，*表示尽可能多的合并元素，属于解构知识封装与解构

#集合是无序的，因此输出的顺序和录入的顺序可能不一样
>>> s1={1}
>>> s2={2}
>>> s3={3}
>>> s4={999}
>>> s4.update(s1,s2,s3)
>>> print(s4)
>>> s4.update([11,22,33])
>>> print(s4)
>>> s4.update({111,222,333})
>>> print(s4)
>>> s4.update('abcdef')
>>> print(s4)
{1, 2, 3, 999}
{1, 2, 3, 33, 999, 11, 22}
{1, 2, 3, 33, 999, 11, 333, 111, 22, 222}
{1, 2, 3, 33, 'c', 'f', 999, 'e', 11, 333, 111, 22, 'd', 'b', 'a', 222}

>>> s4.add('xiejiawen')
>>> print(s4)
{1, 2, 3, 33, 'c', 'f', 999, 'e', 11, 333, 111, 'xiejiawen', 22, 'd', 'b', 'a', 222}

删除元素

删除元素的函数有：

remove(elem)  #删除元素，元素不存在则报KeyError
discard(elem) #移除元素，元素不存在就不操作，同时只能删除一个元素
pop() --> item # 随机删除一个元素，不能带参数
clear()    #清空集合

>>> s4={1, 2, 3, 33, 'c', 'f', 999, 'e', 11, 333, 111, 'xiejiawen', 22, 'd', 'b', 'a', 222}
>>> s4.remove(1)
>>> s4.remove('1')  ##删除不存在的元素，会报KeyError

>>> s4={1, 2, 3, 33, 'c', 'f', 999, 'e', 11, 333, 111, 'xiejiawen', 22, 'd', 'b', 'a', 222}
>>> s4.remove(1)
>>> # s4.discard(1,2) #报错，参数最大数量为1
>>> s4.discard(2)
>>> s4.discard(2) #重复删除不会报错
>>> print(s4)

>>> s4={3, 'c', 33, 'f', 999, 'e', 11, 333, 111, 'xiejiawen', 22, 'd', 'b', 'a', 222}
>>> s4.pop() #因为每次程序运行时都有一个随机值，这样会导致集合中的hash计算出现变化，所以每次会随机删除一个数据
>>> print(s4)#如果集合为空会报KeyError

可修改与不可索引

集合的元素修改其实就是元素的增删，因为元素是可hash的，那么元素内容必然不可修改，只可以对元素的数量进行增删
集合是无序的，因此不可使用索引来查找元素

集合遍历与查询

只要是容器，遍历每个元素那么时间复杂度必然是O(n)，但是对于元素的查询，集合的效率就要高很多
#集合对于元素查询的时间复杂度为O(1)
成员运算符
列表成员运算符：print(10 in [2,3,5,10])
集合成员运算符：print(10 in {2,3,5,10})
当使用value来查找元素时，使用列表的时间复杂度为O(n)，但是使用value在集合中查找时，时间复杂度为O(1)，因为集合是通过hash值来查找元素的

集合运算

并集
将两个集合的所有元素合并到一起，这就是并集运算

#这几个运算相当于是并集运算
union(*others) #当前集合与参数中的多个集合求并集，返回一个新集合，原集合不变
|  #运算符重载，相当于union
update(*others) #
|=  #等价于update(*others)

>>> s1={1}
>>> s2={2}
>>> s3={3}
>>> s3.union(s1,s2)  #只是进行计算，s3并没有发生改变
{1, 2, 3}

>>> s3.update(s1,s2)  #update会发生改变
>>> print(s3)
{1, 2, 3}

交集
获取所有既在集合a中的也在集合b中的元素

intersection(*others)
&   #等同于intersection
intersection_update(*others) #同时与多个集合求交集，并且就地修改
&=  #等同于intersection_update

>>> s1={1,2,3,4,5}
>>> s2={2,3,4,5,6}
>>> s3={3,4,5,6,7}
>>> s1.intersection(s2) #只是进行交集运算，不会改变原有的集合，不返回数据
{2, 3, 4, 5}

>>> s2.intersection_update(s1,s3)
>>> print(s2)
{3, 4, 5}   #s2发生了改变

差集
获取数据属于集合a且不属于集合b的所有元素，也就是用集合a减去集合a和b的交集

difference(*others) #
-
difference_update(*others) #获取与多个集合的差集，并且就地修改，不返回数据
-=  #等同于difference_update

>>> s1={1,2,3,4,5}
>>> s2={2,3,4,5,6,999}
>>> s3={3,4,5,6,7}
>>> s2.difference_update(s1,s3)
>>> print(s2)
999

对称差集
两个集合的并集减去两个集合的交集

symmetric_difference(other) #两个集合之间的运算，只能带一个参数
^   #等同于symmetric_difference
symmetric_difference()

>>> s1={1,2,3,4,5}
>>> s2={2,3,4,5,6,999}
>>> s3={3,4,5,6,7}
>>> s2.symmetric_difference(s3)
{2, 7, 999}

>>> s1={1,2,3,4,5}
>>> s2={2,3,4,5,6,999}
>>> s3={3,4,5,6,7}
# s2.symmetric_difference(s3)
>>> s2.symmetric_difference_update(s3) #就地修改，直接对s2产生修改
>>> print(s2)
{2, 999, 7}

其他集合运算

issubset(other)、<=  判断当前集合是否是另一个集合的子集
set1 < set2  判断set1是否是set2的真子集
issuperset(other)、>=  判断当前集合是否是other的超集
set1 > set2  判断set1是否是set2的真超集
isdisjoint(other)  当前集合和另一个集合没有交集，没有交集，返回True