集合 set：使用一對大括號，元素寫在大括號之間，使用逗號分隔

集合中的元素只能是不可變的數據類型，不能是列表、字典和集合

set1 = {1, 2, 3}
set2 = {1, 'a', (1, 2, 3)}
print(type(set1), type(set2))  # <class 'set'> <class 'set'>
print(set1, set2)  # {1, 2, 3} {1, 'a', (1, 2, 3)}

集合自動去重且無序

set3 = {3, 3, 2, 2, 1, 1}
print(set3)        # {1, 2, 3}

集合需要注意以下幾點：

1.集合屬于可變的數據類型

2.集合有去重功能，對元素自動去重

3.集合的元素只能是不可變的類型（數值、字符串、元組），不能使用列表、字典、集合

4.集合 set 與字典 map，都是以 hash 值分布存儲，是無序的數據結構

5.空集合不能直接使用一對大括號，空字典才使用 { }

可以使用 set 創建集合

格式：set(可迭代對象)

對象為字典，獲取字典的鍵 key

set4 = set()
print(type(set4), set4)       # <class 'set'> set()# 對象為字符串，去重且無序
set5 = set('Hello')
print(type(set5), set5)       # <class 'set'> {'H', 'o', 'l', 'e'}# 對象為列表、元組、集合
set6 = set((1, 2))
print(type(set6), set6)       # <class 'set'> {1, 2}# 對象為字典，獲取字典的鍵key
set7 = set({'name': 'zhangsan', 'age': 18})
print(type(set7), set7)       # <class 'set'> {'name', 'age'}

集合的運算與運算符：

交集 &? ? ?并集 |? ? ?補集 ^? ? ?差集 -

交集 &?，返回兩個集合中出現相同的元素，intersection

并集 |?，返回兩個集合的全部元素，union

補集 ^?，返回兩個集合中不同的元素，symmetric_difference

差集 -?，對兩個集合進行減法運算，difference

# 交集 &，返回兩個集合中出現相同的元素
s1 = {1, 2, 3, 4, 5}
s2 = {1, 2, 3, 8, 9}
print(s1 & s2)                # {1, 2, 3}
print(s1.intersection(s2))    # {1, 2, 3}# 并集 |，返回兩個集合的全部元素
s3 = {1, 2, 3}
s4 = {2, 3, 4}
print(s3 | s4)         # {1, 2, 3, 4}  集合去重
print(s3.union(s4))    # {1, 2, 3, 4}# 補集 ^，返回兩個集合中不同的元素
s5 = {1, 2, 3, 4, 5}
s6 = {1, 2, 3}
print(s5 ^ s6)                           # {4, 5}
print(s5.symmetric_difference(s6))       # {4, 5}# 差集 -，對兩個集合進行減法運算
s7 = {1, 2, 3, 4, 5}
s8 = {4, 5, 6, 7, 8}
print(s7 - s8)               # {1, 2, 3}
print(s7.difference(s8))     # {1, 2, 3}
print(s8 - s7)               # {8, 6, 7}   集合無序
print(s8.difference(s7))     # {8, 6, 7}

集合更新 update：原集合上更新新集合

集合 1.intersection_update(集合 2)，把交集后的元素更新到集合 1 中

集合 1.update(集合 2)，把并集后的元素更新到集合 1 中

集合 1.symmetric_difference_update(集合 2)，把補集后的元素更新到集合 1 中

集合 1.difference_update(集合 2)，把差集后的元素更新到集合 1 中

# 交集更新
set8 = {1, 2, 3}
set9 = {3, 4, 5}
set8.intersection_update(set9)
print(set8)      # {3}# 并集更新
set8 = {1, 2, 3}
set9 = {3, 4, 5}
set8.update(set9)
print(set8)      # {1, 2, 3, 4, 5}# 補集更新
set8 = {1, 2, 3}
set9 = {3, 4, 5}
set8.symmetric_difference_update(set9)
print(set8)     # {1, 2, 4, 5}# 差集更新
set8 = {1, 2, 3}
set9 = {3, 4, 5}
set8.difference_update(set9)
print(set8)    # {1, 2}

集合增加元素：add(元素)

集合增加的元素只能是不可變的數據類型，比如數值、字符串和元組

不能是列表、字典這些可變的數據類型，否則會報錯

set10 = set()      # 空集合
set10.add(1)
set10.add('a')
set10.add((1, 'a'))
print(set10)       # {(1, 'a'), 1, 'a'}

集合元素的刪除：

1. pop()，隨機刪除

2. remove(指定元素)，刪除指定元素，元素不存在則報錯

set11 = {1, 'a', 2, 'b'}
# remove(指定元素) 刪除
print(set11.remove('b'))       # None
print(set11)                   # {1, 2, 'a'}

3. clear()，清空集合的元素，返回空集合

set11 = {1, 'a', 2, 'b'}
# clear()，清空集合的元素，返回空集合
set11.clear()
print(set11)          # set()

4. discard(指定元素)，刪除指定元素，元素不存在，不會報錯

set11 = {1, 'a', 2, 'b'}
# discard(指定元素)，元素不存在，不會報錯
print(set11.discard('c'))     # None
print(set11)                  # {1, 2, 'a', 'b'}

is 開頭的函數用來做判斷，結果返回布爾值 True、False

集合 1.issubset(集合 2)，判斷集合 1 是否是集合 2 的子集，如果是返回 True，不是則返回 False

集合 1.issuperset(集合 2)，判斷集合 2 是否是集合 1 的子集，如果是返回 True，不是則返回 False

集合 1.isdisjoint(集合 2)，判斷兩個集合是否有相同的元素，有相同元素返回 False，沒有相同元素返回 True

set12 = {1, 2, 3}
set13 = {1, 2, 3, 4, 5}
# 集合1.issubset(集合2)，判斷集合 1 是否是集合 2 的子集
print(set12.issubset(set13))     # True# 集合1.issuperset(集合2)，判斷集合 2 是否是集合 1 的子集
print(set13.issuperset(set12))   # True# 集合1.isdisjoint(集合2)，判斷兩個集合是否有相同的元素，有相同元素返回 False，沒有相同元素返回 True
print(set12.isdisjoint(set13))   # False

copy 淺拷貝：

set14 = {1, 2, 3, 4, 5}
set15 = set14.copy()
print(set14, id(set14))    # {1, 2, 3, 4, 5} 2100890355520
print(set15, id(set15))    # {1, 2, 3, 4, 5} 2100890355744
print(set14 is set15)      # False