我想把这些结合起来:
keys = ['name', 'age', 'food']
values = ['Monty', 42, 'spam']
在单个词典中:
{'name': 'Monty', 'age': 42, 'food': 'spam'}
我想把这些结合起来:
keys = ['name', 'age', 'food']
values = ['Monty', 42, 'spam']
在单个词典中:
{'name': 'Monty', 'age': 42, 'food': 'spam'}
这样地:
keys = ['a', 'b', 'c']
values = [1, 2, 3]
dictionary = dict(zip(keys, values))
print(dictionary) # {'a': 1, 'b': 2, 'c': 3}
Voila:-)成对dict构造函数和zip函数非常有用。
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'}
在Python2中,与zip相比,它的内存消耗也更经济。
如果在创建字典之前需要转换键或值,那么可以使用生成器表达式。例子:
>>> adict = dict((str(k), v) for k, v in zip(['a', 1, 'b'], [2, 'c', 3]))
看一看《像蟒蛇一样的代码:惯用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))}
使用Python3.x,可以进行dict理解
keys = ('name', 'age', 'food')
values = ('Monty', 42, 'spam')
dic = {k:v for k,v in zip(keys, values)}
print(dic)
关于dict的理解,这里有一个例子:
>>> 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))
在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
没有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']))
但请确保列表的长度相同。如果长度不相同,请使用zip函数来切换较长的列表。
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')
这里还有一个在字典中添加列表值的示例
list1 = ["Name", "Surname", "Age"]
list2 = [["Cyd", "JEDD", "JESS"], ["DEY", "AUDIJE", "PONGARON"], [21, 32, 47]]
dic = dict(zip(list1, list2))
print(dic)
始终确保“Key”(列表1)始终位于第一个参数中。
{'Name': ['Cyd', 'JEDD', 'JESS'], 'Surname': ['DEY', 'AUDIJE', 'PONGARON'], 'Age': [21, 32, 47]}
当我试图解决一个与图形相关的问题时,我产生了这种怀疑。我遇到的问题是,我需要定义一个空的邻接列表,并想用一个空列表初始化所有节点,这就是我想如何检查它是否足够快的时候,我的意思是,它是否值得执行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步的速记方法所花费的时间。
用枚举法作为词典理解的解决方案:
dict = {item : values[index] for index, item in enumerate(keys)}
使用enumerate的循环的解决方案:
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 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'}
如果您使用的值超过1组,并且希望有一个字典列表,则可以使用此选项:
def as_dict_list(data: list, columns: list):
return [dict((zip(columns, row))) for row in data]
实际示例是来自数据库查询的元组列表,与来自同一查询的列元组配对。其他答案仅为1比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'}
可以通过以下方式完成。
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=0
for k in l:
d[k] = ll[c] #setting up keys from the second list values
c += 1
print(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 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'}]
"""