如何从单独的键和值列表中创建字典？

喜欢这个：

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

瞧：-）成对字典构造函数和zip函数非常有用。

想象一下，您有：

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

生成以下字典的最简单方法是什么？

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

性能最高的构造函数dictzip

new_dict = dict(zip(keys, values))

在Python 3中，zip现在返回一个惰性迭代器，这是现在性能最高的方法。

dict(zip(keys, values))确实需要对 和 进行一次性全局查找，但它不会形成任何不必要的中间数据结构，也不必在函数应用程序中处理本地查找。dictzip

亚军，词典理解：

使用dict构造函数的一个最接近的方法是使用dict理解的本机语法（而不是列表理解，因为其他人错误地将其解释为）：

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

当您需要根据键或值进行映射或筛选时，请选择此选项。

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

from itertools import izip as zip

所以那仍然是（2.7）：

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

Python 2，非常适合<= 2.6

izip从成为在 Python 3 中。 对于Python 2来说，它比zip更好（因为它避免了不必要的列表创建），并且非常适合2.6或更低版本：itertoolszipizip

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似乎是比较性能的不良方法。当然和/或将是实际使用的更有用的指标。meanmax

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

如果操作系统因任何原因挂起，则与我们尝试比较的内容无关，因此我们需要从分析中排除这些类型的结果。

如果我们使用 ，这些类型的事件会极大地扭曲我们的结果，如果我们使用，我们只会得到最极端的结果 - 最有可能受到此类事件影响的结果。meanmax

一位评论者还说：

在python 3.6.8中，使用平均值，字典理解确实更快，对于这些小列表，大约30%。对于较大的列表（10k 个随机数），调用速度大约快 10%。dict

我假设我们的意思是10k个随机数。这听起来像是一个相当不寻常的用例。在大型数据集中，最直接的调用将占主导地位，这确实是有道理的，如果操作系统挂起占主导地位，考虑到运行该测试需要多长时间，我会感到惊讶，这会进一步扭曲你的数字。如果你使用或我会认为你的结果毫无意义。dict(zip(...meanmax

让我们在主要示例中使用更实际的大小：

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

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

>>> 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