想象一下，您有以下列表。
keys = ['name', 'age', 'food']
values = ['Monty', 42, 'spam']
生成以下字典的最简单方法是什么？
a_dict = {'name': 'Monty', 'age': 42, 'food': 'spam'}
Guido García
问问题
1101296 次
18 回答
196
想象一下，你有：
keys = ('name', 'age', 'food') values = ('Monty', 42, 'spam')生成以下字典的最简单方法是什么？
dict = {'name' : 'Monty', 'age' : 42, 'food' : 'spam'}
性能最高的dict构造函数zip
new_dict = dict(zip(keys, values))
在 Python 3 中， zip 现在返回一个惰性迭代器，这是现在性能最高的方法。
dict(zip(keys, values))dict确实需要对和进行一次全局查找zip，但它不会形成任何不必要的中间数据结构，也不必处理函数应用程序中的本地查找。
亚军，听写理解：
使用 dict 构造函数的一个接近的亚军是使用 dict 推导式的本机语法（不是列表推导式，因为其他人错误地把它）：
new_dict = {k: v for k, v in zip(keys, values)}
当您需要根据键或值进行映射或过滤时选择此项。
在 Python 2 中，zip返回一个列表，为避免创建不必要的列表，请izip改为使用（别名为 zip 可以在您迁移到 Python 3 时减少代码更改）。
from itertools import izip as zip
所以仍然是（2.7）：
new_dict = {k: v for k, v in zip(keys, values)}
Python 2，适用于 <= 2.6
izipfrom在 Python 3中itertools变得比 zip 更好（因为它避免了不必要的列表创建），并且非常适合 2.6 或更低版本：zipizip
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 3zip仅仅创建了一个可迭代对象：
>>> zip(keys, values)
<zip object at 0x7f0e2ad029c8>
由于我们希望避免创建不必要的数据结构，我们通常希望避免使用 Python 2 zip（因为它会创建不必要的列表）。
性能较差的替代方案：
这是传递给 dict 构造函数的生成器表达式：
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 构造函数的列表推导：
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 中，使用平均值，dict 理解确实更快，对于这些小列表大约快 30%。对于较大的列表（10k 个随机数），
dict调用速度大约快 10%。
我想我们的意思是dict(zip(...10k 随机数。这听起来确实是一个相当不寻常的用例。最直接的调用将在大型数据集中占主导地位确实是有道理的，如果操作系统挂起占主导地位，我不会感到惊讶，因为运行该测试需要多长时间，从而进一步扭曲您的数字。如果你使用meanormax我会认为你的结果毫无意义。
让我们在上面的例子中使用更真实的尺寸：
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
于 2015-11-16T13:54:24.427 回答
134
试试这个：
>>> 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.
于 2008-10-16T19:16:02.377 回答
38
>>> keys = ('name', 'age', 'food')
>>> values = ('Monty', 42, 'spam')
>>> dict(zip(keys, values))
{'food': 'spam', 'age': 42, 'name': 'Monty'}
于 2008-10-16T19:09:18.393 回答
31
您还可以在 Python ≥ 2.7 中使用字典推导：
>>> keys = ('name', 'age', 'food')
>>> values = ('Monty', 42, 'spam')
>>> {k: v for k, v in zip(keys, values)}
{'food': 'spam', 'age': 42, 'name': 'Monty'}
于 2012-06-10T20:03:34.183 回答
19
更自然的方法是使用字典理解
keys = ('name', 'age', 'food')
values = ('Monty', 42, 'spam')
dict = {keys[i]: values[i] for i in range(len(keys))}
于 2015-11-16T05:03:26.593 回答
15
如果您需要在创建字典之前转换键或值，则可以使用生成器表达式。例子：
>>> adict = dict((str(k), v) for k, v in zip(['a', 1, 'b'], [2, 'c', 3]))
于 2008-10-16T20:45:04.240 回答
11
使用 Python 3.x，适用于 dict 理解
keys = ('name', 'age', 'food')
values = ('Monty', 42, 'spam')
dic = {k:v for k,v in zip(keys, values)}
print(dic)
更多关于dict理解here，一个例子是：
>>> print {i : chr(65+i) for i in range(4)}
{0 : 'A', 1 : 'B', 2 : 'C', 3 : 'D'}
于 2013-05-25T13:47:03.623 回答
10
对于那些需要简单代码但不熟悉的人zip：
List1 = ['This', 'is', 'a', 'list']
List2 = ['Put', 'this', 'into', 'dictionary']
这可以通过一行代码完成：
d = {List1[n]: List2[n] for n in range(len(List1))}
于 2013-03-29T19:13:45.220 回答
3
您可以使用以下代码：
dict(zip(['name', 'age', 'food'], ['Monty', 42, 'spam']))
但请确保列表的长度相同。如果长度不同。则 zip 函数将较长的列表转换。
于 2017-11-16T13:36:39.547 回答
3
- 2018-04-18
最好的解决方案仍然是：
In [92]: keys = ('name', 'age', 'food')
...: values = ('Monty', 42, 'spam')
...:
In [93]: dt = dict(zip(keys, values))
In [94]: dt
Out[94]: {'age': 42, 'food': 'spam', 'name': 'Monty'}
转置它：
lst = [('name', 'Monty'), ('age', 42), ('food', 'spam')]
keys, values = zip(*lst)
In [101]: keys
Out[101]: ('name', 'age', 'food')
In [102]: values
Out[102]: ('Monty', 42, 'spam')
于 2018-04-18T02:41:00.477 回答
2
这也是在您的字典中添加列表值的示例
list1 = ["Name", "Surname", "Age"]
list2 = [["Cyd", "JEDD", "JESS"], ["DEY", "AUDIJE", "PONGARON"], [21, 32, 47]]
dic = dict(zip(list1, list2))
print(dic)
始终确保您的“密钥”（list1）始终位于第一个参数中。
{'Name': ['Cyd', 'JEDD', 'JESS'], 'Surname': ['DEY', 'AUDIJE', 'PONGARON'], 'Age': [21, 32, 47]}
于 2019-02-20T12:25:19.300 回答
2
当我试图解决与图形相关的问题时，我有这个疑问。我遇到的问题是我需要定义一个空的邻接列表并想用一个空列表初始化所有节点，这就是我想如何检查它是否足够快的时候，我的意思是是否值得进行 zip 操作而不是简单的赋值键值对。毕竟大多数时候，时间因素是一个重要的破冰者。所以我对这两种方法都执行了 timeit 操作。
import timeit
def dictionary_creation(n_nodes):
dummy_dict = dict()
for node in range(n_nodes):
dummy_dict[node] = []
return dummy_dict
def dictionary_creation_1(n_nodes):
keys = list(range(n_nodes))
values = [[] for i in range(n_nodes)]
graph = dict(zip(keys, values))
return graph
def wrapper(func, *args, **kwargs):
def wrapped():
return func(*args, **kwargs)
return wrapped
iteration = wrapper(dictionary_creation, n_nodes)
shorthand = wrapper(dictionary_creation_1, n_nodes)
for trail in range(1, 8):
print(f'Itertion: {timeit.timeit(iteration, number=trails)}\nShorthand: {timeit.timeit(shorthand, number=trails)}')
对于 n_nodes = 10,000,000 我得到，
迭代：2.825081646999024 简写：3.535717916001886
迭代：5.051560923002398 简写：6.255070794999483
迭代：6.52859034499852 简写：8.221581164998497
迭代：8.683652416999394 简写：12.599181543999293
迭代：11.587241565001023 简写：15.27298851100204
迭代：14.816342867001367 简写：17.162912737003353
迭代：16.645022411001264 简写：19.976680120998935
您可以清楚地看到，在某个点之后，第 n_th 步的迭代方法超过了 n-1_th 步的速记方法所花费的时间。
于 2019-07-20T10:01:28.240 回答
0
使用枚举作为字典理解的解决方案：
dict = {item : values[index] for index, item in enumerate(keys)}
使用枚举的 for 循环解决方案：
dict = {}
for index, item in enumerate(keys):
dict[item] = values[index]
于 2019-11-04T19:58:59.200 回答
-1
如果您正在使用一组以上的值并希望拥有一个dicts 列表，您可以使用它：
def as_dict_list(data: list, columns: list):
return [dict((zip(columns, row))) for row in data]
现实生活中的示例是来自 db 查询的元组列表与来自同一查询的列元组配对。其他答案仅提供 1 对 1。
于 2020-12-16T14:25:17.417 回答
-1
keys = ['name', 'age', 'food']
values = ['Monty', 42, 'spam']
dic = {}
c = 0
for i in keys:
dic[i] = values[c]
c += 1
print(dic)
{'name': 'Monty', 'age': 42, 'food': 'spam'}
于 2021-03-04T11:23:54.137 回答
-2
没有zip功能的方法
l1 = [1,2,3,4,5]
l2 = ['a','b','c','d','e']
d1 = {}
for l1_ in l1:
for l2_ in l2:
d1[l1_] = l2_
l2.remove(l2_)
break
print (d1)
{1: 'd', 2: 'b', 3: 'e', 4: 'a', 5: 'c'}
于 2017-05-24T05:47:22.937 回答
-2
尽管有多种方法可以做到这一点，但我认为最根本的方法是；创建一个循环和字典并将值存储到该字典中。在递归方法中，想法仍然相同，但不是使用循环，而是函数调用自身，直到它到达末尾。当然还有其他方法，例如 usingdict(zip(key, value))等。这些都不是最有效的解决方案。
y = [1,2,3,4]
x = ["a","b","c","d"]
# This below is a brute force method
obj = {}
for i in range(len(y)):
obj[y[i]] = x[i]
print(obj)
# Recursive approach
obj = {}
def map_two_lists(a,b,j=0):
if j < len(a):
obj[b[j]] = a[j]
j +=1
map_two_lists(a, b, j)
return obj
res = map_two_lists(x,y)
print(res)
两个结果都应该打印
{1: 'a', 2: 'b', 3: 'c', 4: 'd'}
于 2020-08-28T03:08:42.133 回答