什麼是集合？正如其字面的意思，一堆東西集中合併到一起。乍一聽貌似和容器沒什麼差別，嗯，好吧，集合也算是一種容器。 在學習這個容器有什麼不同之前，先看看集合是如何創建的： 集合分為兩種，一種是不可變的，一種是可變的，兩者的差異後面會分析。 不過，我們創建了兩個空的集合貌似麽什麼意思。 為了使其有意義， ...
什麼是集合？正如其字面的意思，一堆東西集中合併到一起。乍一聽貌似和容器沒什麼差別，嗯，好吧，集合也算是一種容器。
在學習這個容器有什麼不同之前，先看看集合是如何創建的：
a = set() #不可變集合 b = frozenset() #可變集合 print a print b
集合分為兩種，一種是不可變的，一種是可變的，兩者的差異後面會分析。
不過，我們創建了兩個空的集合貌似麽什麼意思。
為了使其有意義，我們就先來看集合最重要的功能：去重。
a = ('aaa',123,123,123) b = set(a) print b
可以看到元祖a中的重覆的元素123在集合中只剩下一個了。所以，我們總結集合的概念：
集合就是將不同的元素放在一起組成一個集合對象。（不影響原來的對象）
此時，有機智的同學看到集合裡面有個方括弧，立馬想到了列表，並試圖用索引來取值：
a = ('aaa',123,123,123) b = set() print b[0]
然而並不可以。
因為集合是無序的，和字典一樣。
那麼是否我們可以將集合看作是一種特殊的字典，只不過沒有鍵，所以不能通過鍵去取值而已。
某種意義上是可以的，不過要註意，集合分為可變集合和不可變集合兩種，不可變的集合就不能像字典一樣修改元素。
另外補充一點：
a = 'abcdaabbccdd' b = set(a) print b
因為字元串也是序列，所以也可以用來去重，但是一般沒什麼用就是。
那麼，對字典去重會怎麼樣？我們在字典中瞭解到了字典會自動處理鍵名重覆的問題，那麼值能進行去重嗎？
a = {'a':123,'b':123}
b = set(a)
print b
看來還是對鍵的去重，並沒有什麼用，除非要將所以的鍵組合成一個集合，其去重意義不大。看業務需要吧。
這裡，我對去重的總結是：去除重覆的引用，相信看過我在python序列中的說明的人能明白這是什麼意思。
知道去重的本質之後，我們有這個需求，我有兩個容器，我想得到這兩個容器去重後的結果。
那我這樣寫：
a = ('scolia',123,456,666) b = ('scolia',666) c = set(a,b) print c
結果是大紅字甩臉，說只要一個參數，結果給了兩個。
好吧，首先看看其內部是怎麼接受參數的：
首先，這裡的__init__是構造函數，在類的創建時會講。現在只要知道我們的參數是傳給 seq=() 的，而按照這裡的寫法，應該是可以傳一個元祖的。
那麼是不是就可以這樣寫：
a = ('scolia',123,456,666) b = ('scolia',666) c = set((a,b)) print c
傳是傳進去了，但結果並不是我們想象的那樣。
看來集合的去重是針對一個對象的，那麼我們就可以將集合總結成：
集合是去除一個對象（序列或類序列的字典）中，元素的重覆引用的。
所以我們想要實現這個需要，首先要將兩個對象拼接起來:
a = ('scolia',123,456,666) b = ('scolia',666) c = set(a+b) print c
關於序列的拼接不只一種，詳情看我之前的博文。
而不同類型的序列先要強制轉換成一種，否則報錯
a = ('scolia',123,456,666) b = ['scolia',666] c = set(a+tuple(b)) print c
下麵我們來開始學習其內置方法吧。
老辦法，先看看幫助文檔。
因為集合分為可變和不可變的，所以將分開說明：
Help on class set in module __builtin__: class set(object) | set() -> new empty set object | set(iterable) -> new set object | | Build an unordered collection of unique elements. | | Methods defined here: | | __and__(...) | x.__and__(y) <==> x&y | | __cmp__(...) | x.__cmp__(y) <==> cmp(x,y) | | __contains__(...) | x.__contains__(y) <==> y in x. | | __eq__(...) | x.__eq__(y) <==> x==y | | __ge__(...) | x.__ge__(y) <==> x>=y | | __getattribute__(...) | x.__getattribute__('name') <==> x.name | | __gt__(...) | x.__gt__(y) <==> x>y | | __iand__(...) | x.__iand__(y) <==> x&=y | | __init__(...) | x.__init__(...) initializes x; see help(type(x)) for signature | | __ior__(...) | x.__ior__(y) <==> x|=y | | __isub__(...) | x.__isub__(y) <==> x-=y | | __iter__(...) | x.__iter__() <==> iter(x) | | __ixor__(...) | x.__ixor__(y) <==> x^=y | | __le__(...) | x.__le__(y) <==> x<=y | | __len__(...) | x.__len__() <==> len(x) | | __lt__(...) | x.__lt__(y) <==> x<y | | __ne__(...) | x.__ne__(y) <==> x!=y | | __or__(...) | x.__or__(y) <==> x|y | | __rand__(...) | x.__rand__(y) <==> y&x | | __reduce__(...) | Return state information for pickling. | | __repr__(...) | x.__repr__() <==> repr(x) | | __ror__(...) | x.__ror__(y) <==> y|x | | __rsub__(...) | x.__rsub__(y) <==> y-x | | __rxor__(...) | x.__rxor__(y) <==> y^x | | __sizeof__(...) | S.__sizeof__() -> size of S in memory, in bytes | | __sub__(...) | x.__sub__(y) <==> x-y | | __xor__(...) | x.__xor__(y) <==> x^y | | add(...) | Add an element to a set. | | This has no effect if the element is already present. | | clear(...) | Remove all elements from this set. | | copy(...) | Return a shallow copy of a set. | | difference(...) | Return the difference of two or more sets as a new set. | | (i.e. all elements that are in this set but not the others.) | | difference_update(...) | Remove all elements of another set from this set. | | discard(...) | Remove an element from a set if it is a member. | | If the element is not a member, do nothing. | | intersection(...) | Return the intersection of two or more sets as a new set. | | (i.e. elements that are common to all of the sets.) | | intersection_update(...) | Update a set with the intersection of itself and another. | | isdisjoint(...) | Return True if two sets have a null intersection. | | issubset(...) | Report whether another set contains this set. | | issuperset(...) | Report whether this set contains another set. | | pop(...) | Remove and return an arbitrary set element. | Raises KeyError if the set is empty. | | remove(...) | Remove an element from a set; it must be a member. | | If the element is not a member, raise a KeyError. | | symmetric_difference(...) | Return the symmetric difference of two sets as a new set. | | (i.e. all elements that are in exactly one of the sets.) | | symmetric_difference_update(...) | Update a set with the symmetric difference of itself and another. | | union(...) | Return the union of sets as a new set. | | (i.e. all elements that are in either set.) | | update(...) | Update a set with the union of itself and others. | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __hash__ = None | | __new__ = <built-in method __new__ of type object> | T.__new__(S, ...) -> a new object with type S, a subtype of Tset
可分為以下幾類：
1.運算符相關
3.內置函數相關（以後總結）
4.普通內置方法
1.運算符相關
不知道你是否還記得數學中的集合，就是那個交集、補集什麼的，忘記了請自己重修。
下麵用一個表格總結：
| 數學符號 | python符號 | 說明 |
| ∩ | & | 交集，如a&b |
| ∪ | | | 並集，如a|b |
| - 或 \ | - | 差補或相對補集 |
| △ | ^ | 對稱差分 |
| ⊂ | < | 真子集 |
| ⊆ | <= | 子集 |
| ⊃ | > | 真超集 |
| ⊇ | >= | 超集 |
| = | == | 等於，兩個集合相等 |
| ≠ | != | 不等於 |
| ∈ | in | 屬於，是裡面的元素 |
| ∉ | not in | 不屬於 |
這部分內容只能呼叫數學老師了。我就不講了。
2.普通內置方法
雖說在幫助文檔中列出了一堆方法，但集合是分為可變的和不可變的，所以有些方法，如修改操作只有可變的集合可以使用，所以內置方法又可以分為兩種：
1.所有集合都能使用的：
| 方法 | 說明 |
| a.issubset(b) | 如果a是b的子集，則返回True，否則返回False |
| a.issuperset(b) | 如果a是b的超集，則返回True，否則返回False |
| a.intersection(b) | 返回a和b的交集 |
| a.union(b) | 返回a和b的並集 |
| a.difference(b) | 返回一個新集合，該集合是集合a去除和b元素部分後的 |
| a.symmetric_difference(b) | 返回一個新集合，該集合是a或b的成員，但不是a和b共有的成員 |
| a.copy() | 返回一個淺拷貝。 |
2.可修改集合才能用的：
| 方法 | 說明 |
| a.add() | 在集合里添加新的對象 |
| a.clear() | 清空集合里的所有對象 |
| a.pop() | 刪除a中的任意元素，並返回，為空時報錯 |
| a.remove(obj) | 在a中刪除obj這個元素，沒找到時報錯 |
| a.discard(obj) | 在a中刪除obj這個元素，沒找到時什麼都不做，返回None |
| a.update(b) | 用b中的元素修改a，此時a包含a或b的成員。相當與合併 |
| a.intersection_update(b) | 用a和b的交集更新a集合 |
| a.difference_update(b) | 從a中移除和b一樣的元素 |
| a.symmetric_difference(b) | 將a修改成a和b的對稱差分 |
這裡交並補、子集超集之類的基本數學概念就不再重覆了。這裡講下差補和對稱差分：
1.差補
a =set( 'scolia') b = set('good') print a - b print a.difference(b)
實際上就是幹掉了 a 中的 'o'，而之所以幹掉 'o' 是因為兩個集合裡面都有 'o'。
本想用數學公式來解釋一番的，然而我的數學也已經遺忘到太平洋里去了。
2.對稱差分
a =set( 'scolia') b = set('good') print a ^ b print a.symmetric_difference(b)
將幹掉兩種的交集，然後把剩下來的拿出去組成新集合。
好了，集合就先講到這裡了，這麼多東西我也不一定全部記得住，要用的時候再來查就行了。
參考資料：戳這裡
