Python標準庫---1五、內置類型：集合類型、映射類型

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

集合類型 --- set, frozenset

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'}。

兩個類的構造器具備相同的做用方式：

class set([iterable])

class frozenset([iterable])

返回一個新的 set 或 frozenset 對象，其元素來自於 iterable。 集合的元素必須爲 hashable。 要表示由集合對象構成的集合，全部的內層集合必須爲 frozenset 對象。 若是未指定 iterable，則將返回一個新的空集合。

set 和 frozenset 的實例提供如下操做：

len(s)

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

### x in s

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

### x not in s

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

### isdisjoint(other)

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

issubset(other)

set <= other

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

### set < other

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

issuperset(other)

set >= other

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

### set > other

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

union(*others)

set | other | ...

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

intersection(*others)

set & other & ...

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

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

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

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

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

copy()

返回原集合的淺拷貝。

請注意，非運算符版本的 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: a<b, a==b, or a>b。

因爲集合僅定義了部分排序（子集關係），所以由集合構成的列表 list.sort() 方法的輸出並沒有定義。

集合的元素，與字典的鍵相似，必須爲 hashable。

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

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

update(*others)

set |= other | ...

更新集合，添加來自 others 中的全部元素。

intersection_update(*others)

set &= other & ...

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

difference_update(*others)

### set -= other | ...

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

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

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

add(elem)

將元素 elem 添加到集合中。

### remove(elem)

從集合中移除元素 elem。 若是 elem 不存在於集合中則會引起 KeyError。

### discard(elem)

若是元素 elem 存在於集合中則將其移除。

pop()

從集合中移除並返回任意一個元素。 若是集合爲空則會引起 KeyError。

### clear()

從集合中移除全部元素。

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

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

映射類型 --- dict

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

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

字典能夠經過將以逗號分隔的 鍵: 值 對列表包含於花括號以內來建立，例如: {'jack': 4098, 'sjoerd': 4127} 或 {4098: 'jack', 4127: 'sjoerd'}，也能夠經過 dict 構造器來建立。

class dict(**kwarg)

class dict(mapping, **kwarg)

class dict(iterable, **kwarg)

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

若是沒有給出位置參數，將建立一個空字典。 若是給出一個位置參數而且其屬於映射對象，將建立一個具備與映射對象相同鍵值對的字典。 不然的話，位置參數必須爲一個 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 標識符做爲鍵。 其餘方式則可以使用任何有效的鍵。

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

len(d)

返回字典 d 中的項數。

d[key]

返回 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] 設爲 value。

del d[key]

將 d[key] 從 d 中移除。 若是映射中不存在 key 則會引起 KeyError。

key in d

若是 d 中存在鍵 key 則返回 True，不然返回 False。

key not in d

等價於 not key in d。

iter(d)

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

clear()

移除字典中的全部元素。

### copy()

返回原字典的淺拷貝。

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

使用來自 iterable 的鍵建立一個新字典，並將鍵值設爲 value。

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

get(key[, default])

若是 key 存在於字典中則返回 key 的值，不然返回 default。 若是 default 未給出則默認爲 None，於是此方法毫不會引起 KeyError。

### items()

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

keys()

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

pop(key[, default])

若是 key 存在於字典中則將其移除並返回其值，不然返回 default。 若是 default 未給出且 key 不存在於字典中，則會引起 KeyError。

popitem()

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

    popitem() 適用於對字典進行消耗性的迭代，這在集合算法中常常被使用。 若是字典爲空，調用 popitem() 將引起 KeyError。

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

setdefault(key[, default])

若是字典存在鍵 key ，返回它的值。若是不存在，插入值爲 default 的鍵 key ，並返回 default 。 default 默認爲 None。

update([other])

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

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

values()

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

兩個字典的比較當且僅當具備相同的 (鍵, 值) 對時纔會相等。 順序比較 ('<', '<=', '>=', '>') 會引起 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() 所返回的對象是 視圖對象。 該對象提供字典條目的一個動態視圖，這意味着當字典改變時，視圖也會相應改變。

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

len(dictview)

返回字典中的條目數。

iter(dictview)

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

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

在添加或刪除字典中的條目期間對視圖進行迭代可能引起 RuntimeError 或者沒法徹底迭代全部條目。

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

x in dictview

若是 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標準庫---1四、內置類型：二進制序列類型 (memoryview)
下一篇文章： Python標準庫---1六、內置類型：上下文管理器類型、其餘、特殊屬性