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六、内置类型：上下文管理器类型、其余、特殊属性