摘要：目前有兩種內置集合類型，和。兩個類的構造器具有相同的作用方式返回一個新的或對象，其元素來自于。要表示由集合對象構成的集合，所有的內層集合必須為對象。目前僅有一種標準映射類型字典。

上一篇文章：Python標準庫---14、內置類型：二進制序列類型 (memoryview)
下一篇文章：Python標準庫---16、內置類型：上下文管理器類型、其他、特殊屬性

set 對象是由具有唯一性的 hashable 對象所組成的無序多項集。 常見的用途包括成員檢測、從序列中去除重復項以及數學中的集合類計算，例如交集、并集、差集與對稱差集等等。 （關于其他容器對象請參看 dict, list 與 tuple 等內置類，以及 collections 模塊。）

與其他多項集一樣，集合也支持 x in set, len(set) 和 for x in set。 作為一種無序的多項集，集合并不記錄元素位置或插入順序。 相應地，集合不支持索引、切片或其他序列類的操作。

目前有兩種內置集合類型，set 和 frozenset。 set 類型是可變的 --- 其內容可以使用 add() 和 remove() 這樣的方法來改變。 由于是可變類型，它沒有哈希值，且不能被用作字典的鍵或其他集合的元素。 frozenset 類型是不可變并且為 hashable --- 其內容在被創建后不能再改變；因此它可以被用作字典的鍵或其他集合的元素。

除了可以使用 set 構造器，非空的 set (不是 frozenset) 還可以通過將以逗號分隔的元素列表包含于花括號之內來創建，例如: {"jack", "sjoerd"}。

兩個類的構造器具有相同的作用方式：

返回一個新的 set 或 frozenset 對象，其元素來自于 iterable。 集合的元素必須為 hashable。 要表示由集合對象構成的集合，所有的內層集合必須為 frozenset 對象。 如果未指定 iterable，則將返回一個新的空集合。

set 和 frozenset 的實例提供以下操作：

    返回集合 s 中的元素數量（即 s 的基數）。

### x in s

    檢測 x 是否為 s 中的成員。

### x not in s

    檢測 x 是否非 s 中的成員。

### isdisjoint(other)

    如果集合中沒有與 other 共有的元素則返回 True。 當且僅當兩個集合的交集為空集合時，兩者為不相交集合。

    檢測是否集合中的每個元素都在 other 之中。

### set < other

    檢測集合是否為 other 的真子集，即 set <= other and set != other。

    檢測是否 other 中的每個元素都在集合之中。

### set > other

    檢測集合是否為 other 的真超集，即 set >= other and set != other。

    返回一個新集合，其中包含來自原集合以及 others 指定的所有集合中的元素。

    返回一個新集合，其中包含原集合以及 others 指定的所有集合中共有的元素。

### difference(*others)
### set - other - ...

    返回一個新集合，其中包含原集合中在 others 指定的其他集合中不存在的元素。

### symmetric_difference(other)
### set ^ other

    返回一個新集合，其中的元素或屬于原集合或屬于 other 指定的其他集合，但不能同時屬于兩者。

    返回原集合的淺拷貝。

請注意，非運算符版本的 union(), intersection(), difference()，以及 symmetric_difference(), issubset() 和 issuperset() 方法會接受任意可迭代對象作為參數。 相比之下，它們所對應的運算符版本則要求其參數為集合。 這就排除了容易出錯的構造形式例如 set("abc") & "cbs"，而推薦可讀性更強的 set("abc").intersection("cbs")。

set 和 frozenset 均支持集合與集合的比較。 兩個集合當且僅當每個集合中的每個元素均包含于另一個集合之內（即各為對方的子集）時則相等。 一個集合當且僅當其為另一個集合的真子集（即為后者的子集但兩者不相等）時則小于另一個集合。 一個集合當且僅當其為另一個集合的真超集（即為后者的超集但兩者不相等）時則大于另一個集合。

set 的實例與 frozenset 的實例之間基于它們的成員進行比較。 例如 set("abc") == frozenset("abc") 返回 True，set("abc") in set([frozenset("abc")]) 也一樣。

子集與相等比較并不能推廣為完全排序函數。 例如，任意兩個非空且不相交的集合不相等且互不為對方的子集，因此以下 所有 比較均返回 False: ab。

由于集合僅定義了部分排序（子集關系），因此由集合構成的列表 list.sort() 方法的輸出并無定義。

集合的元素，與字典的鍵類似，必須為 hashable。

混合了 set 實例與 frozenset 的二進制位運算將返回與第一個操作數相同的類型。例如: frozenset("ab") | set("bc") 將返回 frozenset 的實例。

下表列出了可用于 set 而不能用于不可變的 frozenset 實例的操作：

    更新集合，添加來自 others 中的所有元素。

    更新集合，只保留其中在所有 others 中也存在的元素。

### set -= other | ...

    更新集合，移除其中也存在于 others 中的元素。

### symmetric_difference_update(other)
### set ^= other

    更新集合，只保留存在于集合的一方而非共同存在的元素。

    將元素 elem 添加到集合中。

### remove(elem)

    從集合中移除元素 elem。 如果 elem 不存在于集合中則會引發 KeyError。

### discard(elem)

    如果元素 elem 存在于集合中則將其移除。

    從集合中移除并返回任意一個元素。 如果集合為空則會引發 KeyError。

### clear()

    從集合中移除所有元素。

請注意，非運算符版本的 update(), intersection_update(), difference_update() 和 symmetric_difference_update() 方法將接受任意可迭代對象作為參數。

請注意，__contains__(), remove() 和 discard() 方法的 elem 參數可能是一個 set。 為支持對一個等價的 frozenset 進行搜索，會根據 elem 臨時創建一個該類型對象。

mapping 對象會將 hashable 值映射到任意對象。 映射屬于可變對象。 目前僅有一種標準映射類型 字典。 （關于其他容器對象請參看 list, set 與 tuple 等內置類，以及 collections 模塊。）

字典的鍵 幾乎 可以是任何值。 非 hashable 的值，即包含列表、字典或其他可變類型的值（此類對象基于值而非對象標識進行比較）不可用作鍵。 數字類型用作鍵時遵循數字比較的一般規則：如果兩個數值相等 (例如 1 和 1.0) 則兩者可以被用來索引同一字典條目。 （但是請注意，由于計算機對于浮點數存儲的只是近似值，因此將其用作字典鍵是不明智的。）

字典可以通過將以逗號分隔的 鍵: 值 對列表包含于花括號之內來創建，例如: {"jack": 4098, "sjoerd": 4127} 或 {4098: "jack", 4127: "sjoerd"}，也可以通過 dict 構造器來創建。

返回一個新的字典，基于可選的位置參數和可能為空的關鍵字參數集來初始化。

如果沒有給出位置參數，將創建一個空字典。 如果給出一個位置參數并且其屬于映射對象，將創建一個具有與映射對象相同鍵值對的字典。 否則的話，位置參數必須為一個 iterable 對象。 該可迭代對象中的每一項本身必須為一個剛好包含兩個元素的可迭代對象。 每一項中的第一個對象將成為新字典的一個鍵，第二個對象將成為其對應的值。 如果一個鍵出現一次以上，該鍵的最后一個值將成為其在新字典中對應的值。

如果給出了關鍵字參數，則關鍵字參數及其值會被加入到基于位置參數創建的字典。 如果要加入的鍵已存在，來自關鍵字參數的值將替代來自位置參數的值。

作為演示，以下示例返回的字典均等于 {"one": 1, "two": 2, "three": 3}:

    >>> a = dict(one=1, two=2, three=3)
    >>> b = {"one": 1, "two": 2, "three": 3}
    >>> c = dict(zip(["one", "two", "three"], [1, 2, 3]))
    >>> d = dict([("two", 2), ("one", 1), ("three", 3)])
    >>> e = dict({"three": 3, "one": 1, "two": 2})
    >>> a == b == c == d == e
    True

像第一個例子那樣提供關鍵字參數的方式只能使用有效的 Python 標識符作為鍵。 其他方式則可使用任何有效的鍵。

這些是字典所支持的操作（因而自定義的映射類型也應當支持）：

    返回字典 d 中的項數。

    返回 d 中以 key 為鍵的項。 如果映射中不存在 key 則會引發 KeyError。

    如果字典的子類定義了方法 __missing__() 并且 key 不存在，則 d[key] 操作將調用該方法并附帶鍵 key 作為參數。 d[key] 隨后將返回或引發 __missing__(key) 調用所返回或引發的任何對象或異常。 沒有其他操作或方法會發起調用 __missing__()。 如果未定義 __missing__()，則會引發 KeyError。 __missing__() 必須是一個方法；它不能是一個實例變量:

        >>> class Counter(dict):
        ...     def __missing__(self, key):
        ...         return 0
        >>> c = Counter()
        >>> c["red"]
        0
        >>> c["red"] += 1
        >>> c["red"]
        1

    上面的例子顯示了 collections.Counter 實現的部分代碼。 還有另一個不同的 __missing__ 方法是由 collections.defaultdict 所使用的。

    將 d[key] 設為 value。

    將 d[key] 從 d 中移除。 如果映射中不存在 key 則會引發 KeyError。

    如果 d 中存在鍵 key 則返回 True，否則返回 False。

    等價于 not key in d。

    返回以字典的鍵為元素的迭代器。 這是 iter(d.keys()) 的快捷方式。

    移除字典中的所有元素。

### copy()

    返回原字典的淺拷貝。

### classmethod fromkeys(iterable[, value])

    使用來自 iterable 的鍵創建一個新字典，并將鍵值設為 value。

    fromkeys() 屬于類方法，會返回一個新字典。 value 默認為 None。

    如果 key 存在于字典中則返回 key 的值，否則返回 default。 如果 default 未給出則默認為 None，因而此方法絕不會引發 KeyError。

### items()

    返回由字典項 ((鍵, 值) 對) 組成的一個新視圖。 參見 視圖對象文檔。

    返回由字典鍵組成的一個新視圖。 參見 視圖對象文檔。

    如果 key 存在于字典中則將其移除并返回其值，否則返回 default。 如果 default 未給出且 key 不存在于字典中，則會引發 KeyError。

    從字典中移除并返回一個 (鍵, 值) 對。 鍵值對會按 LIFO 的順序被返回。

    popitem() 適用于對字典進行消耗性的迭代，這在集合算法中經常被使用。 如果字典為空，調用 popitem() 將引發 KeyError。

    在 3.7 版更改: 現在會確保采用 LIFO 順序。 在之前的版本中，popitem() 會返回一個任意的鍵/值對。

    如果字典存在鍵 key ，返回它的值。如果不存在，插入值為 default 的鍵 key ，并返回 default 。 default 默認為 None。

    使用來自 other 的鍵/值對更新字典，覆蓋原有的鍵。 返回 None。

    update() 接受另一個字典對象，或者一個包含鍵/值對（以長度為二的元組或其他可迭代對象表示）的可迭代對象。 如果給出了關鍵字參數，則會以其所指定的鍵/值對更新字典: d.update(red=1, blue=2)。

    返回由字典值組成的一個新視圖。 參見 視圖對象文檔。

兩個字典的比較當且僅當具有相同的 (鍵, 值) 對時才會相等。 順序比較 ("<", "<=", ">=", ">") 會引發 TypeError。

字典會保留插入時的順序。 請注意對鍵的更新不會影響順序。 刪除并再次添加的鍵將被插入到末尾。

    >>> d = {"one": 1, "two": 2, "three": 3, "four": 4}
    >>> d
    {"one": 1, "two": 2, "three": 3, "four": 4}
    >>> list(d)
    ["one", "two", "three", "four"]
    >>> list(d.values())
    [1, 2, 3, 4]
    >>> d["one"] = 42
    >>> d
    {"one": 42, "two": 2, "three": 3, "four": 4}
    >>> del d["two"]
    >>> d["two"] = None
    >>> d
    {"one": 42, "three": 3, "four": 4, "two": None}

在 3.7 版更改: 字典順序會確保為插入順序。 此行為是自 3.6 版開始的 CPython 實現細節。

參見

types.MappingProxyType 可被用來創建一個 dict 的只讀視圖。

由 dict.keys(), dict.values() 和 dict.items() 所返回的對象是 視圖對象。 該對象提供字典條目的一個動態視圖，這意味著當字典改變時，視圖也會相應改變。

字典視圖可以被迭代以產生與其對應的數據，并支持成員檢測：

返回字典中的條目數。

返回字典中的鍵、值或項（以 (鍵, 值) 為元素的元組表示）的迭代器。

鍵和值是按插入時的順序進行迭代的。 這樣就允許使用 zip() 來創建 (值, 鍵) 對: pairs = zip(d.values(), d.keys())。 另一個創建相同列表的方式是 pairs = [(v, k) for (k, v) in d.items()].

在添加或刪除字典中的條目期間對視圖進行迭代可能引發 RuntimeError 或者無法完全迭代所有條目。

在 3.7 版更改: 字典順序會確保為插入順序。

如果 x 是對應字典中存在的鍵、值或項（在最后一種情況下 x 應為一個 (鍵, 值) 元組） 則返回 True。

鍵視圖類似于集合，因為其條目不重復且可哈希。 如果所有值都是可哈希的，即 (鍵, 值) 對也是不重復且可哈希的，那么條目視圖也會類似于集合。 （值視圖則不被視為類似于集合，因其條目通常都是有重復的。） 對于類似于集合的視圖，為抽象基類 collections.abc.Set 所定義的全部操作都是有效的 (例如 ==, < 或 ^)。

一個使用字典視圖的示例:

>>>

>>> dishes = {"eggs": 2, "sausage": 1, "bacon": 1, "spam": 500}
>>> keys = dishes.keys()
>>> values = dishes.values()

>>> # iteration
>>> n = 0
>>> for val in values:
...     n += val
>>> print(n)
504

>>> # keys and values are iterated over in the same order (insertion order)
>>> list(keys)
["eggs", "sausage", "bacon", "spam"]
>>> list(values)
[2, 1, 1, 500]

>>> # view objects are dynamic and reflect dict changes
>>> del dishes["eggs"]
>>> del dishes["sausage"]
>>> list(keys)
["bacon", "spam"]

>>> # set operations
>>> keys & {"eggs", "bacon", "salad"}
{"bacon"}
>>> keys ^ {"sausage", "juice"}
{"juice", "sausage", "bacon", "spam"}

上一篇文章：Python標準庫---14、內置類型：二進制序列類型 (memoryview)
下一篇文章：Python標準庫---16、內置類型：上下文管理器類型、其他、特殊屬性