在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新的知識了，你準備好了嗎？