如何从单独的键和值列表中制作字典（字典）？

像这样：

keys = ['a', 'b', 'c']values = [1, 2, 3]dictionary = dict(zip(keys, values))print(dictionary) # {'a': 1, 'b': 2, 'c': 3}

瞧：-）成对的#0构造函数和#1函数非常有用。

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

输出：

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

试试这个：

>>> 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相比，它的内存消耗也更经济。

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

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

看看像Pythonista一样编码：惯用的Python。

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

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

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

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

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

使用Python 3. x，可以进行字典理解

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

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

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

假设你有：

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进行一次性全局查找，但它不会形成任何不必要的中间数据结构，也不必在函数应用程序中处理本地查找。

亚军，字典理解：

一个接近使用字典构造函数的亚军是使用字典理解的本机语法（不是列表理解，就像其他人错误地说的那样）：

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

izip在Python 3中从itertools变为zip。izip比Python 2的zip更好（因为它避免了不必要的列表创建），非常适合2.6或更低版本：

from itertools import izipnew_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 3的zip仅仅创建了一个可迭代对象：

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

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

性能较差的替代品：

这是一个正在传递给字典构造函数的生成器表达式：

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([(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中，使用均值，对这些小列表的理解确实更快，大约快30%。对于较大的列表（10k随机数），dict调用大约快10%。

我假设我们的意思是dict(zip(...带有10k随机数。这听起来确实是一个相当不寻常的用例。最直接的调用将在大型数据集中占主导地位，这确实是有道理的。考虑到运行该测试需要多长时间，如果操作系统挂起占据主导地位，进一步扭曲你的数字，我也不会感到惊讶。如果你使用mean或max，我会认为你的结果毫无意义。

让我们在上面的例子中使用更现实的大小：

import numpyimport timeitl1 = 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

不带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'}

你可以使用下面的代码：

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

但是要确保列表的长度same.if长度不same.thenzip函数旋转较长的列表。

• 2018-04-18

最好的解决方案仍然是：

In [92]: keys = ('name', 'age', 'food')...: values = ('Monty', 42, 'spam')...:
In [93]: dt = dict(zip(keys, values))In [94]: dtOut[94]: {'age': 42, 'food': 'spam', 'name': 'Monty'}

转换它：

    lst = [('name', 'Monty'), ('age', 42), ('food', 'spam')]keys, values = zip(*lst)In [101]: keysOut[101]: ('name', 'age', 'food')In [102]: valuesOut[102]: ('Monty', 42, 'spam')

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

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

始终确保您的“Key”（list 1）始终位于第一个参数中。

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

当我试图解决一个与图相关的问题时，我有这个疑问。我遇到的问题是我需要定义一个空的邻接列表，并想用一个空列表初始化所有节点，这时我想如何检查它是否足够快，我的意思是是否值得做zip操作而不是简单的赋值键值对。毕竟，时间因素是一个重要的破冰器。所以我对这两种方法都执行了timeit操作。

import timeitdef 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速记：8221581164998497

迭代：8.683652416999394速记：12599181543999293

迭代：11.587241565001023速记：1527298851100204

迭代：14816342867001367速记：17162912737003353

迭代：16645022411001264速记：19976680120998935

您可以清楚地看到，在某一点之后，n_th步的迭代方法超过了1_th步的速记方法所花费的时间。

使用enumerate进行字典理解的解决方案：

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

使用enumerate的for循环的解决方案：

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

虽然有多种方法可以做到这一点，但我认为最基本的方法是处理它；创建一个循环和字典并将值存储到该字典中。在递归方法中，想法仍然是一样的，但不是使用循环，而是函数调用自己直到它到达结尾。当然还有其他方法，如使用dict(zip(key, value))等这些都不是最有效的解决方案。

y = [1,2,3,4]x = ["a","b","c","d"]
# This below is a brute force methodobj = {}for i in range(len(y)):obj[y[i]] = x[i]print(obj)
# Recursive approachobj = {}def map_two_lists(a,b,j=0):if j < len(a):obj[b[j]] = a[j]j +=1map_two_lists(a, b, j)return obj      


res = map_two_lists(x,y)print(res)

两个结果都应该打印

{1: 'a', 2: 'b', 3: 'c', 4: 'd'}

如果您正在使用超过1组值并希望有一个字典列表，您可以使用：

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

现实生活中的示例是来自db查询的元组列表与来自同一查询的列元组配对。其他答案仅提供1到1。

keys = ['name', 'age', 'food']values = ['Monty', 42, 'spam']dic = {}c = 0for i in keys:dic[i] = values[c]c += 1
print(dic){'name': 'Monty', 'age': 42, 'food': 'spam'}

它可以通过以下方式完成。

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

所有答案总结：

l = [1, 5, 8, 9]ll = [3, 7, 10, 11]

zip：

dict(zip(l,ll)) # {1: 3, 5: 7, 8: 10, 9: 11}
#if you want to play with key or value @recommended
{k:v*10 for k, v in zip(l, ll)} #{1: 30, 5: 70, 8: 100, 9: 110}

计数器：

d = {}c=0for k in l:d[k] = ll[c] #setting up keys from the second list valuesc += 1print(d){1: 3, 5: 7, 8: 10, 9: 11}

枚举：

d = {}for i,k in enumerate(l):d[k] = ll[i]print(d){1: 3, 5: 7, 8: 10, 9: 11}

import pprint
p = ['A', 'B', 'C']q = [5, 2, 7]r = ["M", "F", "M"]s = ['Sovabazaar','Shyambazaar','Bagbazaar','Hatkhola']

def makeDictUsingAlternateLists1(**rest):print("*rest.keys() : ",*rest.keys())print("rest.keys() : ",rest.keys())print("*rest.values() : ",*rest.values())print("**rest.keys() : ",rest.keys())print("**rest.values() : ",rest.values())[print(a) for a in zip(*rest.values())]    
[ print(dict(zip(rest.keys(),a))) for a in zip(*rest.values())]print("...")    
    
finalRes= [ dict( zip( rest.keys(),a))  for a in zip(*rest.values())]return finalRes    
l = makeDictUsingAlternateLists1(p=p,q=q,r=r,s=s)pprint.pprint(l)"""*rest.keys() :  p q r srest.keys() :  dict_keys(['p', 'q', 'r', 's'])*rest.values() :  ['A', 'B', 'C'] [5, 2, 7] ['M', 'F', 'M'] ['Sovabazaar', 'Shyambazaar', 'Bagbazaar', 'Hatkhola']**rest.keys() :  dict_keys(['p', 'q', 'r', 's'])**rest.values() :  dict_values([['A', 'B', 'C'], [5, 2, 7], ['M', 'F', 'M'], ['Sovabazaar', 'Shyambazaar', 'Bagbazaar', 'Hatkhola']])('A', 5, 'M', 'Sovabazaar')('B', 2, 'F', 'Shyambazaar')('C', 7, 'M', 'Bagbazaar'){'p': 'A', 'q': 5, 'r': 'M', 's': 'Sovabazaar'}{'p': 'B', 'q': 2, 'r': 'F', 's': 'Shyambazaar'}{'p': 'C', 'q': 7, 'r': 'M', 's': 'Bagbazaar'}...[{'p': 'A', 'q': 5, 'r': 'M', 's': 'Sovabazaar'},{'p': 'B', 'q': 2, 'r': 'F', 's': 'Shyambazaar'},{'p': 'C', 'q': 7, 'r': 'M', 's': 'Bagbazaar'}] 
"""