集合

1、定义: 在{}内用逗号分隔开多个元素，多个元素满足以下三个条件：

（1）集合内元素必须为不可变类型

（2）集合内元素无序

（3）集合内元素没有重复

 s={1,[1,2]}  # 集合内元素必须为不可变类型

 s={1,'a','z','b',4,7}  # 集合内元素无序

 s={1,1,1,1,1,1,'a','b'}  # 集合内元素没有重复

s={} # 默认是空字典

 s=set()  # 定义空集合

2、类型转换：但凡能被for循环的遍历的数据类型（强调：遍历出的每一个值都必须为不可变类型）都可以传给set()转换成集合类型

列表s = set([1,2,3,4])   # {1, 2, 3, 4}

元组 s1= set((1,2,3,4))  # {1, 2, 3, 4}

字典s2 = set({'name':'jason',})  # {'name'}

字符串s3 = set('egon')   # {'e', 'o', 'g', 'n'}

3、内置方法

*关系运算

friends1 = {"zero","kevin","jason","egon"}

friends2 = {"Jy","ricky","jason","egon"}

（1）取交集：两者共同的部分

 res=friends1 & friends2

 print(res)  # {'jason', 'egon'}

 print(friends1.intersection(friends2))

（2）取并集/合集：两者所有的部分

 print(friends1 | friends2) 

# {'jason', 'egon', 'ricky', 'Jy', 'zero', 'kevin'}

 print(friends1.union(friends2)) 

（3）取差集：取friends1独有的部分

 print(friends1 - friends2) # {'zero', 'kevin'}

 print(friends1.difference(friends2))

# 取friends2独有的部分

 print(friends2 - friends1)  # {'Jy', 'ricky'}

（3）对称差集: 求两个用户独有的部分(即去掉公共部分)

 print(friends1 ^ friends2) # {'ricky', 'kevin', 'zero', 'Jy'}

print(friends1.symmetric_difference(friends2))

（4）父子集：包含的关系

 s1={1,2,3}   s2={1,2,4}

# 不存在包含关系，下面比较均为False

 print(s1 > s2)

 print(s1 < s2)

 s1={1,2,3}   s2={1,2}

 print(s1 > s2) # 当s1大于或等于s2时，s1包含s2

 print(s1.issuperset(s2)) # s1 > s2  =>True

 print(s2.issubset(s1))  # s2 < s1  =>True

 s1={1,2,3}   s2={1,2,3}

 print(s1 == s2) # s1与s2互为父子

*去重

（1）只能针对不可变类型去重

（2）无法保证原来的顺序

*其他操作

（1）长度.len()

（2）成员运算in和not in

（3）循环:输出集合里的每个元素

（4）.discard()  # 删除元素不存在返回None

（5）.remove()  # 删除元素不存在则报错

（6）.update()  # 用新集合更新就集合

（7）.pop()  # 删除元素可返回删除的元素

（8）.add()  # 添加元素

（9）.isdisjoint() # 两个集合完全独立、没有共同部分，返回True

（10）.difference_update() # 相当于差运算

数据类型总结：

按存值个数区分
只能存一个值：可称为标量/原子类型	数字类型、字符串
可存放多个值：容器类型	列表、元组、字典、集合
按照访问方式区分
直接访问：只能通过变量名访问整个值	数字类型
顺序访问：可以用索引访问指定的值，索引代表顺序，又称为序列类型	字符串、列表、元组
Key访问：用键访问指定的值，又称映射类型	字典
按可变类型和不可变类型区分
不可变类型	数字类型、字符串、元组
可变类型	列表、字典、集合