使用 Python 的集合類型進行集合操作（​​例如，確定聯合集、乘積集和子集）

商業

Python 提供了一種內置的數據類型 set 來處理集合。

類型集是不重複元素（值不相同的元素，唯一元素）的集合，可以進行並集、積集、差集等集合操作。

本節以示例代碼說明集合類型集合操作中的基本操作。

  • 創建集合對象:{},set()
  • 設置包含符號
  • 集合中的元素數:len()
  • 將元素添加到集合:add()
  • 從集合中移除一個元素:discard(),remove(),pop(),clear()
  • 瓦塞特（合併、聯合）:|運算符,union()
  • 產品集（通用部分、交叉點、交叉點）:&操作員,intersection()
  • 相對互補:-操作員,difference()
  • 對稱差集:^ 運算符,symmetric_difference()
  • 子集與否:<= 運算符,issubset()
  • 上套與否:>= 運算符,issuperset()
  • 確定它們是否互質:isdisjoint()

set 類型是可以添加和刪除元素的可變類型，還有一種 freezeset 類型，它具有與 set 類型相同的 set 操作和其他方法但不可變（不能通過添加、刪除或其他方式修改元素來修改） )。

創建集合對象：:{},set()

由波括號 {} 生成

set 類型的對象可以通過將元素括在大括號 {} 中來創建。

如果有重複值，它們將被忽略，並且只有唯一值保留為元素。

s = {1, 2, 2, 3, 1, 4}

print(s)
print(type(s))
# {1, 2, 3, 4}
# <class 'set'>

可以有不同的類型作為元素。但是，無法註冊列表類型等可更新對象。允許使用元組。

此外，由於集合類型是無序的，因此不會存儲它們的生成順序。

s = {1.23, 'abc', (0, 1, 2), 'abc'}

print(s)
# {(0, 1, 2), 1.23, 'abc'}

# s = {[0, 1, 2]}
# TypeError: unhashable type: 'list'

不同的類型，例如 int 和 float，如果它們的值相等，則被認為是重複的。

s = {100, 100.0}

print(s)
# {100}

由於空括號 {} 被認為是字典類型，因此可以使用下面描述的構造函數創建空集類型對象（空集）。

s = {}

print(s)
print(type(s))
# {}
# <class 'dict'>

由構造函數 set() 生成

set 類型的對像也可以使用構造函數 set() 創建。

將可迭代對象（如列表或元組）指定為參數會生成一個集合對象，其元素僅為唯一值，不包括重複元素。

l = [1, 2, 2, 3, 1, 4]

print(l)
print(type(l))
# [1, 2, 2, 3, 1, 4]
# <class 'list'>

s_l = set(l)

print(s_l)
print(type(s_l))
# {1, 2, 3, 4}
# <class 'set'>

不可變的frozenset 類型是使用構造函數frozenset() 創建的。

fs_l = frozenset(l)

print(fs_l)
print(type(fs_l))
# frozenset({1, 2, 3, 4})
# <class 'frozenset'>

如果省略參數，則創建一個空集類型對象（空集）。

s = set()

print(s)
print(type(s))
# set()
# <class 'set'>

可以使用 set() 從列表或元組中刪除重複元素，但不會保留原始列表的順序。

要將集合類型轉換為列表或元組，請使用 list(),tuple()。

l = [2, 2, 3, 1, 3, 4]

l_unique = list(set(l))
print(l_unique)
# [1, 2, 3, 4]

有關在保留順序的同時刪除重複元素、僅提取重複元素以及處理二維數組（列表列表）中的重複元素的信息，請參閱以下文章。

設置包含符號

除了列表推導，還有集合推導。只需將列表推導中的方括號 [] 替換為大括號 {}。

s = {i**2 for i in range(5)}

print(s)
# {0, 1, 4, 9, 16}

有關列表理解表示法的更多信息，請參閱以下文章。

集合中的元素數:len()

可以使用內置函數 len() 獲取集合中元素的數量。

s = {1, 2, 2, 3, 1, 4}

print(s)
print(len(s))
# {1, 2, 3, 4}
# 4

如果要統計每個列表中包含重複值元素的元素數量等，請參閱以下文章。

將元素添加到集合:add()

要將元素添加到集合中，請使用 add() 方法。

s = {0, 1, 2}

s.add(3)
print(s)
# {0, 1, 2, 3}

從集合中移除一個元素:discard(),remove(),pop(),clear()

要從集合中刪除元素，請使用 discard()、remove()、pop() 和 clear() 方法。

discard() 方法刪除參數中指定的元素。如果指定了集合中不存在的值，則不執行任何操作。

s = {0, 1, 2}

s.discard(1)
print(s)
# {0, 2}

s = {0, 1, 2}

s.discard(10)
print(s)
# {0, 1, 2}

remove() 方法也會刪除參數中指定的元素，但如果指定了集合中不存在的值，則會返回錯誤 KeyError。

s = {0, 1, 2}

s.remove(1)
print(s)
# {0, 2}

# s = {0, 1, 2}

# s.remove(10)
# KeyError: 10

pop() 方法從集合中移除元素並返回它們的值。無法選擇要刪除的值。空集將導致 KeyError 錯誤。

s = {2, 1, 0}

v = s.pop()

print(s)
print(v)
# {1, 2}
# 0

s = {2, 1, 0}

print(s.pop())
# 0

print(s.pop())
# 1

print(s.pop())
# 2

# print(s.pop())
# KeyError: 'pop from an empty set'

clear() 方法刪除所有元素並使集合為空。

s = {0, 1, 2}

s.clear()
print(s)
# set()

瓦塞特（合併、聯合）:|運算符,union()

聯合集（合併，聯合）可以用 |運算符或 union() 方法。

s1 = {0, 1, 2}
s2 = {1, 2, 3}
s3 = {2, 3, 4}

s_union = s1 | s2
print(s_union)
# {0, 1, 2, 3}

s_union = s1.union(s2)
print(s_union)
# {0, 1, 2, 3}

可以為一個方法指定多個參數。除了集合類型之外，可以通過 set() 轉換為集合類型的列表和元組也可以指定為參數。這同樣適用於後續的運算符和方法。

s_union = s1.union(s2, s3)
print(s_union)
# {0, 1, 2, 3, 4}

s_union = s1.union(s2, [5, 6, 5, 7, 5])
print(s_union)
# {0, 1, 2, 3, 5, 6, 7}

產品集（通用部分、交叉點、交叉點）:&操作員,intersection()

乘積集（公共部分、交集、交集）可以用 &運算符或 intersection() 方法。

s_intersection = s1 & s2
print(s_intersection)
# {1, 2}

s_intersection = s1.intersection(s2)
print(s_intersection)
# {1, 2}

s_intersection = s1.intersection(s2, s3)
print(s_intersection)
# {2}

相對互補:-操作員,difference()

可以使用 – 運算符或 difference() 方法獲得差異集。

s_difference = s1 - s2
print(s_difference)
# {0}

s_difference = s1.difference(s2)
print(s_difference)
# {0}

s_difference = s1.difference(s2, s3)
print(s_difference)
# {0}

對稱差集:^ 運算符,symmetric_difference()

可以使用 ^ 運算符或 symmetric_difference() 獲得對稱差分集（僅包含在兩者之一中的元素集）。

相當於邏​​輯運算中的異或（XOR）。

s_symmetric_difference = s1 ^ s2
print(s_symmetric_difference)
# {0, 3}

s_symmetric_difference = s1.symmetric_difference(s2)
print(s_symmetric_difference)
# {0, 3}

子集與否:<= 運算符,issubset()

要確定一個集合是否是另一個集合的子集，請使用 <= 運算符或 issubset() 方法。

s1 = {0, 1}
s2 = {0, 1, 2, 3}

print(s1 <= s2)
# True

print(s1.issubset(s2))
# True

<= 運算符和 issubset() 方法都為等效集返回 true。

要確定它是否是真正的子集，請使用 <= 運算符，它對等效集返回 false。

print(s1 <= s1)
# True

print(s1.issubset(s1))
# True

print(s1 < s1)
# False

上套與否:>= 運算符,issuperset()

要確定一個集合是否是另一個集合的超集，請使用 >= 運算符或 issuperset()。

s1 = {0, 1}
s2 = {0, 1, 2, 3}

print(s2 >= s1)
# True

print(s2.issuperset(s1))
# True

>= 運算符和 issuperset() 方法都為等效集返回 true。

要確定它是否是真正的超集，請使用 >= 運算符，它對等效集返回 false。

print(s1 >= s1)
# True

print(s1.issuperset(s1))
# True

print(s1 > s1)
# False

確定它們是否互質:isdisjoint()

要確定兩個集合是否互質，請使用 isdisjoint() 方法。

s1 = {0, 1}
s2 = {1, 2}
s3 = {2, 3}

print(s1.isdisjoint(s2))
# False

print(s1.isdisjoint(s3))
# True