从单独的键值列表创建字典

Question

我想把这些内容合并在一起：

keys = ['name', 'age', 'food']
values = ['Monty', 42, 'spam']

变成一个完整的字典：

{'name': 'Monty', 'age': 42, 'food': 'spam'}

我该怎么做呢？

Answer 1

试试这个：

>>> import itertools
>>> keys = ('name', 'age', 'food')
>>> values = ('Monty', 42, 'spam')
>>> adict = dict(itertools.izip(keys,values))
>>> adict
{'food': 'spam', 'age': 42, 'name': 'Monty'}

在Python 2中，这种方法在内存使用上比zip更节省。

Answer 2

new_dict = dict(zip(keys, values))

假设你有：

keys = ('name', 'age', 'food')
values = ('Monty', 42, 'spam')

有什么简单的方法可以生成下面这个字典吗？

dict = {'name' : 'Monty', 'age' : 42, 'food' : 'spam'}

最有效的方式，使用 dict 构造函数和 zip

在 Python 3 中，zip 现在返回一个懒惰的迭代器，这种方法是最有效的。

dict(zip(keys, values)) 需要一次性全局查找 dict 和 zip，但它不会创建任何不必要的中间数据结构，也不需要处理函数应用中的局部查找。

次优选择，字典推导式：

使用字典构造函数的一个接近选择是使用字典推导式的原生语法（而不是 列表 推导式，很多人搞错了）：

new_dict = {k: v for k, v in zip(keys, values)}

当你需要根据键或值进行映射或过滤时，选择这个方法。

在 Python 2 中，zip 返回一个列表，为了避免创建不必要的列表，可以使用 izip（在迁移到 Python 3 时，将其别名为 zip 可以减少代码更改）。

from itertools import izip as zip

所以在 (2.7) 中仍然是：

new_dict = {k: v for k, v in zip(keys, values)}

Python 2，适合 <= 2.6

izip 来自 itertools 在 Python 3 中变成了 zip。izip 在 Python 2 中比 zip 更好（因为它避免了不必要的列表创建），非常适合 2.6 或更早的版本：

from itertools import izip
new_dict = dict(izip(keys, values))

所有情况下的结果：

在所有情况下：

>>> new_dict
{'age': 42, 'name': 'Monty', 'food': 'spam'}

解释：

如果我们查看 dict 的帮助文档，会发现它可以接受多种形式的参数：

>>> help(dict)

class dict(object)
 |  dict() -> new empty dictionary
 |  dict(mapping) -> new dictionary initialized from a mapping object's
 |      (key, value) pairs
 |  dict(iterable) -> new dictionary initialized as if via:
 |      d = {}
 |      for k, v in iterable:
 |          d[k] = v
 |  dict(**kwargs) -> new dictionary initialized with the name=value pairs
 |      in the keyword argument list.  For example:  dict(one=1, two=2)

最佳的方法是使用可迭代对象，同时避免创建不必要的数据结构。在 Python 2 中，zip 会创建一个不必要的列表：

>>> zip(keys, values)
[('name', 'Monty'), ('age', 42), ('food', 'spam')]

在 Python 3 中，相应的做法是：

>>> list(zip(keys, values))
[('name', 'Monty'), ('age', 42), ('food', 'spam')]

而 Python 3 的 zip 仅仅创建一个可迭代对象：

>>> zip(keys, values)
<zip object at 0x7f0e2ad029c8>

因为我们想避免创建不必要的数据结构，所以通常希望避免使用 Python 2 的 zip（因为它会创建一个不必要的列表）。

性能较差的替代方案：

这是一个生成器表达式被传递给字典构造函数：

generator_expression = ((k, v) for k, v in zip(keys, values))
dict(generator_expression)

或者等效的：

dict((k, v) for k, v in zip(keys, values))

这是一个列表推导式被传递给字典构造函数：

dict([(k, v) for k, v in zip(keys, values)])

在前两种情况下，zip 可迭代对象上多了一层不必要的计算，而在列表推导式的情况下，又多创建了一个不必要的列表。我预计它们的性能都会较差，肯定不会更好。

性能评估：

在 Nix 提供的 64 位 Python 3.8.2 上，运行在 Ubuntu 16.04 中，从快到慢排序：

>>> min(timeit.repeat(lambda: dict(zip(keys, values))))
0.6695233230129816
>>> min(timeit.repeat(lambda: {k: v for k, v in zip(keys, values)}))
0.6941362579818815
>>> min(timeit.repeat(lambda: {keys[i]: values[i] for i in range(len(keys))}))
0.8782548159942962
>>> 
>>> min(timeit.repeat(lambda: dict([(k, v) for k, v in zip(keys, values)])))
1.077607496001292
>>> min(timeit.repeat(lambda: dict((k, v) for k, v in zip(keys, values))))
1.1840861019445583

dict(zip(keys, values)) 即使在小的键值集合中也表现最好，但对于更大的集合，性能差异会更明显。

有位评论者说：

min 似乎不是比较性能的好方法。显然 mean 和/或 max 会是更有用的指标。

我们使用 min 是因为这些算法是确定性的。我们想知道在最佳条件下算法的性能。

如果操作系统因为某种原因挂起了，这与我们要比较的内容无关，所以我们需要将这类结果排除在分析之外。

如果我们使用 mean，这些事件会严重影响我们的结果，而如果使用 max，我们只会得到最极端的结果——最有可能受到这种事件影响的结果。

还有位评论者说：

在 Python 3.6.8 中，使用平均值，字典推导式确实仍然更快，大约快 30% 对于这些小列表。对于更大的列表（10k 个随机数），dict 调用大约快 10%。

我想我们指的是 dict(zip(... 和 10k 个随机数。这听起来确实是一个相当不寻常的用例。对于大数据集，最直接的调用占主导地位是有道理的，我不会感到惊讶如果操作系统挂起影响了测试的时间，进一步扭曲了你的数字。如果你使用 mean 或 max，我认为你的结果是没有意义的。

让我们在我们的顶级示例中使用一个更现实的大小：

import numpy
import timeit
l1 = list(numpy.random.random(100))
l2 = list(numpy.random.random(100))

我们在这里看到，dict(zip(... 确实在更大的数据集上运行得更快，大约快 20%。

>>> min(timeit.repeat(lambda: {k: v for k, v in zip(l1, l2)}))
9.698965263989521
>>> min(timeit.repeat(lambda: dict(zip(l1, l2))))
7.9965161079890095

Answer 3

像这样：

keys = ['a', 'b', 'c']
values = [1, 2, 3]
dictionary = dict(zip(keys, values))
print(dictionary) # {'a': 1, 'b': 2, 'c': 3}

太棒了 :-) 使用成对的 dict 构造器和 zip 函数非常有用。