想象一下您有:
keys = ['name', 'age', 'food']
values = ['Monty', 42, 'spam']
产生以下字典的最简单方法是什么?
a_dict = {'name' : 'Monty', 'age' : 42, 'food' : 'spam'}
#1楼
您还可以在≥2.7的Python中使用字典理解:
>>> keys = ('name', 'age', 'food')
>>> values = ('Monty', 42, 'spam')
>>> {k: v for k, v in zip(keys, values)}
{'food': 'spam', 'age': 42, 'name': 'Monty'}
#2楼
对于那些需要简单代码并且对zip
不熟悉的人:
List1 = ['This', 'is', 'a', 'list']
List2 = ['Put', 'this', 'into', 'dictionary']
可以通过一行代码来完成:
d = {List1[n]: List2[n] for n in range(len(List1))}
#3楼
使用Python 3.x进行dict理解
keys = ('name', 'age', 'food')
values = ('Monty', 42, 'spam')
dic = {k:v for k,v in zip(keys, values)}
print(dic)
>>> print {i : chr(65+i) for i in range(4)}
{0 : 'A', 1 : 'B', 2 : 'C', 3 : 'D'}
#4楼
像这样:
>>> keys = ['a', 'b', 'c']
>>> values = [1, 2, 3]
>>> dictionary = dict(zip(keys, values))
>>> print(dictionary)
{'a': 1, 'b': 2, 'c': 3}
成对的dict
构造函数和zip
函数非常有用: https : //docs.python.org/3/library/functions.html#func-dict
#5楼
>>> keys = ('name', 'age', 'food')
>>> values = ('Monty', 42, 'spam')
>>> dict(zip(keys, values))
{'food': 'spam', 'age': 42, 'name': 'Monty'}
#6楼
尝试这个:
>>> 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
相比,它在内存消耗方面也更经济。
#7楼
如果需要在创建字典之前转换键或值,则可以使用生成器表达式 。 例:
>>> adict = dict((str(k), v) for k, v in zip(['a', 1, 'b'], [2, 'c', 3]))
#8楼
一种更自然的方法是使用字典理解
keys = ('name', 'age', 'food')
values = ('Monty', 42, 'spam')
dict = {keys[i]: values[i] for i in range(len(keys))}
#9楼
想象一下您有:
keys = ('name', 'age', 'food') values = ('Monty', 42, 'spam')
产生以下字典的最简单方法是什么?
dict = {'name' : 'Monty', 'age' : 42, 'food' : 'spam'}
性能最高-Python 2.7和3,dict理解:
使用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
所以仍然是:
new_dict = {k: v for k, v in zip(keys, values)}
Python 2,非常适合<= 2.6
izip
从itertools
变得zip
在Python 3. izip
比拉链用于Python 2更好(因为它避免了不必要的列表创建),以及理想的2.6或以下:
from itertools import izip
new_dict = dict(izip(keys, values))
Python 3
在Python 3中, zip
变成了与itertools
模块相同的函数,因此很简单:
new_dict = dict(zip(keys, values))
但是,对dict的理解会更有表现(请参阅此答案末尾的表现评论)。
所有情况的结果:
在所有情况下:
>>> 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
(因为它创建了不必要的列表)。
性能较差的替代品:
这是一个传递给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上放置了一个额外的非操作(因此是不必要的)计算层,并且在列表理解的情况下,不必要地创建了一个额外的列表。 我希望他们所有人的表现都不太好,当然也不会那么好。
性能评估:
在Ubuntu 18.04上的64位Python 3.7.3中,从最快到最慢的顺序是:
>>> min(timeit.repeat(lambda: dict(zip(keys, values))))
0.4772876740025822
>>> min(timeit.repeat(lambda: {k: v for k, v in zip(keys, values)}))
0.5217149950040039
>>> min(timeit.repeat(lambda: {keys[i]: values[i] for i in range(len(keys))}))
0.6797661719901953
>>> min(timeit.repeat(lambda: dict([(k, v) for k, v in zip(keys, values)])))
0.7864680950006004
>>> min(timeit.repeat(lambda: dict((k, v) for k, v in zip(keys, values))))
0.8561034000013024
评论者说:
min
似乎是比较性能的一种不好方法。 当然,mean
和/或max
对于实际使用将是更有用的指标。
我们使用min
是因为这些算法是确定性的。 我们想知道算法在最佳条件下的性能。
如果操作系统由于任何原因挂起,则与我们要比较的内容无关,因此我们需要从分析中排除这些结果。
如果我们使用mean
,那么这类事件将大大扭曲我们的结果,而如果使用max
,则只会得到最极端的结果-最有可能受此类事件影响的结果。
评论者还说:
在python 3.6.8中,使用平均值,对dict的理解确实仍然更快,对于这些小列表来说,大约30%。 对于较大的列表(10k个随机数),
dict
调用的速度快大约10%。
我认为我们的意思是dict(zip(...
具有10k随机数。这听起来像是一个非常不寻常的用例。这确实是最直接的调用将在大型数据集中占主导地位,如果使用OS,我也不会感到惊讶鉴于测试需要花费多长时间,因此挂起操作占主导地位,这进一步会使您的数字产生偏差。如果您使用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
#10楼
没有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'}
#11楼
您可以使用以下代码:
dict(zip(['name', 'age', 'food'], ['Monty', 42, 'spam']))
但是请确保列表的长度相同。如果长度不相同,则zip函数会将较长的列表进行分类。
#12楼
- 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')
#13楼
这也是在字典中添加列表值的示例
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]}
#14楼
在尝试解决与图形相关的问题时,我有这个疑问。 我遇到的问题是我需要定义一个空的邻接列表,并想用一个空列表初始化所有节点,那是当我想到如何检查它是否足够快时,我的意思是说值得进行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_步的迭代方法超过了第n-1_步的速记方法所花费的时间。
#15楼
带有枚举的字典理解解决方案:
dict = {item : values[index] for index, item in enumerate(keys)}
与枚举循环的解决方案:
dict = {}
for index, item in enumerate(keys):
dict[item] = values[index]