>>> s=set('cheeseshop') 使用工廠方法創(chuàng)建
>>> s
{'h', 'c', 'o', 's', 'e', 'p'}
>>> type(s)
<type 'set'>
>>> s={'chessseshop','bookshop'}直接創(chuàng)建，類似于list的[]和dict的{}，不同于dict的是其中的值，set會將其中的元素轉(zhuǎn)換為元組
>>> 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 , in ?
AttributeError: 'frozenset' object has no attribute 'add' 

>>> '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
e
p
>>> t=frozenset('bookshop')
>>> t
frozenset({'h', 'o', 's', 'b', 'p', 'k'})
>>> for i in t:
print(i) 
h
o
b
p
k 

 兩個集合的聯(lián)合是一個新集合，該集合中的每個元素都至少是其中一個集合的成員，即，屬于兩個集合其中之一的成員。聯(lián)合符號有一個等價的方法，union().
 >>> s | t
 set(['c', 'b', 'e', 'h', 'k', 'o', 'p', 's']) 

 你可以把交集操作比做集合的 AND(或合取)操作。兩個集合的交集是一個新集合，該集合中的每
 個元素同時是兩個集合中的成員，即，屬于兩個集合的成員。交集符號有一個等價的方法，intersection()
 >>> s & t
 set(['h', 's', 'o', 'p']

 兩個集合(s 和 t)的差補或相對補集是指一個集合 C，該集合中的元素，只屬于集合 s，而不屬
 于集合 t。差符號有一個等價的方法，difference().
 >>> s - t
 set(['c', 'e']) 

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

 上面的示例中，左邊的 s 是可變集合，而右邊的 t 是一個不可變集合. 注意上面使用集合操作
 運算符所產(chǎn)生的仍然是可變集合,但是如果左右操作數(shù)的順序反過來，結(jié)果就不一樣了:
 >>> t | s
 frozenset(['c', 'b', 'e', 'h', 'k', 'o', 'p', 's'])
 >>> t ^ s
 frozenset(['c', 'b', 'e', 'k'])
 >>> t - s frozenset(['k', 'b']) 

 s.update(t) 用 t 中的元素修改 s, 即，s 現(xiàn)在包含 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)，將引發(fā) KeyError 錯誤
 s.discard(obj) 如果 obj 是集合 s 中的元素，從集合 s 中刪除對象 obj；
 s.pop() 刪除集合 s 中的任意一個對象，并返回它
 s.clear() 刪除集合 s 中的所有元素 

 len(s) 集合基數(shù): 集合 s 中元素的個數(shù)
 set([obj]) 可變集合工廠函數(shù); obj 必須是支持迭代的，由 obj 中的元素創(chuàng)建集合，否則創(chuàng)建一個空集合
 frozenset([obj]) 不可變集合工廠函數(shù); 執(zhí)行方式和 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,將引發(fā) KeyError
 s.discard(obj) 丟棄操作: remove() 的 友 好 版 本 - 如果 s 中存在 obj,從 s 中刪除它
 s.pop() Pop 操作: 移除并返回 s 中的任意一個元素
 s.clear() 清除操作: 移除 s 中的所有元素