python中的集合類型（全家福）

白話學python，就找三歲學編程，用最簡譜的話帶你從0開始

python集合是什麼？

python中也有集合類型（set）
該集合類型與數學的集合基本相似。
概念：包含0個或多個數據項的無序組合。集合元素不可重複。
集合中只包含整數、浮點型、字符串、元組等不可變數據。

無序組合

由於集合的無序性所以沒有索引和切片的概念
不能夠切片

可以動態添加或刪除元素。

元素不可重複

集合裏面的元素是單獨的唯一的，不可以重複的
使用集合可以把其他數據類型的內容過濾重複元素

set() 函數

set()函數把其他類型的轉換成集合。

————————————————————————————

#集合的創建及無序性
>>> s = {123, 'python', (13, 14), 5.18}
>>> s
{(13, 14), 123, 5.18, 'python'}
>>> t = {123, 'python', (13, 14), 5.18, 'hallo'}
>>> t
{5.18, 'python', (13, 14), 'hallo', 123}
#set() 函數的使用
>>> w = set('python')
>>> w
{'n', 'y', 'h', 'p', 't', 'o'}
>>> v = set(((13, 14), 123, 5.18, 'python'))
>>> v
{(13, 14), 123, 5.18, 'python'}
#不可重複性
>>> c = {3, 5, 6, 3}
>>> c
{3, 5, 6}
>>> a = 3, 6, 9, 6 #創建元組a
>>> a = set(a)# 將元組轉換成列表
>>> a
{9, 3, 6}

集合類型的操作符

集合共有4種基本操作：

交集 （&）
並集 （|）
差集 （-）
補集 （^）

集合類型操作符

操作符	描述
S-T or S.difference(T)	返回一個新的集合，包括在集合S但是不包括在T中的元素
S -= T or S.difference_update(T)	更新集合S ，返回S中有的但是T中沒有的元素
S&T or S.intersection(T)	返回一個新集合，包括在S和T中的相同的元素
S&=T or S.intersection_update(T)	更新集合S，返回集合S和T中共有的元素
S|T or S.union(T)	返回一個新的集合，包括S和T中所有的元素
S|=T or S.updat(T)	更新集合S，返回 S 和 T 的所有元素
S^T or S.symmetric_difference(T)	返回一個新集合，包含 S 和T 之中所有不同的元素
S^=T or S.symmetric_difference_update(T)	更新集合 S ，返回集合 S 和 T 集合的不相同值
S<=T or S.issubset(T)	S 與 T相同，或是其子集則返回 True 否則返回 False,用 S<T 判定S 是不是T 的真子集
S>=T or S.issuperset(T)	與上面的相反，S 與 T 相同或 S 是 T 的子集，返回 True ，否者返回 False，用 S>T 來判斷 S 是不是 T 的 真超集

差集

集合A和B的差集就是兩者的差

S - T or S.difference(T)

返回一個新的集合，包括在集合S但是不包括在T中的元素

>>> s - t
set()
>>> t-s
{'hallo'}
>>> s.difference(t)
set()
>>> t.difference(s)
{'hallo'}

S -= T or S.difference_update(T)

更新集合S ，返回S中有的但是T中沒有的元素

>>> s -= t
>>> s
set()
>>> s = {123, 'python', (13, 14), 5.18}
>>> t = {123, 'python', (13, 14), 5.18, 'hallo'}
>>> t -= s
>>> t
{'hallo'}
>>> s = {123, 'python', (13, 14), 5.18}
>>> t = {123, 'python', (13, 14), 5.18, 'hallo'}
>>> t.difference_update(s)
>>> t
{'hallo'}
>>> s = {123, 'python', (13, 14), 5.18}
>>> t = {123, 'python', (13, 14), 5.18, 'hallo'}
>>> s.difference_update(t)
>>> s
set()

交集

A和B相同的部分

S&T or S.intersection(T)

返回一個新集合，包括在S和T中的相同的元素

>>> s = {123, 'python', (13, 14), 5.18}
>>> t = {123, 'python', (13, 14), 5.18, 'hallo'}
>>> s & t
{(13, 14), 123, 5.18, 'python'}
>>> t & s
{(13, 14), 123, 5.18, 'python'}
>>> s.intersection(t)
{(13, 14), 123, 5.18, 'python'}
>>> t.intersection(s)
{(13, 14), 123, 5.18, 'python'}

這裏s和t的順序無關，結果都一樣

S&=T or S.intersection_update(T)

更新集合S，返回集合S和T中共有的元素

>>> s &= t
>>> s
{(13, 14), 123, 5.18, 'python'}
>>> t &= s
>>> t
{(13, 14), 123, 5.18, 'python'}
>>> s.intersection_update(t)
>>> s
{(13, 14), 123, 5.18, 'python'}
>>> t.intersection_update(s)
>>> t
{(13, 14), 123, 5.18, 'python'}

這裏要注意s和t的位置，結果是不一樣的

並集

A和B的並集是A和B裏面所有的元素

S|T or S.union(T)

返回一個新的集合，包括S和T中所有的元素

>>> s = {(13, 14), 123, 5.18, 'python'}
>>> t = {5.18, 'python', (13, 14), 'hallo', 123}
>>> s | t
{5.18, 'python', (13, 14), 'hallo', 123}
>>> s.union(t)
{5.18, 'python', (13, 14), 'hallo', 123}

因爲不改變原有代碼，s和 t 的順序不會產生影響

S|=T or S.updat(T)

更新集合S，返回 S 和 T 的所有元素

>>> s |= t
>>> s
{5.18, 'python', (13, 14), 'hallo', 123}
>>> t |= s
>>> t
{5.18, 'python', (13, 14), 'hallo', 123}

>>> s = {(13, 14), 123, 5.18, 'python'}
>>> t.update(s)
>>> t
{5.18, 'python', (13, 14), 'hallo', 123}
>>> s.update(t)
>>> s
{5.18, 'python', (13, 14), 'hallo', 123}

因爲會更新原有集合，所以注意順序

補集

A 和 B 集合中不相同的元素

S^T or S.symmetric_difference(T)

返回一個新集合，包含 S 和T 之中所有不同的元素

>>> s = {(13, 14), 123, 5.18, 'python'}
>>> s ^ t
{'hallo'}
>>> s.symmetric_difference(t)
{'hallo'}

返回新集合，s 和 t 的位置無關

S^=T or S.symmetric_difference_update(T)

更新集合 S ，返回集合 S 和 T 集合的不相同值

>>> s ^= t
{'hallo'}
>>> t ^= s
{5.18, 'python', (13, 14), 123}

>>>s.symmetric_difference_update(t)
>>> s
{'hallo'}

>>> t.symmetric_difference_update(s)
>>> t
{'hallo'}

更新了數組，注意順序和位置

S和T數組比較

S<=T or S.issubset(T)

S 與 T相同，或是其子集則返回 True 否則返回 False
用 S<T 判定S 是不是T 的真子集

>>> s = {(13, 14), 123, 5.18, 'python'}
>>> t={5.18, 'python', (13, 14), 'hallo', 123}
>>> s <= t
True
>>> s.issubset (t)
True
>>> t <= s
False
>>> t.issubset(s)
False

S>=T or S.issuperset(T)

與上面的相反，S 與 T 相同或 S 是 T 的子集，返回 True ，否者返回 False
用 S>T 來判斷 S 是不是 T 的 真超集

>>> s >= t
False
>>> s.issuperset(t)
False
>>> t >= s
True
>>> t.issuperset(s)
True

集合類型的操作函數或方法

操作函數及方法	描 述/解 釋
S.add(X)	如果 元素 X 不在 S 集合中則添加到集合 S
S.clear()	移除 S 中的所有數據項
S.copy()	返回一個集合的副本
S.pop()	隨機返回集合的一個元素，若S爲空則報錯！
S.discard(X)	如果元素 X 在集合 S 中，則刪除，不在也不報錯
S.remove(X)	如果元素 X 在集合 S 中，則刪除，不在則報錯（keyError異常）
S.isdisjoint(T)	若 S 和 T 沒有相同的元素則返回True
X in S	如果X 是S的元素返回 True 否則返回False
X not in S	如果X 不是S的元素返回 True 否則返回False

S.add(X)

如果 元素 X 不在 S 集合中則添加到集合 S

>>> s.add(250)
>>> s
{5.18, 'python', (13, 14), 250, 123}

S.clear()

移除 S 中的所有數據項

>>> s = {5.18, 'python', (13, 14), 250, 123}
>>> s.clear()
>>> s
set()

注：移除數據項，不是刪除整個集合

S.copy()

返回一個集合的副本
注：這裏是副本，不是返回集合

>>> s.copy()
{(13, 14), 123, 5.18, 'python'}

S.pop()

隨機返回集合的一個元素，若S爲空則報錯！

>>> s.pop()
(13, 14)
>>> s.pop()
123
#報錯測試
>>> b = set()
>>> b.pop()
Traceback (most recent call last):
  File "<pyshell#94>", line 1, in <module>
    b.pop()
KeyError: 'pop from an empty set'

S.discard(X) or S.remove(X)

S.discard(X) | 如果元素 X 在集合 S 中，則刪除，不在也不報錯
S.remove(X) | 如果元素 X 在集合 S 中，則刪除，不在則報錯（keyError異常）

# S.discard(X)
>>> s = {5.18, 'python', (13, 14), 250, 123}
>>> s.discard(123)
>>> s
{5.18, 'python', (13, 14), 250}
>>> s.discard(6)
>>> s
{5.18, 'python', (13, 14), 250}

#S.remove(X)
>>> s = {5.18, 'python', (13, 14), 250, 123}
>>> s.remove(123)
>>> s
{5.18, 'python', (13, 14), 250}
>>> s.remove(12)
Traceback (most recent call last):
  File "<pyshell#105>", line 1, in <module>
    s.remove(12)
KeyError: 12

S.isdisjoint(T)

若 S 和 T 沒有相同的元素則返回True

>>> s.isdisjoint(t)
False

X in S or X not in S

X in S | 如果X 是S的元素返回 True 否則返回False
X not in S | 如果X 不是S的元素返回 True 否則返回False

>>> 'python' in s
True
>>> 'python' not in s
False
>>> 'hallo' in s
False
>>> 'hallo' not in s
True

優勢

集合的單一性，不包括重複的元素是特色
所以有需要數據去重的可以用集合來完成

冰凍的集合

冰凍的被凍住了那麼久無法修改了，這是一個特殊的集合又叫不可變集合

frozenset()

定義冰凍的集合（不可變集合）

>>> a = frozenset('pythopn')
>>> a
frozenset({'y', 'p', 'h', 't', 'n', 'o'})

既然是不可變的集合那麼上面的
添加、刪除就不存在了

沒有add()、remove()、clear()、pop()等函數

>>> a.add('c') #add()報錯
Traceback (most recent call last):
  File "<pyshell#2>", line 1, in <module>
    a.add('c')
AttributeError: 'frozenset' object has no attribute 'add'

>>> a.clear('h')#clear() 報錯
Traceback (most recent call last):
  File "<pyshell#3>", line 1, in <module>
    a.clear('h')
AttributeError: 'frozenset' object has no attribute 'clear'

>>> a.remove('h')#remove()報錯
Traceback (most recent call last):
  File "<pyshell#4>", line 1, in <module>
    a.remove('h')
AttributeError: 'frozenset' object has no attribute 'remove'

>>> a.pop()# pop()報錯
Traceback (most recent call last):
  File "<pyshell#6>", line 1, in <module>
    a.pop()
AttributeError: 'frozenset' object has no attribute 'pop'

>>> a.discard('h')#discard()報錯
Traceback (most recent call last):
  File "<pyshell#7>", line 1, in <module>
    a.discard('h')
AttributeError: 'frozenset' object has no attribute 'discard'

以上函數均不適用於冰凍集合，估計是他太高冷，沒有那麼平易近人。
他有哈希值，可以作爲字典的鍵，也可以作爲元素，就是不能夠修改，比較硬核。

集合的整理就告一段落了，有問題記得留言，好的記得收藏
點個贊，給小編一點，鼓勵，整理不易啊
謝謝大家！！！