python中set和frozenset方法和區別

set(可變集合)與frozenset(不可變集合)的區別：

set無序排序且不重復，是可變的，有add（），remove（）等方法，既然是可變的，所以它不存在哈希值，基本功能包括關系測驗和消除重復元素. 集合物件還支持union(聯合), intersection(交集), difference(差集)和sysmmetric difference(對稱差集)等數學運算.
sets 支持 x in set, len(set),和 for x in set，作為一個無序的集合，sets不記錄元素位置或者插入點，因此，sets不支持 indexing, 或其它類序列的操作，
frozenset是凍結的集合，它是不可變的，存在哈希值，好處是它可以作為字典的key，也可以作為其它集合的元素，缺點是一旦創建便不能更改，沒有add，remove方法，

一、集合的創建

set()和 frozenset()工廠函式分別用來生成可變和不可變的集合，如果不提供任何引數，默認
會生成空集合，如果提供一個引數，則該引數必須是可迭代的，即，一個序列，或迭代器，或支持
迭代的一個物件，例如：一個串列或一個字典，

>>> s=set('cheeseshop')  #使用工廠方法創建
>>> s
{'h', 'c', 'o', 's', 'e', 'p'}
>>> type(s)
<type 'set'>
 
>>> s={'chessseshop','bookshop'}#直接創建，類似于list的[]和dict的{}，不同于dict的是其中的值，set會將其中的元素轉換為元組
>>> s
{'bookshop', 'chessseshop'}
>>> type(s)
<type 'set'>
 
#不可變集合創建：
>>> t=frozenset('bookshop')
>>> t
frozenset({'h', 'o', 's', 'b', 'p', 'k'})

二、更新可變集合

用各種集合內建的方法和運算子添加和洗掉集合的成員:

>>> s.add('z')  #添加
>>> s
set(['c', 'e', 'h', 'o', 'p', 's', 'z'])
>>> s.update('pypi') #添加
>>> s
set(['c', 'e', 'i', 'h', 'o', 'p', 's', 'y', 'z'])
>>> s.remove('z') #洗掉
>>> s
set(['c', 'e', 'i', 'h', 'o', 'p', 's', 'y'])
>>> s -= set('pypi')#洗掉
>>> s
set(['c', 'e', 'h', 'o', 's'])
>>> del s  #洗掉集合

只有可變集合能被修改，試圖修改不可變集合會引發例外，

>>> t.add('z')
Traceback (most recent call last):
File "<stdin>", line 1, in ?
AttributeError: 'frozenset' object has no attribute 'add'

三、成員關系 (in, not in)

 >>> 'k' in s
 False
 >>> 'k' in t
 True
 >>> 'c' not in t
 True

四、集合等價/不等價

>>> s == t
False
>>> s != t
True
>>> u = frozenset(s)
>>> s == u
True
>>> set('posh') == set('shop')
True

五、子集/超集

 >>> set('shop') < set('cheeseshop')
 True
 >>> set('bookshop') >= set('shop')
 True

六、遍歷訪問集合中的值(可變集合和非可變都支持)

>>> s=set('cheeseshop')
>>> s
{'h', 'c', 'o', 's', 'e', 'p'}
>>> for i in s:
    print(i)   
h
c
o
s
e
p
 
 
>>> t=frozenset('bookshop')
>>> t
frozenset({'h', 'o', 's', 'b', 'p', 'k'})
>>> for i in t:
    print(i)   
h
o
s
b
p
k

七、集合型別運算子（所有的集合型別）

1.聯合( | )

兩個集合的聯合是一個新集合，該集合中的每個元素都至少是其中一個集合的成員，即，屬于兩個集合其中之一的成員，聯合符號有一個等價的方法，union().

 >>> s | t
 set(['c', 'b', 'e', 'h', 'k', 'o', 'p', 's'])

2.交集( & )

你可以把交集操作比做集合的 AND(或合取)操作，兩個集合的交集是一個新集合，該集合中的每個元素同時是兩個集合中的成員，即，屬于兩個集合的成員，交集符號有一個等價的方法，intersection()

>>> s & t
set(['h', 's', 'o', 'p']

3.差補/相對補集( – )

兩個集合(s 和 t)的差補或相對補集是指一個集合 C，該集合中的元素，只屬于集合 s，而不屬于集合 t，差符號有一個等價的方法，difference().

>>> s - t
set(['c', 'e'])

4.對稱差分( ^ )

和其他的布爾集合操作相似， 對稱差分是集合的 XOR(又稱"異或 ").
兩個集合(s 和 t)的對稱差分是指另外一個集合 C,該集合中的元素，只能是屬于集合 s 或者集合 t的成員，不能同時屬于兩個集合，對稱差分有一個等價的方法，symmetric_difference().

>>> s ^ t
set(['k', 'b', 'e', 'c'])

5.混合集合型別操作
上面的示例中，左邊的 s 是可變集合，而右邊的 t 是一個不可變集合. 注意上面使用集合操作運算子所產生的仍然是可變集合,但是如果左右運算元的順序反過來，結果就不一樣了:

>>> t | s
frozenset(['c', 'b', 'e', 'h', 'k', 'o', 'p', 's'])
>>> t ^ s#Python小白學習交流群：711312441
frozenset(['c', 'b', 'e', 'k'])
>>> t - s frozenset(['k', 'b'])

如果左右兩個運算元的型別相同， 既都是可變集合或不可變集合, 則所產生的結果型別是相同的，但如果左右兩個運算元的型別不相同(左運算元是 set，右運算元是 frozenset，或相反情況)，則所產生的結果型別與左運算元的型別相同，

八、可變集合型別的方法

s.update(t) 用 t 中的元素修改 s, 即，s 現在包含 s 或 t 的成員
s.intersection_update(t) s 中的成員是共同屬于 s 和 t 的元素，
s.difference_update(t) s 中的成員是屬于 s 但不包含在 t 中的元素
s.symmetric_difference_update(t) s 中的成員更新為那些包含在 s 或 t 中，但不 是 s
和 t 共有的元素
s.add(obj) 在集合 s 中添加物件 obj
s.remove(obj) 從集合 s 中洗掉物件 obj；如果 obj 不是集合 s 中的元素(obj not
in s)，將引發 KeyError 錯誤
s.discard(obj) 如果 obj 是集合 s 中的元素，從集合 s 中洗掉物件 obj；
s.pop() 洗掉集合 s 中的任意一個物件，并回傳它
s.clear() 洗掉集合 s 中的所有元素

九、集合型別運算子、函式和方法

函式/方法名 等價運算子 說明
所有集合型別：

len(s) 集合基數: 集合 s 中元素的個數
set([obj]) 可變集合工廠函式; obj 必須是支持迭代的，由 obj 中
的元素創建集合，否則創建一個空集合
frozenset([obj]) 不可變集合工廠函式; 執行方式和 set()方法相同，
但它回傳的是不可變集合
obj in s 成員測驗：obj 是 s 中的一個元素嗎?
obj not in s 非成員測驗：obj 不是 s 中的一個元素嗎?
s == t 等價測驗: 測驗 s 和 t 是否具有相同的元素?
s != t 不等價測驗: 與==相反
s < t (嚴格意義上)子集測驗; s != t 而且 s 中 所 有
的元素都是 t 的成員
s.issubset(t) s <= t 子集測驗(允許不嚴格意義上的子集): s 中所有的元素
都是 t 的成員
s > t (嚴格意義上)超集測驗: s != t 而且 t 中所有的元素
都是 s 的成員
s.issuperset(t) s >= t 超集測驗(允許不嚴格意義上的超集): t 中所有的元素
都是 s 的成員
s.union(t) s | t 合并操作： s 或 t 中的元素
s.intersec- tion(t) s & t 交集操作： s 和 t 中的元素
s.difference(t) s - t 差分操作: s 中的元素，而不是 t 中的元素
s.symmetric_difference(t)s ^ t 對稱差分操作：s 或 t 中的元素，但不是 s 和 t 共有
的元素
s.copy() 復制操作:回傳 s 的(淺復制)副本

僅用于可變集合：

s.update(t) s |= t (Union) 修改操作: 將 t 中的成員添加 s
s.intersection_update(t) s &= t 交集修改操作: s 中僅包括 s 和 t 中共有的成員
s.difference_update(t) s -= t 差修改操作: s 中包括僅屬于 s 但不屬于 t 的成員
s.symmetric_
difference_
update(t) s ^= t 對稱差分修改操作: s 中包括僅屬于 s 或僅屬于 t 的
成員
s.add(obj) 加操作: 將 obj 添加到 s
s.remove(obj) 洗掉操作: 將 obj 從 s 中洗掉；如果 s 中不存在
obj,將引發 KeyError
s.discard(obj) 丟棄操作: remove() 的 友 好 版 本 - 如
果 s 中存在 obj,
從 s 中洗掉它
s.pop() Pop 操作: 移除并回傳 s 中的任意一個元素
s.clear() 清除操作: 移除 s 中的所有元素

標籤：Python

上一篇：Python從零到壹丨帶你了解影像直方圖理論知識和繪制實作

下一篇：返回列表