在Python中将两个列表转换为字典


假设你有:

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

生成下列字典的最简单方法是什么?

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

是这样的:

1
2
3
4
5
>>> 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

试试这个:

1
2
3
4
5
6
>>> import itertools
>>> keys = ('name', 'age', 'food')
>>> values = ('Monty', 42, 'spam')
>>> adict = dict(itertools.izip(keys,values))
>>> adict
{'food': 'spam', 'age': 42, 'name': 'Monty'}

在python2中，它在内存消耗方面也比zip更经济。

相关讨论

Imagine that you have:

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

What is the simplest way to produce the following dictionary ?

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

性能最佳- Python 2.7和3,dict理解:

使用dict构造函数的一个可能的改进是使用dict理解的原生语法(而不是像其他人错误地说的列表理解):

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

在python2中，zip返回一个列表，为了避免创建不必要的列表，使用izip代替(当您移动到python3时，别名为zip可以减少代码更改)。

1
from itertools import izip as zip

所以这仍然是:

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

python2，适用于<= 2.6

在python3中，itertools中的izip变成了zip。对于Python 2， izip比zip更好(因为它避免了不必要的列表创建)，对于2.6或以下版本是理想的:

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

Python 3

在python3中，zip变成了与itertools模块相同的函数，即:

1
new_dict = dict(zip(keys, values))

尽管如此，对单词的理解会更有效果(请参阅本答案末尾的性能评估)。

所有病例结果:

在所有情况下:

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

解释:

如果我们看一下关于dict的帮助，我们会发现它采用了多种形式的参数:

1
2
3
4
5
6
7
8
9
10
11
12
>>> 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)

最佳方法是使用可迭代的方法，同时避免创建不必要的数据结构。在python2中，zip创建了一个不必要的列表:

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

在python3中，等价的是:

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

Python 3的zip仅仅创建了一个可迭代的对象:

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

由于我们希望避免创建不必要的数据结构，所以我们通常希望避免Python 2的zip(因为它创建了一个不必要的列表)。

低性能的替代品:

这是传递给dict构造函数的生成器表达式:

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

或者说:

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

这是传递给dict构造函数的列表理解:

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

在前两种情况下，在zip iterable上放置了一个额外的非工作(因此不必要)计算层，在理解列表的情况下，不必要地创建了一个额外的列表。我希望他们所有人的表现都不那么出色，而且肯定不会更糟。

绩效考核:

在64位Python 3.4.3, Ubuntu 14.04上，从最快到最慢:

1
2
3
4
5
6
7
8
9
10
>>> min(timeit.repeat(lambda: {k: v for k, v in zip(keys, values)}))
0.7836067057214677
>>> min(timeit.repeat(lambda: dict(zip(keys, values))))
1.0321204089559615
>>> min(timeit.repeat(lambda: {keys[i]: values[i] for i in range(len(keys))}))
1.0714934510178864
>>> min(timeit.repeat(lambda: dict([(k, v) for k, v in zip(keys, values)])))
1.6110592018812895
>>> min(timeit.repeat(lambda: dict((k, v) for k, v in zip(keys, values))))
1.7361853648908436
1
2
3
4
>>> keys = ('name', 'age', 'food')
>>> values = ('Monty', 42, 'spam')
>>> dict(zip(keys, values))
{'food': 'spam', 'age': 42, 'name': 'Monty'}

你也可以在Python中使用字典理解≥2.7:

1
2
3
4
>>> keys = ('name', 'age', 'food')
>>> values = ('Monty', 42, 'spam')
>>> {k: v for k, v in zip(keys, values)}
{'food': 'spam', 'age': 42, 'name': 'Monty'}

更自然的方法是使用字典理解

1
2
3
keys = ('name', 'age', 'food')
values = ('Monty', 42, 'spam')    
dict = {keys[i]: values[i] for i in range(len(keys))}

如果在创建字典之前需要转换键或值，那么可以使用生成器表达式。例子:

1
>>> adict = dict((str(k), v) for k, v in zip(['a', 1, 'b'], [2, 'c', 3]))

看一下Pythonista:惯用Python的代码。

Python 3。x代表dict的理解

1
2
3
4
5
6
keys = ('name', 'age', 'food')
values = ('Monty', 42, 'spam')

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

print(dic)

更多关于dict的理解，这里有一个例子:

1
2
>>> print {i : chr(65+i) for i in range(4)}
    {0 : 'A', 1 : 'B', 2 : 'C', 3 : 'D'}

对于那些需要简单的代码和不熟悉zip:

1
2
List1 = ['This', 'is', 'a', 'list']
List2 = ['Put', 'this', 'into', 'dictionary']

这可以通过一行代码完成:

1
d = {List1[n]: List2[n] for n in range(len(List1))}
相关讨论

2018-04-18

最好的解决办法仍然是:

1
2
3
4
5
6
7
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'}

转置:

1
2
3
4
5
6
    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')
1
2
3
4
keys = ['name', 'age', 'food']
values = ['Monty', 42, 'spam']
new_dict = dict(zip(keys,values))
print(new_dict)

这里还有一个在字典中添加列表值的例子

1
2
3
4
list1 = ["Name","Surname","Age"]
list2 = [["Cyd","JEDD","JESS"], ["DEY","AUDIJE","PONGARON"], [21, 32, 47]]
dic = dict(zip(list1, list2))
print(dic)

始终确保您的"Key"(清单1)始终位于第一个参数中。

1
{'Name': ['Cyd', 'JEDD', 'JESS'], 'Surname': ['DEY', 'AUDIJE', 'PONGARON'], 'Age': [21, 32, 47]}

你可以用字典里的一句话来解释:

1
a_dict={key:value for key,value in zip(keys,values)}

就是这样。享受Python…

你可以使用以下代码:

1
dict(zip(['name', 'age', 'food'], ['Monty', 42, 'spam']))

但是要确保列表的长度是相同的。如果长度不相等。然后zip函数转换较长的那个。

没有zip函数的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
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'}
相关讨论