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

时间:2008-10-16 19:05:47

标签: python list dictionary

想象一下,你有:

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

制作以下字典的最简单方法是什么?

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

22 个答案:

答案 0 :(得分:1734)

像这样:

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

答案 1 :(得分:118)

试试这个:

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

答案 2 :(得分:110)

  

想象一下,你有:

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的{​​{1}}在Python 3中变为itertoolszip优于用于Python 2的zip(因为它避免了不必要的列表创建),并且非常适合2.6或以下:

izip

Python 3

在Python 3中,from itertools import izip new_dict = dict(izip(keys, values)) zip模块中的函数相同,因此只是:

itertools

虽然dict理解会更高效(请参阅本答案末尾的表现评论)。

所有案例的结果:

在所有情况下:

new_dict = dict(zip(keys, values))

说明:

如果我们查看>>> new_dict {'age': 42, 'name': 'Monty', 'food': 'spam'} 上的帮助,我们会发现它需要各种形式的参数:

dict

最佳方法是使用iterable,同时避免创建不必要的数据结构。在Python 2中,zip创建了一个不必要的列表:

>>> 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 3中,等效的是:

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

和Python 3的>>> list(zip(keys, values)) [('name', 'Monty'), ('age', 42), ('food', 'spam')] 只是创建一个可迭代的对象:

zip

由于我们希望避免创建不必要的数据结构,我们通常希望避免使用Python 2 >>> zip(keys, values) <zip object at 0x7f0e2ad029c8> (因为它会创建一个不必要的列表)。

性能较低的替代方案:

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

zip

或等效地:

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

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

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

在前两种情况下,在zip可迭代上放置一层额外的非操作(因此不必要的)计算,并且在列表理解的情况下,不必要地创建额外的列表。我希望他们所有人都不那么高效,当然也不会更多。

绩效考核:

在64位Python 3.4.3中,在Ubuntu 14.04上,从最快到最慢排序:

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

答案 3 :(得分:30)

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

答案 4 :(得分:27)

您还可以在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'}

答案 5 :(得分:13)

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

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

答案 6 :(得分:12)

如果您需要在创建字典之前转换键或值,则可以使用generator expression。例如:

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

看看Code Like a Pythonista: Idiomatic Python

答案 7 :(得分:10)

使用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'}

答案 8 :(得分:5)

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

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

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

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

答案 9 :(得分:3)

  • 2018年4月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'}

Tranpose it:

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

答案 10 :(得分:1)

您可以使用以下代码:

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

但要确保列表的长度是相同的。如果长度不一样,那么zip函数就会变长。

答案 11 :(得分:1)

您可以使用字典理解功能只用一行就可以做到:

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

就这样。享受Python .....;)

答案 12 :(得分:1)

这也是在字典中添加列表值的示例

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

答案 13 :(得分:1)

keys = ['name', 'age', 'food']
values = ['Monty', 42, 'spam']
new_dict = dict(zip(keys,values))
print(new_dict)

答案 14 :(得分:1)

在尝试解决与图形相关的问题时,我有这个疑问。我遇到的问题是我需要定义一个空的邻接列表,并想用一个空列表初始化所有节点,这就是我想到如何检查它是否足够快的时候,我的意思是说值得进行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 :(得分:0)

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

答案 16 :(得分:0)

作为带有枚举的字典理解的解决方案:

dict = {}
for index, item in enumerate(keys):
    dict[item] = values[index]

用于枚举循环的解决方案:

temp.info()

答案 17 :(得分:0)

如果您使用的是一组以上的值,并且希望有一个词典列表,则可以使用以下方法:

def as_dict_list(data: list, columns: list):
    return [dict((zip(columns, row))) for row in data]

实际示例是将数据库查询中的元组列表与同一查询中的列元组配对。其他答案仅适用于1到1。

答案 18 :(得分:-1)

您也可以尝试将两个列表组合在一起的一个列表;)

a = [1,2,3,4]
n = [5,6,7,8]

x = []
for i in a,n:
    x.append(i)

print(dict(zip(x[0], x[1])))

答案 19 :(得分:-1)

尽管有多种方法可以做到这一点,但我认为最基本的解决方法是: 创建循环和字典并​​将值存储到该字典中 。在递归方法中,想法仍然是相同的,但是该函数不使用循环,而是调用自身直至到达末尾。当然,还有其他方法,例如使用dict(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'}  

答案 20 :(得分:-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'}

答案 21 :(得分:-2)

keys = ['name', 'age', 'food']
values = ['Monty', 42, 'spam']
index=np.arange(0,len(keys)-1)

df=pd.DataFrame(list(zip(keys,values)), columns=['keys','values'])
df.set_index('keys')
print(df.head())

data_dict = df.iloc[index].set_index('keys')['values'].to_dict() 
print(data_dict)

zip创建一个并行值生成器 list()实例化完整的生成器,并将其传递到转换整个表达式的数据帧中。 结果输出:

两个列表:

    keys values
 0  name  Monty
 1   age     42
 2  food   spam
 

输出:字典

 {'name': 'Monty', 'age': 42}