Python 3.7.1 数据类型 字典 dict

1. 定义

一个映射对象映射可哈希值到任意对象。映射是可变对象。目前只有一种标准的映射类型，即字典。（对于其它容器见内置的 list，set 和tuple类 和 collections模块）。

字典的键几乎是任意值。不可哈希的值，即包含列表，字典或其他可变类型（通过值而不是通过对象标识进行比较）的值不能用作键。用于键的数字类型遵循用于数字比较的常规规则：如果两个数字比较相等（例如1和1.0），则它们可以互换地用于索引相同的字典条目。（但请注意，由于计算机将浮点数存储为近似值，因此将它们用作字典键通常是不明智的。）

可以通过 在大括号中放置以逗号分隔的key: value对列表来创建字典，例如：{'jack': 4098, 'sjoerd': 4127}或{4098: 'jack', 4127: 'sjoerd'}，或由dict构造函数。

2. 类

class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)

返回一个新的字典，从可选的位置参数和可能为空的关键字参数集初始化而来。

如果没有给出位置参数，则创建一个空字典。如果给出位置参数并且它是映射对象，则创建具有与映射对象相同的键 - 值对的字典。否则，位置参数必须是可迭代（iterable）对象。iterable中的每个项目本身都必须是具有两个对象的可迭代项。每个项目的第一个对象成为新词典中的一个键，第二个对象成为相应的值。如果某个键出现多次，则该键的最后一个值将成为新字典中的相应值。

如果给出了关键字参数，则将关键字参数及其值添加到从位置参数创建的字典中。如果已添加的键已存在，则keyword参数中的值将替换位置参数中的值。

为了说明，以下示例都返回一个等于{"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标识符的键。

3. 方法

这些是字典支持的操作（因此，自定义映射类型也应该支持这些）：

len(d)

返回字典中的项目数d。

d[key]

返回key对应的值。key不在字典中引发KeyError。

如果dict的子类定义了方法__missing__()并且键 不存在，d[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 的部分实现 。使用和collections.defaultdict不同的__missing__方法。

d[key] = value

设置d[key]为值。

del d[key]

从d中删除key和对应的值。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（seq [，value ] ）

使用seq中的键创建一个新字典，并将值设置为value。

fromkeys()是一个返回新字典的类方法。value 默认为None。

get(key[, default])

如果key在字典中，则返回key的值，否则返回default。如果未给出default，则默认为None，因此此方法永远不会引发KeyError。

items()

返回字典项目（(key, value)对）的新视图。请参阅视图对象的文档。

keys()

返回字典键的新视图。请参阅视图对象的文档。

pop(key[, default])

如果key在字典中，则将其删除并返回其值，否则返回 default。如果未给出default并且key不在字典中，则引发KeyError。

popitem()

从字典中删除并返回一个(key, value)对。对以LIFO（后进先出）顺序弹出。
popitem()对于在字典中进行破坏性迭代很有用，就像在集合算法中经常使用的那样。如果字典为空，则调用 popitem()会引发 KeyError。

在版本3.7中更改：现在保证LIFO顺序。在先前版本中，popitem()将返回任意键/值对。

setdefault(key[, default])

如果key在字典中，则返回其对应的值。如果不在，插入key ，值为default和返回default。 default默认为 None。

update([other])

更新来自other中的键/值对字典，覆盖现有的key。返回None。

update()接受另一个字典对象或可迭代的键/值对（比如元组或长度为2的可迭代对象）。如果指定了关键字参数，则使用这些键/值对更新字典：d.update(red=1, blue=2)。

values()

返回字典值的新视图。请参阅视图对象的 文档。

当且仅当它们具有相同的(key, value)对时，字典才会相等。顺序比较（'<'，'<='，'> ='，'>'）引发TypeError 。

字典保留了插入顺序。请注意，更新key不会影响顺序。删除后添加的键最后插入。

>>>
>>> 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的只读视图。

4. 字典视图对象

dict.keys()，dict.values()和 dict.items()返回的是视图对象。它们提供字典条目的动态视图，这意味着当字典更改时，视图会反映这些更改。

字典视图可以迭代生成各自的数据，并支持成员测试：

len(dictview)

返回字典中的条目数。

iter(dictview)

在字典中的键，值或项目（表示为(key, value)元组）上返回一个迭代器 。

键和值按插入顺序可迭代。这允许使用zip()方式创建(key, value)对：pairs = zip(d.values(), d.keys())创建相同列表的另一种方法是pairs = [(v, k) for (k, v) in d.items()]。

在字典中添加或删除条目时迭代视图可能会引发RuntimeError或不能遍历所有条目。

版本3.7中已更改：字典顺序保证为插入顺序。

x in dictview

如果X是在底层的字典的键，值或项（在后一种情况下，X应是一个(key, value)元组）返回True。

key视图类似set，因为它们的条目是唯一且可哈希的。如果所有值都是可哈希的，那么(key, value)对是唯一且可哈希的，那么items视图也类似于set。（因为条目通常不是唯一的所以values视图不被视为类似set）。对于类似set的视图，所有在抽象基类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'}