在python中，集合是一个无序的，不重复的数据组合，他的主要工作如下：

1、去重，把一个列表变成集合，就自动去重了

2、关系测试，测试两组数据之间的交集、差集、并集等关系

我来举个例子，前两个月出了iPhoneXS，去年出了iPhoneX，我现在想知道有多少人不仅去年买了iPhoneX今年也买了iPhoneXS，如下两个数组：

iPhoneX = ['张三','李四','王五','赵六']

iPhoneXS = ['刘一','李四','周八','郑十','张三']

我要得出两部手机都买了的人按照之前学过的来做的话，肯定要两部循环，如：

iPhoneX = ['张三','李四','王五','赵六']

iPhoneXS = ['刘一','李四','周八','郑十','张三']

user = list()

for i in iPhoneX:

if i in iPhoneXS:

user.append(i)

print(user)

输出结果为：['张三', '李四']

如果再更改需求，我需要把买过 iPhoneXS 和 iPhoneX 的人合并在一起，并且去除重复购买的人该怎么做呢，如果按照之前学过的几种基本类型来做的话，我首先要再建立一个 数组，并且把买过 iPhoneX 和 iPhoneXS 的人拼接到一个数组中，然后根据已经得到的 user 循环判断，删除和 user 重复的所有数据，然后再把 user 拼接进去就得到了我想要的数据，思路是这样没错，可是 python 还是嫌它太麻烦了，所以就有了一个 集合类型，来看看集合是怎么操作的：

首先语法和 字典 一样都是{}号包裹着的，和字典不同的是，在字典里面是有key和value值的，而集合是没有key的，他直接就是value值，如：

a = {1,2,3,4,5,6}

注意，如果集合内部没有一个值，他默认是字典类型，我来做个测试判断，如：

a = {1,2,3,4,5,6}

type(a)

>> #集合类型

a = {}

print(type(a))

>> #字典类型

集合中的内部元素有三个特性：

1、确定性(元素必须可 hash)

2、互异性(去重复)

3、无序性(集合中的元素没有先后之分)

先看看它去重复的功能，还是用最上方的例子来解释

iPhoneX = ['张三','李四','王五','赵六']

iPhoneXS = ['刘一','李四','周八','郑十','张三']

arr = iPhoneX+iPhoneXS

print(set(arr))

>> {'赵六', '王五', '郑十', '李四', '周八', '刘一', '张三'}

可以看到我直接用他的类型set()方法，就直接将一个数组去重并且转成集合类型，同样的我用数组的方法list再把它转成数组就直接ok了：

iPhoneX = ['张三','李四','王五','赵六']

iPhoneXS = ['刘一','李四','周八','郑十','张三']

arr = iPhoneX+iPhoneXS

print(list(set(arr)))

>> ['刘一', '赵六', '李四', '周八', '王五', '郑十', '张三']

这就是集合的强大之处，一个简单的操作完成了很多复杂的逻辑化处理，关于集合的基本操作方法确实还有很多，下面我来一一演示

add(需要增加的内容): 增加 (注意：这里只能添加一个值，如果添加多个值会报错)

update(): 增加(增加多个值，如果重复了会被自动剔除，注意：这里的添加必须写如一个数组)

pop(): 随机删除(注意：这里的可能在数据不多的情况下可能是删除第一个或者最后一个，但是只要数据量足够大，它一定是随机删除的)

remove(参数): 指定删除(通过传递参数指定删除某一个元素，注意：如果指定的元素不存在，则会报错)

discard(参数): 指定删除(通过传递参数指定删除某一个元素，和remove()方法相反的是如果不存在，并不会报错)

clear(): 清空整个集合

add():

a = {1,2,3,4,5}

a.add(6)

print(a)

>> {1,2,3,4,5,6}

a.add(2)

print(a)

>> {1,2,3,4,5,6} #已经存在的值是增加不进去的，集合的特性就是不重复

update():

a = {1,2,3,4,5}

a.update([4,5,6,7,8,9,0]) # 在 update 方法里面添加集合必须以数组的方式加进去

print(a)

>> {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

pop():

a = {1,2,3,4,5,6,7,8,9,0}

a.pop()

print(a)

>> set({1, 2, 3, 4, 5, 6, 7, 8, 9})

remove():

a = {1,2,3,4,5,6,7,8,9,0}

a.remove(5)

print(a)

>> set({1, 2, 3, 4, 6, 7, 8, 9, 0}) #删除完成后变量 a 已经没有 5 这个变量值了

a.remove(5) #删除没有的元素在控制台会报以下错误

>> Traceback (most recent call last):

File "", line 1, in

KeyError: 5

discard():

a = {1,2,3,4,5,6,7,8,9,0}

a.discard(5)

print(a)

>> set({1, 2, 3, 4, 6, 7, 8, 9, 0}) #删除完成后变量 a 已经没有 5 这个变量值了

a.discard(5) #控制台并不会报错

>>

clear():

a = {1,2,3,4,5,6,7,8,9,0}

a.clear()

print(a)

>> set() # 空集合

好了基本的集合类方法已经讲解完毕了，其实上面说了这么多都是关于集合去重复的一些常规的增删改查，其实集合还有一个关键的重点，那就是关系测试。

关系测试

关系测试分为交集、差集、并集这么几种，可能很多朋友对这几个关键词比较迷惑，其实啊，在我看到交集、差集、并集这三种名称的时候同样的迷惑，先来了解以下这三种分别代表什么意思，在来说说集合能怎么处理这几种关系测试。

交集：

如上方例子，再看下方示意图，就是又买了iPhoneX也买了iPhoneXS的人，这样类型的数据就是交集。

intersection(): 查找交集数据或这直接简写成&

intersection()

iPhoneX = ['张三','李四','王五','赵六']

iPhoneXS = ['刘一','李四','周八','郑十','张三']

a = set(iPhoneX).intersection(set(iPhoneXS))

print(a)

>> {'张三', '李四'}

intersection()简写&

iPhoneX = {'张三','李四','王五','赵六'}

iPhoneXS = {'刘一','李四','周八','郑十','张三'}

print(iPhoneX & iPhoneXS)

>> {'张三', '李四'}

差集：

我们已经知道了怎么获取交集，什么又是差集呢，差集就是非交集的都算是差集，看到下图，我现在能获取到iPhoneX和iPhoneXS都买了的人但是我现在要获取只买了iPhoneX和iPhoneXS的人，那么这种只买了iPhoneX和iPhoneXS的人就是差集，如下图：

difference(): 查找差集数据或这直接简写成-

difference()

iPhoneX = {'张三','李四','王五','赵六'}

iPhoneXS = {'刘一','李四','周八','郑十','张三'}

#查找只购买了 iPhoneX 的人

a = iPhoneX.difference(iPhoneXS)

print(a)

>> {'赵六', '王五'}

difference()简写–

iPhoneX = {'张三','李四','王五','赵六'}

iPhoneXS = {'刘一','李四','周八','郑十','张三'}

#查找只购买了 iPhoneX 的人

a = iPhoneX - iPhoneXS

print(a)

>> {'王五', '赵六'}

并集：

并集其实很好理解，就是两个集合全部相加在一起，然后去除重复的内容就叫并集

union(): 将两个集合转换成一个集合，并且去除重复的内容可以简写成|

union()

iPhoneX = {'张三','李四','王五','赵六'}

iPhoneXS = {'刘一','李四','周八','郑十','张三'}

a = iPhoneX.union(iPhoneXS)

print(a)

>> {'张三', '赵六', '郑十', '周八', '刘一', '王五', '李四'}

union()简写成|

iPhoneX = {'张三','李四','王五','赵六'}

iPhoneXS = {'刘一','李四','周八','郑十','张三'}

a = iPhoneX | iPhoneXS

print(a)

>> {'张三', '赵六', '郑十', '周八', '刘一', '王五', '李四'}

好了集合类型一共就是上方三种，可以算基本上完了，但是差集还有一个小知识点，那就是对称差集

对称差集

对称差集又是什么呢？用上方的例子来说就是只取买了 iPhoneX 和 iPhoneXS 如果都买了就会被过滤掉，如果用上方的讲过的几个知识点来做的话，可能需要这样做：

iPhoneX = {'张三','李四','王五','赵六'}

iPhoneXS = {'刘一','李四','周八','郑十','张三'}

a = iPhoneX - iPhoneXS #iPhoneX 的差集

b = list(iPhoneXS - iPhoneX) #iPhoneXS 的差集并且转成数组

a.update(b) 将数组 b 添加进集合 a 里

print(a)

>> {'王五', '郑十', '周八', '刘一', '赵六'}

可以看到根据上方所学可以这样就求出了只买了iPhoneX和iPhoneXS的人，直接过滤了两者都买了的人。

其实上方代码已经很简洁了，可是python还是嫌弃他比较繁琐，所以又提供了一个内置的方法：symmetric_difference()

symmetric_difference(): 求出对称差集，可以简写成^

symmetric_difference()

iPhoneX = {'张三','李四','王五','赵六'}

iPhoneXS = {'刘一','李四','周八','郑十','张三'}

a = iPhoneX.symmetric_difference(iPhoneXS)

print(a)

>> {'周八', '郑十', '王五', '赵六', '刘一'}

symmetric_difference() 简写方案^

iPhoneX = {'张三','李四','王五','赵六'}

iPhoneXS = {'刘一','李四','周八','郑十','张三'}

a = iPhoneX ^ iPhoneXS

print(a)

>> {'郑十', '赵六', '王五', '刘一', '周八'}

可以看到，对称差集就求出来了，接下来继续往下看看集合的对应关系。

集合的对应关系

什么是集合的对应关系呢？举个最简单的例子：

一个城市的多级联动，省级以下是市级的单位，市级以上是省级，那么在python里面省级就是市级的超集，市级就是省级的子集

这个时候我有一份省级的人物名单和好几份市级的人名单，如：

Province = {'a','b','c','d','e','f','g'} #省级

city1 = {'w','e'} #城市一

city2 = {'f','e'} #城市二

city3 = {'j','k'} #城市三

city4 = {'z','k'} #城市四

city5 = {'a','h'} #城市五

我需要判断这些市级有那些是属于这个省级的子集那么该怎么做呢？python也为我们提供了可以判断层级关系的内置方法：

issubset(): 判断一个集合内的所有元素是否被包含在另一个集合内 (简写方式为<=)

issuperset(): 判断一个集合内的元素是否包含了另一个集合的所有元素(和上方相反简写方式为>=)

根据这个城市的小例子，上方数据不是很多，一眼就可以看到只有城市二的所有元素，是省级单位都包括了的，所以其他的城市我就不测试了，直接用城市二来测试，如：

Province = {'a','b','c','d','e','f','g'} #省级单位

city2 = {'f','e'} #城市二

a = Province.issuperset(city2) #判断省份里面是否包含了 市级

b = city2.issubset(Province) #判断市级是否被包含在省级内

print(a)

print(b)

>> True

>> True

简写方式：

Province = {'a','b','c','d','e','f','g'} #省级单位

city2 = {'f','e'} #城市二

a = Province >= city2 #判断省份里面是否包含了 市级

b = city2 <= Province #判断市级是否被包含在省级内

print(a)

print(b)

>> True

>> True

python还为我们提供了一个方法用来判断两个集合是不是不相交的。

isdisjoint(): 用来判断两个集合是不是不相交的，如果相交，返回 False, 如果不相交，返回True

isdisjoint()

city2 = {'f','e'}

a = city2.isdisjoint(city2) #city2和它自身是相交的，所以返回的是 false ，只有不相交才会返回 true

print(a)

>> False

好了，还有最后两个内置方法：

difference_update() : 差集赋值

intersection_update() : 交集赋值

difference_update()

a = {1,2,3,4,5,6,7,8,9,0}

b = {1,2,3,4,5,6,7}

a.difference_update(b) #将取到的差集赋值给 a 改变了 a 原有的值

print(a)

>> {0, 8, 9}

intersection_update()

a = {1,2,3,4,5,6,7,8,9,0}

b = {1,2,3,4,5,6,7}

a.intersection_update(b) #将取到的交集赋值给 a 改变了 a 原有的值

print(a)

好了关于集合类型基本上全部完了，加上前面的几个章节基本上关于python的所有基本类型就彻底学完了要学习关于python新的知识了，你准备好了吗？