摘要：與上面的操作類似，可以使用多種運(yùn)算符和方法來(lái)更改集合的內(nèi)容。通過(guò)修改集合元素方法運(yùn)算符用法通過(guò)修改集合和作用是向集合中添加中所有不存在的元素。

大家好，恰逢初五迎財(cái)神，先預(yù)祝大家新年財(cái)源滾滾??！
在上一期詳解tuple元組的用法后，今天我們來(lái)看Python里面最后一種常見(jiàn)的數(shù)據(jù)類型：集合(Set)

與dict類似，set也是一組key的集合，但不存儲(chǔ)value。由于key不能重復(fù)，所以，在set中，沒(méi)有重復(fù)的key。創(chuàng)建一個(gè)set，需要提供一個(gè)list作為輸入集集合，重復(fù)元素在set中會(huì)被自動(dòng)被過(guò)濾，通過(guò)add(key)方法往set中添加元素，重復(fù)添加不會(huì)有效果。如果現(xiàn)在你發(fā)現(xiàn)我講的很模糊請(qǐng)不要著急。稍后會(huì)有海量例子為大家詳解。

總而言之,Set具有三個(gè)顯著特點(diǎn)：

無(wú)序

元素是獨(dú)一無(wú)二的，不允許出現(xiàn)重復(fù)的元素

可以修改集合本身，但集合中包含的元素必須是不可變類型

現(xiàn)在讓我們開(kāi)啟Set奇幻之旅，我希望這篇文章是SegmentFault社區(qū)對(duì)于Set介紹最全的模范，哈哈！

我們有兩種方式可以創(chuàng)建一個(gè)Set，可以使用內(nèi)置的set()方法，或是使用中括號(hào){}
創(chuàng)建模板如下：

                    x = set()         
                    x = {, , ..., }

現(xiàn)在讓我們來(lái)看例子~

set()內(nèi)置方法創(chuàng)建

x = set(["foo", "bar", "baz", "foo", "qux"])   # 傳入List
print(x)

y = set(("foo", "bar", "baz", "foo", "qux"))   #傳入元組
print(y)

Out: {"qux", "foo", "bar", "baz"}  # 注意到無(wú)序了吧~
     {"bar", "qux", "baz", "foo"}
     

這里要注意用set()內(nèi)置方法創(chuàng)建時(shí)一定要傳遞一個(gè)可以迭代的參數(shù)，還有從輸出結(jié)果相信大家已經(jīng)發(fā)現(xiàn)set的第一個(gè)特點(diǎn)了：無(wú)序

字符串也是可迭代的，因此字符串也可以傳遞給set（）

s = "quux"
a = set(s)
print(a)

Out: {"u", "q", "x"}      # 無(wú)序，唯一

這里又體現(xiàn)了set的第二個(gè)特點(diǎn)：元素唯一性

{} 方法創(chuàng)建

>>> x = {"foo", "bar", "baz", "foo", "qux"}
>>> x
{"qux", "foo", "bar", "baz"}

這里考慮到之后例子太多，實(shí)在不能每次都打print啦，這種形式大家看的更清楚，這個(gè)直接用{}創(chuàng)建很簡(jiǎn)單，只要傳遞進(jìn)元素就行啦

創(chuàng)建空集合

Set可以是空的。但是，請(qǐng)記住Python將空花括號(hào){}解釋為空字典，因此定義空集的唯一方法是使用set（）函數(shù)

>>> x = set()
>>> type(x)


>>> x = {}
>>> type(x)

一個(gè)空集合用布爾類型顯示為False

>>> x = set()
>>> bool(x)
False
>>> x or 1
1
>>> x and 1
set()

對(duì)比小結(jié)

對(duì)于這兩種方法創(chuàng)建Set，本質(zhì)區(qū)別在于以下兩點(diǎn)

set（）的參數(shù)是可迭代的。它會(huì)生成要放入集合中的所有元素組成的List。

花括號(hào) {} 中的對(duì)象完整地放入集合中，即使它們是可迭代的。

補(bǔ)充說(shuō)明

集合中的元素可以是不同類型的對(duì)象，不一定非要是同一類型的，可以包含不同類型，比如：

>>> x = {42, "foo", 3.14159, None}
>>> x
{None, "foo", 42, 3.14159}

但同時(shí)不要忘記set元素必須是不可變的。例如，元組可以包括在集合中：

>>> x = {42, "foo", (1, 2, 3), 3.14159}
>>> x
{42, "foo", 3.14159, (1, 2, 3)}

但列表和字典是可變的，因此它們不能成為Set的元素：

>>> a = [1, 2, 3]
>>> {a}
Traceback (most recent call last):
  File "", line 1, in 
    {a}
TypeError: unhashable type: "list"


>>> d = {"a": 1, "b": 2}
>>> qoyqs8suu2u
Traceback (most recent call last):
  File "", line 1, in 
    qoyqs8suu2u
TypeError: unhashable type: "dict"

len（）函數(shù)返回集合中元素的數(shù)量，而in和not in運(yùn)算符可用于測(cè)試是否為Set中的元素：

>>> x = {"foo", "bar", "baz"}
>>> len(x)
3

>>> "bar" in x
True
>>> "qux" in x
False

方法和運(yùn)算符

許多可用于Python其他數(shù)據(jù)類型的操作對(duì)集合沒(méi)有意義。例如，無(wú)法對(duì)集合建立索引或切片。但是，Python在set對(duì)象上提供了運(yùn)算符，這些操作符其實(shí)很多和數(shù)學(xué)里是一模一樣的，相信數(shù)學(xué)好的朋友們對(duì)這部分簡(jiǎn)直不要太熟悉

所以對(duì)于Set的操作除了用普通的內(nèi)置方法，我們也可以使用運(yùn)算符，比較方便

Union 并集

用法：計(jì)算兩個(gè)或更多集合的并集。

方法: x1.union(x2[, x3 ...])

運(yùn)算符：x1 | x2 [| x3 ...]

讓我們新建兩個(gè)Set做測(cè)試：

>>> x1 = {"foo", "bar", "baz"}
>>> x2 = {"baz", "qux", "quux"}

現(xiàn)在我們想求x1,x2的并集，如下圖所示：

具體實(shí)現(xiàn)方法如下，或是用方法，或是用操作符：

>>> x1 = {"foo", "bar", "baz"}
>>> x2 = {"baz", "qux", "quux"}

>>> x1.union(x2)
{"foo", "qux", "quux", "baz", "bar"}

>>> x1 | x2
{"foo", "qux", "quux", "baz", "bar"}

如果有兩個(gè)以上的Set也是沒(méi)有問(wèn)題的，原理都是一樣的：

>>> a = {1, 2, 3, 4}
>>> b = {2, 3, 4, 5}
>>> c = {3, 4, 5, 6}
>>> d = {4, 5, 6, 7}

>>> a.union(b, c, d)
{1, 2, 3, 4, 5, 6, 7}

>>> a | b | c | d
{1, 2, 3, 4, 5, 6, 7}

Intersection 交集

方法: x1.intersection(x2[, x3 ...])

運(yùn)算符：x1 & x2 [& x3 ...]

用法：計(jì)算兩個(gè)或更多集合的交集。

現(xiàn)在還讓我們用剛才創(chuàng)建好的兩個(gè)set，所求部分如下圖：

實(shí)現(xiàn)仍然是兩種方法：

>>> x1 = {"foo", "bar", "baz"}
>>> x2 = {"baz", "qux", "quux"}

>>> x1.intersection(x2)
{"baz"}

>>> x1 & x2
{"baz"}

多個(gè)集合的情況公示和方法依然有效，結(jié)果僅包含所有指定集合中都存在的元素。

>>> a = {1, 2, 3, 4}
>>> b = {2, 3, 4, 5}
>>> c = {3, 4, 5, 6}
>>> d = {4, 5, 6, 7}

>>> a.intersection(b, c, d)
{4}

>>> a & b & c & d
{4}

Difference 差集

方法: x1.difference(x2[, x3 ...])

運(yùn)算符：x1 - x2 [- x3 ...]

用法：計(jì)算兩個(gè)或更多集合的差集。大白話說(shuō)就是x1去除x1和x2的共有元素

下圖所示為x1.difference(x2)的目標(biāo)結(jié)果：

>>> x1 = {"foo", "bar", "baz"}
>>> x2 = {"baz", "qux", "quux"}

>>> x1.difference(x2)
{"foo", "bar"}

>>> x1 - x2
{"foo", "bar"}

還是老樣子，適用于2個(gè)及以上的集合：

>>> a = {1, 2, 3, 30, 300}
>>> b = {10, 20, 30, 40}
>>> c = {100, 200, 300, 400}

>>> a.difference(b, c)
{1, 2, 3}

>>> a - b - c
{1, 2, 3}

指定多個(gè)集合時(shí)，操作從左到右執(zhí)行。在上面的示例中，首先計(jì)算a - b，得到{1,2,3,300}。然后從該集合中減去c，留下{1,2,3}，具體流程如下圖所示：

Symmetric Difference 對(duì)稱差集

方法: x1.symmetric_difference(x2)

運(yùn)算符：x1 ^ x2 ¹

用法：計(jì)算兩個(gè)或更多集合的差集。大白話說(shuō)就是x1去除x1和x2的共有元素

下圖所示為x1.symmetric_difference(x2)的目標(biāo)結(jié)果：

實(shí)現(xiàn)方法如下；

>>> x1 = {"foo", "bar", "baz"}
>>> x2 = {"baz", "qux", "quux"}

>>> x1.symmetric_difference(x2)
{"foo", "qux", "quux", "bar"}

>>> x1 ^ x2
{"foo", "qux", "quux", "bar"}

老規(guī)矩，支持2個(gè)及以上set的連續(xù)操作:

>>> a = {1, 2, 3, 4, 5}
>>> b = {10, 2, 3, 4, 50}
>>> c = {1, 50, 100}

>>> a ^ b ^ c
{100, 5, 10}

當(dāng)指定多個(gè)集合時(shí)，操作從左到右執(zhí)行,奇怪的是，雖然 ^ 運(yùn)算符允許多個(gè)集合，但.symmetric_difference（）方法不允許

>>> a = {1, 2, 3, 4, 5}
>>> b = {10, 2, 3, 4, 50}
>>> c = {1, 50, 100}

>>> a.symmetric_difference(b, c)
Traceback (most recent call last):
  File "", line 1, in 
    a.symmetric_difference(b, c)
TypeError: symmetric_difference() takes exactly one argument (2 given)

x1.isdisjoint(x2) 判斷是否相交

方法: x1.isdisjoint(x2)

用法：確定兩個(gè)集合是否具有任何共同的元素

>>> x1 = {"foo", "bar", "baz"}
>>> x2 = {"baz", "qux", "quux"}

>>> x1.isdisjoint(x2)
False

>>> x2 - {"baz"}
{"quux", "qux"}
>>> x1.isdisjoint(x2 - {"baz"})
True

從這個(gè)栗子可以看出，如果兩個(gè)Set沒(méi)有共同元素返回True，如果有返回True，如果返回True同時(shí)也意味著
他們之間的交集為空集，這個(gè)很好理解：

>>> x1 = {1, 3, 5}
>>> x2 = {2, 4, 6}

>>> x1.isdisjoint(x2)
True
>>> x1 & x2
set()

注意：目前還沒(méi)有運(yùn)算符對(duì)應(yīng)這個(gè)方法

x1.issubset(x2)   判斷x1是否為x2子集

方法: x1.issubset(x2)

運(yùn)算符：x1 <= x2

用法：如果返回True，x1為x2子集，反之返回False

>>> x1 = {"foo", "bar", "baz"}
>>> x1.issubset({"foo", "bar", "baz", "qux", "quux"})
True

>>> x2 = {"baz", "qux", "quux"}
>>> x1 <= x2
False

一個(gè)集合本身當(dāng)然是它自己的子集啦：

>>> x = {1, 2, 3, 4, 5}
>>> x.issubset(x)
True
>>> x <= x
True

x1

>>> x1 = {"foo", "bar"}
>>> x2 = {"foo", "bar", "baz"}
>>> x1 < x2
True

>>> x1 = {"foo", "bar", "baz"}
>>> x2 = {"foo", "bar", "baz"}
>>> x1 < x2
False

>>> x = {1, 2, 3, 4, 5}
>>> x <= x
True
>>> x < x
False

x1.issuperset(x2)  判斷x1是否為x2的超集

>>> x1 = {"foo", "bar", "baz"}

>>> x1.issuperset({"foo", "bar"})
True

>>> x2 = {"baz", "qux", "quux"}
>>> x1 >= x2
False

>>> x = {1, 2, 3, 4, 5}
>>> x.issuperset(x)
True
>>> x >= x
True

x1 > x2  判斷x1是否為x2的真超集

>>> x1 = {"foo", "bar", "baz"}
>>> x2 = {"foo", "bar"}
>>> x1 > x2
True

>>> x1 = {"foo", "bar", "baz"}
>>> x2 = {"foo", "bar", "baz"}
>>> x1 > x2
False

>>> x = {1, 2, 3, 4, 5}
>>> x > x
False

x1.update(x2) 通過(guò)union修改集合元素 

>>> x1 = {"foo", "bar", "baz"}
>>> x2 = {"foo", "baz", "qux"}

>>> x1 |= x2
>>> x1
{"qux", "foo", "bar", "baz"}

>>> x1.update(["corge", "garply"])
>>> x1
{"qux", "corge", "garply", "foo", "bar", "baz"}

x1.intersection(x2) 通過(guò)intersection修改集合元素 

>>> x1 = {"foo", "bar", "baz"}
>>> x2 = {"foo", "baz", "qux"}

>>> x1 &= x2
>>> x1
{"foo", "baz"}

>>> x1.intersection_update(["baz", "qux"])
>>> x1
{"baz"}

x1.difference_update(x2) 通過(guò)difference修改集合元素 

>>> x1 = {"foo", "bar", "baz"}
>>> x2 = {"foo", "baz", "qux"}

>>> x1 -= x2
>>> x1
{"bar"}

>>> x1.difference_update(["foo", "bar", "qux"])
>>> x1
set()

x1.symmetric_difference_update(x2) 通過(guò)對(duì)稱差集修改集合元素 

>>> x1 = {"foo", "bar", "baz"}
>>> x2 = {"foo", "baz", "qux"}
>>> 
>>> x1 ^= x2
>>> x1
{"bar", "qux"}
>>> 
>>> x1.symmetric_difference_update(["qux", "corge"])
>>> x1
{"bar", "corge"}

x.add( 添加元素

>>> x = {"foo", "bar", "baz"}
>>> x.add("qux")
>>> x
{"bar", "baz", "foo", "qux"}

x.remove() 刪除元素

>>> x = {"foo", "bar", "baz"}

>>> x.remove("baz")
>>> x
{"bar", "foo"}

>>> x.remove("qux")
Traceback (most recent call last):
  File "", line 1, in 
    x.remove("qux")
KeyError: "qux"

>>> x = {"foo", "bar", "baz"}

>>> x.discard("baz")
>>> x
{"bar", "foo"}

>>> x.discard("qux")
>>> x
{"bar", "foo"}

>>> x = {"foo", "bar", "baz"}

>>> x.pop()
"bar"
>>> x
{"baz", "foo"}

>>> x.pop()
"baz"
>>> x
{"foo"}

>>> x.pop()
"foo"
>>> x
set()

>>> x = {"foo", "bar", "baz"}
>>> x
{"foo", "bar", "baz"}
>>> 
>>> x.clear()
>>> x
set()

Frozen Sets是什么東西

>>> x = frozenset(["foo", "bar", "baz"])
>>> x
frozenset({"foo", "baz", "bar"})

>>> len(x)
3

>>> x & {"baz", "qux", "quux"}
frozenset({"baz"})

>>> x = frozenset(["foo", "bar", "baz"])

>>> x.add("qux")
Traceback (most recent call last):
  File "", line 1, in 
    x.add("qux")
AttributeError: "frozenset" object has no attribute "add"

>>> x.pop()
Traceback (most recent call last):
  File "", line 1, in 
    x.pop()
AttributeError: "frozenset" object has no attribute "pop"

>>> x.clear()
Traceback (most recent call last):
  File "", line 1, in 
    x.clear()
AttributeError: "frozenset" object has no attribute "clear"

>>> x
frozenset({"foo", "bar", "baz"})

基本使用舉例

>>> x1 = set(["foo"])
>>> x2 = set(["bar"])
>>> x3 = set(["baz"])
>>> x = {x1, x2, x3}
Traceback (most recent call last):
  File "", line 1, in 
    x = {x1, x2, x3}
TypeError: unhashable type: "set"

>>> x1 = frozenset(["foo"])
>>> x2 = frozenset(["bar"])
>>> x3 = frozenset(["baz"])
>>> x = {x1, x2, x3}
>>> x
{frozenset({"bar"}), frozenset({"baz"}), frozenset({"foo"})}