基础数据类型：
- int，整数类型（整形）
- float，浮点类型（浮点型）
- complex,复数类型
- bool，布尔类型
- str，字符串类型
高级数据类型
- list，列表类型
- tuple，元组类型
- set，集合类型
- dict，字典类型
学习目标：掌握集合相关知识。
在学习了列表和元组之后，我们再来学习一种容器型的数据类型，它的名字叫集合（set）。说到集合这个词大家一定不会陌生，在数学课本上就有这个概念。通常我们对集合的定义是“把一定范围的、确定的、可以区别的事物当作一个整体来看待”，集合中的各个事物通常称为集合的元素。集合应该满足以下特性：
- 无序性：一个集合中，每个元素的地位都是相同的，元素之间是无序的。
- 互异性：一个集合中，任何两个元素都认为是不相同的，即每个元素只能出现一次。
- 确定性：给定一个集合，任给一个元素，该元素或者属于或者不属于该集合，二者必居其一，不允许有模棱两可的情况出现。
Python程序中的集合跟数学上的集合是完全一致的，需要强调的是上面所说的无序性和互异性。无序性说明集合中的元素并不像列中的元素那样一个挨着一个，可以通过索引的方式实现随机访问（随机访问指的是给定一个有效的范围，随机抽取出一个数字，然后通过这个数字获取到对应的元素），所以Python中的集合肯定不能够支持索引运算。另外，集合的互异性决定了集合中不能有重复元素，这一点也是集合区别于列表的关键，说得更直白一些就是，Python中的集合类型具有去重特性。当然，Python中的集合一定是支持in和not in成员运算的，这样就可以确定一个元素是否属于集合，也就是上面所说的集合的确定性。集合的成员运算在性能上要优于列表的成员运算，这是集合的底层存储特性决定的，此处我们暂时不做讨论，先记下这个结论即可。
集合的定义
通过对比列表和元组，我们来看一下集合的定义：
列表（list），是一个有序且可变的容器，在里面可以存放多个不同类型、数据元素可重复的元素。
元组（tuple），是一个有序且不可变的容器，在里面可以存放多个不同类型、数据元素可重复的元素。
集合（set），是一个 无序 且可变的容器，在里面可以存放多个不同类型、数据元素不可重复的元素。
集合的特点：
- 以
{}包裹，,为分隔符 - 内部元素无序：无法通过索引取值
- 内部元素可变：可以添加和删除元素
- 内部元素类型可不同
- 内部元素不可重复：经常应用在有去重需求的场景
- 以
一般什么时候用集合呢？
就是想要维护一大堆不重复的数据时，就可以用它。比如：做爬虫去网上找图片的链接，为了避免链接重复，可以选择用集合去存储链接地址。
集合的创建
在Python中，创建集合可以使用{}字面量语法，{}中需要至少有一个元素，因为没有元素的{}并不是空集合而是一个空字典，我们下一节就会大家介绍字典的知识。当然，也可以使用内置函数set来创建一个集合，准确的说set并不是一个函数，而是创建集合对象的构造器，这个知识点我们很快也会讲到，现在不理解跳过它就可以了。要创建空集合可以使用set()；也可以将其他序列转换成集合，例如：set('hello')会得到一个包含了4个字符的集合（重复的l会被去掉）。除了这两种方式，我们还可以使用生成式语法来创建集合，就像我们之前用生成式创建列表那样。要知道集合中有多少个元素，还是使用内置函数len；使用for循环可以实现对集合元素的遍历。
# 创建集合的字面量语法(重复元素不会出现在集合中)
set1 = {1, 2, 3, 3, 3, 2}
print(set1) # {1, 2, 3}
print(len(set1)) # 3
# 创建集合的构造器语法(后面会讲到什么是构造器)
set2 = set('hello')
print(set2) # {'h', 'l', 'o', 'e'}
# 将列表转换成集合(可以去掉列表中的重复元素)
set3 = set([1, 2, 3, 3, 2, 1])
print(set3) # {1, 2, 3}
# 创建集合的生成式语法(将列表生成式的[]换成{})
set4 = {num for num in range(1, 20) if num % 3 == 0 or num % 5 == 0}
print(set4) # {3, 5, 6, 9, 10, 12, 15, 18}
# 集合元素的循环遍历
for elem in set4:
print(elem)注意：定义空集合时，只能使用v = set()，不能使用 v={}（这样是定义一个空字典）。
v1 = []
v11 = list()
v2 = ()
v22 = tuple()
v3 = set()
v4 = {} # 空字典
v44 = dict()需要提醒大家，集合中的元素必须是hashable类型。所谓hashable类型指的是能够计算出哈希码的数据类型，你可以暂时将哈希码理解为和变量对应的唯一的ID值。通常不可变类型都是hashable类型，如整数、浮点、字符串、元组等，而可变类型都不是hashable类型，因为可变类型无法确定唯一的ID值，所以也就不能放到集合中。集合本身也是可变类型，所以集合不能够作为集合中的元素，这一点请大家一定要注意。
集合的方法
集合常用的方法如下：
- 添加
- add(value)，在集合中添加一个元素
- 删除
- pop()，删除并返回任意集合元素，若集合为空，则引发KeyError
- discard(value)，在集合中删除指定元素，若不存在不报错
- remove(value)，在集合中删除指定元素，若不存在报错
- del set，删除集合
- 清空
- clear()，清空集合
- 求交集
- intersection(set2)，返回两个集合的交集，自身集合不发生改变
- intersection_update(set2)，在自身集合的基础上求两个集合的交集，改变自身集合
- 求并集
- update(set2)，使用自身和其他集合的并集来更新集合，改变自身集合
- union(set2)，并集，返回两个集合的并集，不改变自身
- 求差集
- difference(set2)，返回两个集合的差集，自身集合不发生改变
- difference_update(set2)，在自身集合的基础上求两个集合的差集，改变自身集合
- symmetric_difference(set2)，对称差集
- 求超集和子集
- issuperset(set2)，求超集
- issubset(set2)，求子集
使用示例
# 1，列表去重。
l1 = [1, 2, 1, 2, 3, 4, 5, 6, 6,]
set1 = set(l1)
l2 = list(set1)
print(l2) # [1, 2, 3, 4, 5, 6]
# 2，集合的增删查。
set1 = set()
# 添加
set1.add("周杰伦")
set1.add("林俊杰")
print(set1) # {'周杰伦', '林俊杰'}
set2 = {"刘嘉玲", '关之琳', "王祖贤", "张曼⽟", "李若彤"}
set1.update(set2)
print(set1) # {'王祖贤', '刘嘉玲', '张曼⽟', '周杰伦', '林俊杰', '关之琳', '李若彤'}
print(set1.union(set2)) # # {'王祖贤', '刘嘉玲', '张曼⽟', '周杰伦', '林俊杰', '关之琳', '李若彤'}
# 删除
print(set1.pop()) # 关之琳 随机删除 返回指定元素
print(set1) # {'周杰伦', '张曼⽟', '李若彤', '王祖贤', '林俊杰', '刘嘉玲'}
set1.remove('刘嘉玲') # 删除指定元素 若不存在 会引发KeyError异常 {'周杰伦', '张曼⽟', '李若彤', '王祖贤', '林俊杰'}
print(set1)
set1.discard('李若彤') # 删除指定元素 若不存在不报错
print(set1) # {'周杰伦', '张曼⽟', '王祖贤', '林俊杰'}
# 清空
# set1.clear()
# print(set1) # set()
# del set1
# print(set1) # NameError: name 'set1' is not defined
# 查询: for循环
for val in set1:
print(val)
# 3，集合的关系测试。
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
# 交集：& intersection
print(set1 & set2) # {4, 5}
print(set1.intersection(set2)) # {4, 5}
# 并集：| union
print(set1 | set2) # {1, 2, 3, 4, 5, 6, 7, 8}
print(set1.union(set2)) # {1, 2, 3, 4, 5, 6, 7, 8}
# 差集：- difference
print(set1 - set2) # {1, 2, 3}
print(set1.difference(set2)) # {1, 2, 3}
# 对称差集: ^ symmetric_difference
print(set1 ^ set2) # {1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2)) # {1, 2, 3, 6, 7, 8}
set1 = {1, 2, 3, 4, 5}
set2 = {1, 2, 3}
# 超集：>
print(set1 > set2) # True
print(set1.issuperset(set2)) # True
# 子集：< issubset
print(set2 < set1) # True
print(set2.issubset(set1)) # True如果要判断两个集合有没有相同的元素可以使用isdisjoint方法，没有相同元素返回True，否则返回False，代码如下所示。
set1 = {'Java', 'Python', 'Go', 'Kotlin'}
set2 = {'Kotlin', 'Swift', 'Java', 'Objective-C', 'Dart'}
set3 = {'HTML', 'CSS', 'JavaScript'}
print(set1.isdisjoint(set2)) # False
print(set1.isdisjoint(set3)) # True集合的运算
Python为集合类型提供了非常丰富的运算符，主要包括：成员运算、交集运算、并集运算、差集运算、比较运算（相等性、子集、超集）等。常见运算总结如下：
- 成员运算
int/not in：检查元素是否在集合中
- 交并差运算
&：求两个集合的交集，即公共的元素|：求两个集合的并集，即两个集合中去重之后所有的元素-：求两个集合中的差集，及第一个集合中有第二个集合中没有的元素^：求两个集合中的对称差，即两个集合的并集减去两个集合的差集
- 比较运算
==：判断两个集合中元素是否相等!=：判断两个集合中元素是否不等<：判断第一个集合是否是第二个集合的真子集<=：断第一个集合是否是第二个集合的子集>：判断第一个集合是否是第二个集合的超集
成员运算
可以通过成员运算in和not in 检查元素是否在集合中，代码如下所示。
set1 = {11, 12, 13, 14, 15}
print(10 in set1) # False
print(15 in set1) # True
set2 = {'Python', 'Java', 'Go', 'Swift'}
print('Ruby' in set2) # False
print('Java' in set2) # True交并差运算
Python中的集合跟数学上的集合一样，可以进行交集、并集、差集等运算，而且可以通过运算符和方法调用两种方式来进行操作，代码如下所示。
set1 = {1, 2, 3, 4, 5, 6, 7}
set2 = {2, 4, 6, 8, 10}
# 交集
# 方法一: 使用 & 运算符
print(set1 & set2) # {2, 4, 6}
# 方法二: 使用intersection方法
print(set1.intersection(set2)) # {2, 4, 6}
# 并集
# 方法一: 使用 | 运算符
print(set1 | set2) # {1, 2, 3, 4, 5, 6, 7, 8, 10}
# 方法二: 使用union方法
print(set1.union(set2)) # {1, 2, 3, 4, 5, 6, 7, 8, 10}
# 差集
# 方法一: 使用 - 运算符
print(set1 - set2) # {1, 3, 5, 7}
# 方法二: 使用difference方法
print(set1.difference(set2)) # {1, 3, 5, 7}
# 对称差
# 方法一: 使用 ^ 运算符
print(set1 ^ set2) # {1, 3, 5, 7, 8, 10}
# 方法二: 使用symmetric_difference方法
print(set1.symmetric_difference(set2)) # {1, 3, 5, 7, 8, 10}
# 方法三: 对称差相当于两个集合的并集减去交集
print((set1 | set2) - (set1 & set2)) # {1, 3, 5, 7, 8, 10}通过上面的代码可以看出，对两个集合求交集，&运算符和intersection方法的作用是完全相同的，使用运算符的方式更直观而且代码也比较简短。相信大家对交集、并集、差集、对称差这几个概念是比较清楚的，如果没什么印象了可以看看下面的图。
集合的交集、并集、差集运算还可以跟赋值运算一起构成复合运算，如下所示。
set1 = {1, 3, 5, 7}
set2 = {2, 4, 6}
# 将set1和set2求并集再赋值给set1
# 也可以通过set1.update(set2)来实现
set1 |= set2
print(set1) # {1, 2, 3, 4, 5, 6, 7}
set3 = {3, 6, 9}
# 将set1和set3求交集再赋值给set1
# 也可以通过set1.intersection_update(set3)来实现
set1 &= set3
print(set1) # {3, 6}比较运算
两个集合可以用==和!=进行相等性判断，如果两个集合中的元素完全相同，那么==比较的结果就是True，否则就是False。如果集合A的任意一个元素都是集合B的元素，那么集合A称为集合B的子集，即对于∀a∈A，均有a∈B，则A⊆B。A是B的子集，反过来也可以称B是A的超集。如果A是B的子集且A不等于B，那么A就是B的真子集。Python为集合类型提供了判断子集和超集的运算符，其实就是我们非常熟悉的<和>运算符，代码如下所示。
set1 = {1, 3, 5}
set2 = {1, 2, 3, 4, 5}
set3 = set2
# <运算符表示真子集，<=运算符表示子集
print(set1 < set2, set1 <= set2) # True True
print(set2 < set3, set2 <= set3) # False True
# 通过issubset方法也能进行子集判断
print(set1.issubset(set2)) # True
# 反过来可以用issuperset或>运算符进行超集判断
print(set2.issuperset(set1)) # True
print(set2 > set1) # True不可变集合
Python中还有一种不可变类型的集合，名字叫frozenset。set跟frozenset的区别就如同list跟tuple的区别，frozenset由于是不可变类型，能够计算出哈希码，因此它可以作为set中的元素。除了不能添加和删除元素，frozenset在其他方面跟set基本是一样的，下面的代码简单的展示了frozenset的用法。
set1 = frozenset({1, 3, 5, 7})
set2 = frozenset(range(1, 6))
print(set1 & set2) # frozenset({1, 3, 5})
print(set1 | set2) # frozenset({1, 2, 3, 4, 5, 7})
print(set1 - set2) # frozenset({7})
print(set1 < set2) # False集合类型转换
其他类型如果想要转换为集合类型，可以通过set进行转换，并且如果数据有重复自动剔除。
提示：int/list/tuple/dict都可以转换为集合。
v1 = "张亚飞"
v2 = set(v1)
print(v2) # {"张","亚","飞"}v1 = [11,22,33,11,3,99,22]
v2 = set(v1)
print(v2) # {11,22,33,3,99}v1 = (11,22,3,11)
v2 = set(v1)
print(v2) # {11,22,3}提示：这其实也是去重的一个手段。
data = {11,22,33,3,99}
v1 = list(data) # [11,22,33,3,99]
v2 = tuple(data) # (11,22,33,3,99)集合生成式
s = {v for v in iterable} 其中iterable是一个可迭代的对象，比如list。示例1：求余数
# for in 循环实现
l1 = [3,5,7,8,9,10,20]
s = set()
for i in li:
s.add(l1 % 3)
print(s) # {0, 1, 2}
# 集合生成式
s = { i % 3 for i in range(1,7)}
print(s) # {0, 1， 2}示例2：嵌套if
# for in 循环实现
l1 = [3,5,7,8,9,10,20]
s = set()
for i in li:
if i < 15:
s.add(l1 % 3)
print(s) # {0, 1， 2}
# 集合生成式
s = { i % 3 for i in l1 if i < 15}
print(s) # {0, 1， 2}示例3：嵌套循环
# for in 循环
S = set()
for i in range(1,4):
for j in range(1,4):
S.add(( i * j))
print(S) # {1, 2, 3, 4, 6, 9}
# 集合生成式
S = { i*j for i in range(1,4) for j in range(1,4)}
print(s) # {1, 2, 3, 4, 6, 9}集合的存储原理
元素必须可哈希
因存储原理，集合的元素必须是可哈希的值，即：内部通过通过哈希函数把值转换成一个数字。
目前可哈希的数据类型：int、bool、str、tuple，而list、set是不可哈希的。
总结：集合的元素只能是 int、bool、str、tuple 。
转换成功
v1 = [11,22,33,11,3,99,22] v2 = set(v1) print(v2) # {11,22,33,3,99}转换失败
v1 = [11,22,["Michael","eric"],33] v2 = set(v1) # 报错 print(v2)
查找速度特别快
因存储原理特殊，集合的查找效率非常高（数据量大了才明显）。
低
# 列表存储 user_list = ["张亚飞","Michael","刘翔"] if "Michael" in user_list: print("在") else: print("不在") # 元组存储 user_tuple = ("张亚飞","Michael","刘翔") if "Michael" in user_tuple: print("在") else: print("不在")效率高
user_set = {"张亚飞","Michael","刘翔"} if "Michael" in user_set: print("在") else: print("不在")
对比和嵌套
| 类型 | 是否可变 | 是否有序 | 元素要求 | 是否可哈希 | 转换 | 定义空 |
|---|---|---|---|---|---|---|
| list | 是 | 是 | 无 | 否 | list(其他) | v=[]或v=list() |
| tuple | 否 | 是 | 无 | 是 | tuple(其他) | v=()或v=tuple() |
| set | 是 | 否 | 可哈希 | 否 | set(其他) | v=set() |
data_list = [
"Michael",
11,
(11, 22, 33, {"Michael", "eric"}, 22),
[11, 22, 33, 22],
{11, 22, (True, ["中国", "北京"], "沙河"), 33}
]注意：由于True和False本质上存储的是 1 和 0 ，而集合又不允许重复，所以在整数 0、1和False、True出现在集合中会有如下现象：
v1 = {True, 1}
print(v1) # {True}
v2 = {1, True}
print(v2) # {1}
v3 = {0, False}
print(v3) # {0}
v4 = {False, 0}
print(v4) # {False}简单的总结
Python中的集合底层使用了哈希存储的方式，使得其具有查找速度快的优势，且其数据元素不可重复，经常应用在需要大量查找和去重的场景下。现阶段大家只需要知道以下几个知识点：
- 集合，是 无序、不重复、元素必须可哈希、可变的一个容器（子孙元素都必须是可哈希）。
- 集合的查找速度比较快（底层是基于哈希进行存储）
- 集合可以具有 交并差 的功能。
- 不支持索引运算
集合与列表不同的地方在于集合中的元素没有序、不能用索引运算、不能重复。
