在
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}
type(a)
>> <class 'set'> #集合類型
a = {}
print(type(a))
>> <class 'dict'> #字典類型
集合中的内部元素有三個特性：
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 "<stdin>", line 1, in <module>
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
新的知識了。