在Python中将两个列表转换为字典-Java 学习之路

835

想象一下，你有：

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

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

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

13 回答

>>> keys = ('name', 'age', 'food')
>>> values = ('Monty', 42, 'spam')
>>> dict(zip(keys, values))
{'food': 'spam', 'age': 42, 'name': 'Monty'}

回复于 2024-05-22T01:43:04+08:00

1519
您可以使用字典理解使用一行来创建它：
```
a_dict={key:value for key,value in zip(keys,values)}
```
这就是它.Enjoy Python .....;）
回复于 2024-05-22T01:43:04+08:00

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

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

回复于 2024-05-22T01:43:04+08:00

29
像这样：
```
>>> keys = ['a', 'b', 'c']
>>> values = [1, 2, 3]
>>> dictionary = dict(zip(keys, values))
>>> print(dictionary)
{'a': 1, 'b': 2, 'c': 3}
```
Voila :-)成对的 dict 构造函数和 zip 函数非常有用：https://docs.python.org/3/library/functions.html#func-dict
回复于 2024-05-22T01:43:04+08:00

没有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'}

回复于 2024-05-22T01:43:04+08:00

13
想象一下，你有：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

来自 itertools 的 izip 在Python 3中变为 zip . izip 比Python 2的zip更好（因为它避免了不必要的列表创建），并且适用于2.6或更低版本：
```
from itertools import izip
new_dict = dict(izip(keys, values))
```
Python 3

在Python 3中， zip 与 itertools 模块中的函数相同，因此它只是：
```
new_dict = dict(zip(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)
```
最佳方法是使用iterable，同时避免创建不必要的数据结构 . 在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可迭代上放置一层额外的非操作（因此不必要的）计算，并且在列表理解的情况下，不必要地创建额外的列表 . 我希望他们所有人都不那么高效，当然也不会更多 .

绩效考核：

在64位Python 3.4.3中，在Ubuntu 14.04上，从最快到最慢排序：
```
>>> 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
```
回复于 2024-05-22T01:43:04+08:00

对于那些需要简单代码且不熟悉 zip 的人：

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

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

d = {List1[n]: List2[n] for n in range(len(List1))}

回复于 2024-05-22T01:43:04+08:00

你也可以在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'}

回复于 2024-05-22T01:43:04+08:00

试试这个：

>>> 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 相比，它在内存消耗方面也更经济 .

回复于 2024-05-22T01:43:04+08:00

113
您可以使用以下代码：
```
dict(zip(['name', 'age', 'food'], ['Monty', 42, 'spam']))
```
但要确保列表的长度是相同的 . 如果长度不一样，那么zip函数就会变长 .
回复于 2024-05-22T01:43:04+08:00

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

回复于 2024-05-22T01:43:04+08:00

2
如果您需要在创建字典之前转换键或值，则可以使用generator expression . 例：
```
>>> adict = dict((str(k), v) for k, v in zip(['a', 1, 'b'], [2, 'c', 3]))
```
看看Code Like a Pythonista: Idiomatic Python .
回复于 2024-05-22T01:43:04+08:00

使用Python 3.x，用于字典理解

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

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

print(dic)

更多关于dict comprehensions here，有一个例子：

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

回复于 2024-05-22T01:43:04+08:00

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

13 回答

性能最佳 - Python 2.7和3，dict理解：

Python 2，非常适合<= 2.6

Python 3

所有案例的结果：

说明：

性能较差的替代方案：

绩效考核：

相关问题