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

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

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

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

想象一下你有：keys=（'name'，'age'，'food'）values=（'Monty'，42，'spam'）生成以下词典的最简单方法是什么？dict={‘name‘：‘Monty‘，‘age‘：42，‘food‘：‘spam‘}

最具性能的dict构造函数，带有zip

new_dict = dict(zip(keys, values))

在Python3中，zip现在返回一个惰性迭代器，这是目前性能最好的方法。

dict（zip（键、值））确实需要对dict和zip进行一次性全局查找，但它不会形成任何不必要的中间数据结构，也不会处理函数应用程序中的本地查找。

亚军，听写理解：

使用dict构造函数的第二个方法是使用dict理解的原生语法（而不是其他人错误地说的列表理解）：

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

当需要根据键或值映射或过滤时，选择此选项。

在Python2中，zip返回一个列表，为了避免创建不必要的列表，请改用izip（别名为zip可以在转到Python3时减少代码更改）。

from itertools import izip as zip

因此，仍然是（2.7）：

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

所有情况的结果：

在所有情况下：

>>> 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可迭代文件上放置了一层额外的非操作（因此不必要）计算，在列表理解的情况下，不必要地创建了一个额外的列表。我希望他们都表现得不那么出色，当然也不会更出色。

绩效审查：

在由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，我们将只得到最极端的结果-最有可能受到此类事件影响的结果。

一位评论者还说：

在python3.6.8中，使用平均值，dict理解速度确实更快，对于这些小列表来说，大约提高了30%。对于更大的列表（10k个随机数），dict调用大约快10%。

我想我们指的是带有10k随机数的dict（zip）。这听起来确实是一个非常不寻常的用例。在大型数据集中，最直接的调用将占主导地位，这是有道理的，而且考虑到运行测试需要多长时间，如果操作系统挂起占主导地位会进一步扭曲你的数字，我不会感到惊讶。如果你使用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

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

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

看一看《像蟒蛇一样的代码：惯用Python》。

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 s
rest.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'}]
 
"""

试试看：

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

当我试图解决一个与图形相关的问题时，我产生了这种怀疑。我遇到的问题是，我需要定义一个空的邻接列表，并想用一个空列表初始化所有节点，这就是我想如何检查它是否足够快的时候，我的意思是，它是否值得执行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=10000000我明白了，

迭代次数：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步的速记方法所花费的时间。