第十九节,基本数据类型,集合set

集合set，无序，是不允许重复内容的，也就是不允许重复元素，如果有重复，会自动忽略，可接收可迭代类型 （一般用于需要判断和处理交集时候用到）

集合与字典的区别是，集合没有键只有值，字典是有键的字典是一对键值对

所以创建空集合不能用{}大括号，用大括号创建空集合默认会变成字典，如果需要创建空集合用set()

创建集合

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 #创建集合
 a = set()
 a = {11,22,33,44,55,55}
 print(a)
 #打印出 {33, 11, 44, 22, 55}

转换集合

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 #转换集合
 a = [11,22,33,44,55]
 b = (11,22,33,44,55)
 c = ""
 #将列表转换成集合
 zh_a = set(a)
 print(zh_a)
 #将元组转换成集合
 zh_b = set(b)
 print(zh_b)
 #将字符串转换成集合
 zh_c = set(c)
 print(zh_c)
 #打印出
 #{33, 11, 44, 22, 55}
 #{33, 11, 44, 22, 55}
 #{'7', '5', '1', '9', '4', '2', '8', '6', '3'}

集合的类库功能

 add(self, *args, **kwargs)

"添加元素"(要添加的元素)

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 #创建一个集合
 se = {11,22,33,44}
 #向集合里添加元素
 se.add(55)
 print(se)
 #打印出 {33, 11, 44, 22, 55}

clear(self, *args, **kwargs)

"清空元素"（）

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 #创建一个集合
 se = {11,22,33,44}
 #清空集合里的元素
 se.clear()
 print(se)
 #打印出 set() 表示空集合

difference(self, *args, **kwargs)

"查找出一个集合里存在，另外一个集合不存在的元素"（格式：查找集合.difference（被判断的集合））

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 #创建二个集合
 a = {11,22,33,44}
 b = {11,55,88,44}
 #查找出a集合里存在，b集合不存在的元素
 c = a.difference(b)
 print(c)
 #打印出 {33, 22}

difference_update(self, *args, **kwargs)

"从当前集合中删除和B中相同的元素"(b集合)

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 #创建二个集合
 a = {11,22,33,44,999}
 b = {11,55,88,44}
 #从a集合中删除和B集合中相同的元素
 a.difference_update(b)
 print(a)
 #打印出 {33, 22, 999}

 discard(self, *args, **kwargs)

"移除指定元素，不存在不报错"（要移除的元素）

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 #创建一个集合
 a = {11,22,33,44,999}
 #移除指定元素，不存在不报错
 a.discard(999)
 print(a)
 #打印出 {33, 11, 44, 22}

intersection(self, *args, **kwargs)

"交集，查找出a集合和b集合都存在的元素"（b集合）

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 #创建二个集合
 a = {66,22,33,44,99}
 b = {44,55,66,77,33}
 #交集，查找出a集合和b集合都存在的元素
 c = a.intersection(b)
 print(c)
 #打印出 {33, 66, 44}

intersection_update(self, *args, **kwargs)

"交集，查找出a集合和b集合都存在的元素,并重新更新到a集合"（b集合）

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 #创建二个集合
 a = {66,22,33,44,99}
 b = {44,55,66,77,33}
 #交集，查找出a集合和b集合都存在的元素,并重新更新到a集合
 a.intersection_update(b)
 print(a)
 #打印出 {33, 66, 44}

isdisjoint(self, *args, **kwargs)

"检查a集合和b集合是否有都存在的元素"（b集合）

返回布尔值:如果没有都存在的，返回True，否则返回False

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 #创建二个集合
 a = {66,22,33,44,99}
 b = {44,55,66,77,33}
 #检查a集合和b集合是否有都存在的元素,
 c = a.isdisjoint(b)
 print(c)
 #打印出 False 说明有交集

 issubset(self, *args, **kwargs)

"判断一个集合是否是另一个集合的子序列"（b集合）

是返回True   不是返回False

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 #创建二个集合
 a = {11,22,33,44}
 b = {11,22}
 #检查a集合是否是b集合的子序列,
 c1 = a.issubset(b)
 print(c1)
 #检查b集合是否是a集合的子序列
 c2 = b.issubset(a)
 print(c2)
 #打印出
 #False 检查a集合是否是b集合的子序列,说明a集合不是b集合的子序列
 #True  检查b集合是否是a集合的子序列,说明b集合是a集合的子序列

issuperset(self, *args, **kwargs)

"判断一个集合是否是另一个集合的父序列"（b集合）

是返回True   不是返回False

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 #创建二个集合
 a = {11,22,33,44}
 b = {11,22}
 #检查a集合是否是b集合的父序列,
 c1 = a.issuperset(b)
 print(c1)
 #检查b集合是否是a集合的父序列
 c2 = b.issuperset(a)
 print(c2)
 #打印出
 #True  检查a集合是否是b集合的父序列,说明a集合是b集合的父序列
 #False 检查b集合是否是a集合的父序列,说明b集合不是a集合的父序列

pop(self, *args, **kwargs)

"移除元素"()

一般默认移除第一个元素，只是集合有一套自己的元素排序规则，

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 a = {44,55,66,77,88}
 #打印出集合，可以看到集合里的元素排序情况
 print(a)
 #移除集合里的元素，默认移除元素里的第一个排序元素
 b = a.pop()
 #打印出被移除的元素
 print(b)
 #打印出a集合被移除后剩下的所有元素
 print(a)
 #最后打印出
 #{88, 66, 44, 77, 55}
 #
 #{66, 44, 77, 55}

remove(self, *args, **kwargs)

"移除指定元素，不存在保错"(要移除的元素)

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 a = {44,55,66,77,88}
 #打印出a集合
 print(a)
 #移除a集合里指定的元素
 a.remove(44)
 #打印a集合移除指定元素后，剩下的所有元素
 print(a)
 #最后输出
 #{88, 66, 44, 77, 55}
 #{88, 66, 77, 55}

 symmetric_difference(self, *args, **kwargs)

"对称差集,就是将两个集合里没有交集的元素重新组合成一个新的集合"（b集合）

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 a = {44,55,66,77,88}
 b = {44,55,11,22,33}
 #对称差集,就是将两个集合里没有交集的元素重新组合成一个新的集合
 c =  a.symmetric_difference(b)
 print(c)
 #输出
 #{33, 66, 11, 77, 22, 88}

symmetric_difference_update(self, *args, **kwargs)

"对称差集，并更新到a中,就是将两个集合里没有交集的元素重新组合更新给a集合"（b集合）

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 a = {44,55,66,77,88}
 b = {44,55,11,22,33}
 #对称差集，并更新到a中,就是将两个集合里没有交集的元素重新组合更新给a集合
 a.symmetric_difference_update(b)
 print(a)
 #输出
 #{33, 66, 11, 77, 22, 88}

union(self, *args, **kwargs)

"并集，将两个集合合并成一个新的集合，元素有重复的会自动忽略"（b集合）

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 a = {44,55,66,77,88}
 b = {44,55,11,22,33}
 #并集，将两个集合合并成一个新的集合，元素有重复的会自动忽略只保留一次
 c = a.union(b)
 print(c)
 #输出
 #{33, 66, 11, 44, 77, 22, 55, 88}

update(self, *args, **kwargs)

"更新,将b集合更新到a集合，相当于合并"（b集合）

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 a = {44,55,66,77,88}
 b = {44,55,11,22,33}
 #更新,将b集合更新到a集合，相当于合并
 a.update(b)
 print(a)
 #输出
 #{33, 66, 11, 44, 77, 22, 55, 88}