15、集合

一、概要

set是一个无序且不重复的元素集合。

集合对象是一组无序排数据，集合成员可以做字典中的键。集合支持用in和not in操作符检查成员，由len()内建函数得到集合的基数(大小)， 用 for 循环迭代集合的成员。但是因为集合本身是无序的，不可以为集合创建索引或执行切片(slice)操作，也没有键(keys)可用来获取集合中元素的值。set和dict一样，只是没有value，相当于dict的key集合，由于dict的key是不重复的，且key是不可变对象因此可以作为可以做字典中的键

主要用来做关系测试和消除重复元素

二、特点

1. 不重复
2. 元素为不可变对象
3. 无序

三、创建

1. 语法格式一

   s = {元素,元素,元素,元素}
   

2. 语法格式二

   s = set(seq=())
   

3. 注意事项
   • 在创建空集合的时候只能使用s=set()，因为s={}创建的是空字典
   • 如果传入的参数有重复，会自动忽略
   • 必须是可以迭代的对象 例如: 序列,元组
4. 举个栗子

   s = {'k1', 'k2', 'k2', 1, 3.14}
   # 字符串对象转化成集合
   s = set('python')
   # 将列表转化成集合
   s = set(['y', 'b', 'o', 'o'])
   # 将字典转化成集合,注意只会包含键,不包含value
   s = set({"k1": 'v1', 'k2': 'v2'})
   # 将元组转化成集合
   s = {('k1', 'k2', 'k2')}
   

   #使用set()创建集合是注意
   # s = set(1)  # 错误
   # s = set(True) # 错误
   ```
   TypeError: 'int' object is not iterable
   ```
   

四、关系测试

4.1、说明

union（并集），intersection（交集），difference（差集）和sysmmetric difference（对称差集）等数学运算

4.2、并集（|）

1. 说明
   数学概念: 给定两个集合A，B，把他们所有的元素合并在一起组成的集合，叫做集合A与集合B的并集，记作A∪B，读作A并B。
   去重后所有元素放一起
2. 语法格式

   集合.union(集合)
   

   集合 | 集合 | 集合...
   

   ​
3. 举个栗子

   s1 = {1, 2, 3, 4, 5}
   s2 = {4, 5, 6, 7, 8}
   print(s1.union(s2))
   s1 = {'a', 'b', 'c', 'd', 'python', 1}
   s2 = {1, 2, 'd', 'java'}
   print(s1.union(s2))
   

4.3、交集（&）

1. 说明
   数学概念: 设A，B是两个集合，由所有属于集合A且属于集合B的元素所组成的集合，叫做集合A与集合B的交集
   两者都存在的
2. 语法格式

   集合.intersection(集合)
   

   集合 & 集合 & 集合 & 集合...
   

3. 举个栗子

   s1 = {1, 2, 3, 4, 5}
   s2 = {4, 5, 6, 7, 8}
   print(s1.intersection(s2))
   s1 = {'a', 'b', 'c', 'd', 'python', 1}
   s2 = {1, 2, 'd', 'java'}
   print(s1.intersection(s2))
   

4.4、差集（-）

1. 说明
   数学概念:以属于A而不属于B的元素为元素的集合成为A与B的差
   你有我没有
2. 语法格式

   集合.difference(集合)
   

   集合 - 集合  - 集合 ...
   

3. 举个栗子

   s1 = {1, 2, 3, 4, 5}
   s2 = {4, 5, 6, 7, 8}
   print(s1.difference(s2))
   # {1, 2, 3}
   s1 = {'a', 'b', 'c', 'd', 'python', 1}
   s2 = {1, 2, 'd', 'java'}
   print(s1.difference(s2))
   # {'b', 'python', 'c', 'a'}
   

4.5、对称差集（^）

1. 说明
   数学概念：两个集合的对称差是只属于其中一个集合，而不属于另一个集合的元素组成的集合
   集合1和集合2都互相都没有（去重后放到一起）
2. 语法格式

   集合.symmetric_difference(集合)
   

   集合 ^ 集合
   

3. 举个栗子

   s1 = {1, 2, 3, 4, 5}
   s2 = {4, 5, 6, 7, 8}
   print(s1.symmetric_difference(s2))
   s1 = {'a', 'b', 'c', 'd', 'python', 1}
   s2 = {1, 2, 'd', 'java'}
   print(s1.symmetric_difference(s2))
   

4.6、子集（issubset）

1. 说明
   数学概念：如果集合A的任意一个元素都是集合B的元素，那么集合A称为集合B的子集。
   集合1是不是集合2的子集
2. 语法格式

   集合1.issubset(集合2)
   

3. 举个栗子

   s1 = {1, 2, 3, 4, 5, 6, 7, 8}
   s2 = {4, 5, 6, 7, 8}
   print(s2.issubset(s1))
   # True
   s1 = {1, 2, 3, 4, 5, 6, 7, 8}
   s2 = {4, 5, 6, 7, 8,9}
   print(s2.issubset(s1))
   # False
   

4.7、父集（issuperset）

1. 说明
   集合1是不是集合2的父集
2. 语法格式

   集合1.issuperset(集合2)
   

3. 举个栗子

   s1 = {1, 2, 3, 4, 5, 6, 7, 8}
   s2 = {4, 5, 6, 7, 8}
   print(s1.issubset(s2))
   

4.8、是否存在交集

1. 说明
   是否存在交集
2. 语法格式

   集合1.isdisjoint(集合2)
   

3. 举个栗子

   s1 = {1, 2, 3, 4, 5}
   s2 = {4, 5, 6, 7, 8}
   print(s1.isdisjoint(s2))
   # False
   s1 = {'a', 'b', 'c', 'python'}
   s2 = {1, 2, 'd', 'java'}
   print(s1.isdisjoint(s2))
   # True
   

五、其它方法

5.1、add

1. 说明
   往set中添加一个元素只有set中不存在该元素时，才会加入该元素
2. 语法格式

   set.add(元素)
   

3. 参数说明
   • 要添加的元素,必须是不可变的
4. 返回值
   无
5. 举个栗子

   s = {(1, 2, 3), '元素1', 1, True}
   s.add(2)
   # {'元素1', 2, 1, (1, 2, 3)}
   s = {(1, 2, 3), '元素1', 1, True}
   s.add(1)
   # {'元素1', 1, (1, 2, 3)}
   #注意元素是不可变的所以list不能作为元素
   s.add([1, 2])
   ```
   TypeError: unhashable type: 'list'
   ```
   

5.2、update

1. 说明
   把新的元素添加到set中，把已有元素从set中删除。
2. 语法格式

   set.update(s)
   

3. 参数说明
   • 必须是可迭代的对象
     注意:传入的元素拆分，做为单个元素传入到集合中
4. 返回
   无
5. 举个栗子

   s = set()
   # 将字符串中的每一个元素添加到集合中
   s.update('python')
   print(s)
   #讲列表中的每一个元素更新到集合中
   s.update([1, 2, 3, 4, 5])
   print(s)
   #把字典里的key更新到集合中
   s.update({1: 2, 'name': '小明'})
   print(s)
   #错误
   s.update(1)
   s.update(True)
   

5.3、pop

1. 说明
   随机删除并返回set类型的集合中的一个不确定的元素，如果为空引发KeyError错误。
2. 语法格式

   element = s.pop() 
   

3. 参数说明：
   • 无
4. 返回值
   被删除的元素
5. 举个栗子

   s = set([2, 3, 4, 5])
   ele = s.pop()
   

5.4、remove

1. 说明
   删除指定元素
2. 语法格式

   set.remove(ele)
   

3. 参数说明
   • 要删除的元素
4. 举个栗子

   s = {1, 'python', (1, 2, 3)}
   print(s)
   s.remove(1)
   print(s)
   

5.5、discard

1. 说明
   如果存在则删除；如果没找到，则什么也不做
2. 语法格式

   discard(element)
   

3. 参数说明
   • 表示要查找并删除的元素
4. 返回值
   无
5. 举个栗子

   set_list = set([1, 2, 3, 4, 5])
   set_list.discard(1)
   set_list.discard('python')
   print(set_list)
   

5.6、clear

1. 说明
   清空s集合中的所有元素
2. 语法格式

   set.clear()
   

3. 参数说明
   • 无
4. 返回值
   无
5. 举个栗子

   s = set([1, 2, 3, 4, 5])
   s.clear()
   

5.7、copy

1. 说明
   复制集合
2. 语法格式

   set.copy()
   

3. 参数说明
   • 无
4. 返回值
   一个新的集合
5. 举个栗子

   s = set('123456')
   new_s = s.copy()
   

5.8、集合的范围判断

1. 说明
   集合可以使用大于（>）、小于（<）、大于等于（>=）、小于等于（<=）、等于（==）、不等于（!=）来判断某个集合是否完全包含于另一个集合，也可以使用子父集判断函数。 也可以使用成员运算
2. 举个栗子

   s1 = set([1, 2, 3, 4, 5])
   s2 = set([1, 2, 3, 4])
   s3 = set(['1', '8', '9', '5'])
   s1 > s2
   True
   s1 > s3
   False
   s1 >= s2
   True
   s2 < s1
   True
   s1 < s3
   False
   s3 < s1
   False
   s1 == s2
   False
   s2 == s3
   False
   s1 != s2
   True
   1 in s1
   True
   6 in s1
   False
   2 not in s1
   False
   6 not in s1
   True
   

六、集合推导

1. 说明
   它们跟列表推导式也是类似的。 唯一的区别在于它使用大括号{}。
2. 语法格式

   {表达式 for item in iterrator if 条件表达式}  
   

3. 举个栗子

   # 重复的数据将会被忽略
   num = {x**2 for x in [100, 100, 30,50,60,50]}
   print(num)