映射类型 dict
- 1. 定义
- 2. 类
- 3. 方法
-
- len(d)
- d[key]
- d[key] = value
- del d[key]
- key in d
- key not in d
- iter(d)
- clear()
- copy()
- classmethod fromkeys（seq [，value ] ）
- get(key[, default])
- items()
- keys()
- pop(key[, default])
- popitem()
- setdefault(key[, default])
- update([other])
- values()
- 4. 字典视图对象
-
- len(dictview)
- iter(dictview)
- x in dictview
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'}