두 목록을 사전으로 변환합니다

Question

당신이 가지고 있다고 상상해보십시오 :

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

다음 사전을 생산하는 가장 간단한 방법은 무엇입니까?

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

Answer 1

이와 같이:

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

Answer 2

이 시도:

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

Answer 3

당신이 가지고 있다고 상상해보십시오 :

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 ~에서 itertools becomes zip 파이썬 3. izip Python 2의 Zip보다 낫습니다 (불필요한 목록 생성을 피하기 때문에). 2.6 이하에 이상적입니다.

from itertools import izip
new_dict = dict(izip(keys, values))

파이썬 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)

최적의 접근 방식은 불필요한 데이터 구조를 피하면서 반복 가능한 것을 사용하는 것입니다. 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 's 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 반복 가능한 위에 배치되며 목록 이해의 경우 추가 목록이 불필요하게 생성됩니다. 나는 그들 모두가 덜 성능을 발휘할 것으로 기대하고, 확실히 더 이상은 아니라고 기대할 것입니다.

성능 검토 :

Ubuntu 14.04에서 64 비트 파이썬 3.4.3에서 가장 빠른에서 가장 느리게 주문했습니다.

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

Answer 4

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

Answer 5

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

Answer 6

보다 자연스러운 방법은 사전 이해력을 사용하는 것입니다

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

Answer 7

사전을 만들기 전에 키나 값을 변환 해야하는 경우 발전기 표현 사용 될수있다. 예시:

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

구경하다 Pythonista와 같은 코드 : 관용 파이썬.

Answer 8

with Python 3.x, goes for dict comprehensions

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

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

print(dic)

More on dict comprehensions here, an example is there:

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

Answer 9

For those who need simple code and aren’t familiar with zip:

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

This can be done by one line of code:

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

Answer 10

• 2018-04-18

The best solution is still:

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

Answer 11

you can use this below code:

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

But make sure that length of the lists will be same.if length is not same.then zip function turncate the longer one.

Answer 12

Here is also an example of adding a list value in you dictionary

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

always make sure the your "Key"(list1) is always in the first parameter.

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

Answer 13

method without zip function

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