키와 값의 개별 목록에서 사전(딕트)을 만들려면 어떻게 해야 합니까?

키와 값의 개별 목록에서 사전(딕트)을 만들려면 어떻게 해야 합니까?

이것들을 조합하고 싶다.

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 :-) 쌍으로 구성된 생성자와 함수는 매우 유용합니다.

예를 들어 다음과 같습니다.

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

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

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

의 퍼포먼스, ★★★★★★★★★★★★★★★★★★★★★★」dict with construct with가 있는 zip

new_dict = dict(zip(keys, values))

Python 3에서 zip은 느린 반복기를 반환하며, 이것이 가장 성능이 뛰어난 접근법입니다.

dict(zip(keys, values)) '1'에 대해 합니다.dict ★★★★★★★★★★★★★★★★★」zip단, 불필요한 중간 데이터 구조를 형성하거나 기능 어플리케이션에서 로컬 룩업을 처리할 필요는 없습니다.

차점자, 딕트 이해:

dict constructor를 사용하는 것에 이어 dict constructure의 네이티브 구문을 사용합니다(다른 사람이 잘못 말한 것처럼 목록 이해가 아닙니다).

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

키 또는 값을 기준으로 매핑 또는 필터링해야 할 경우 이 옵션을 선택합니다.

2, 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부에서itertools다가 되다zip파이썬 3에서. Python 3에 있습니다.izip파이썬 2에 대한 Zip 2.6 또는 아래에 이상적인 목록 생성, 2.6 또는 아래 이상 이상 이상 이상적입니다.Python 2의 경우 zip보다 우수하며(불필요한 목록을 만들지 않기 때문에), 2.6 이하에 이상적입니다.

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

모든 경우의 결과:

모든 경우:

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

설명:

If we look at the help on 에 대한 도움말을 보면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의 Python 3zip반복 가능한 개체를 만들 뿐입니다.

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

한 데이터에 보통 의 Python 2의 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)])

처음 2개의 경우, zipitable 위에 비작동(따라서 불필요한) 연산 레이어가 추가되고, 리스트 이해의 경우 추가 리스트가 불필요하게 작성된다.나는 그들 모두가 성능이 떨어지기를 기대하며, 확실히 더 나아지지는 않을 것이다.

퍼포먼스 리뷰:

Ubuntu 16.04에서 Nix가 제공한 64비트 Python 3.8.2에서 가장 빠른 것부터 가장 느린 것까지:

>>> 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실제 사용에 훨씬 더 유용한 지표가 될 것입니다.

는 용용 we we we we we we we we wemin왜냐하면 이 알고리즘들은 결정론적이기 때문입니다.가능한 한 최적의 조건에서의 알고리즘 성능을 알고 싶습니다.

어떤 이유로든 운영체제가 정지된 경우 비교 대상과는 무관하므로 분석에서 이러한 결과를 제외해야 합니다.

mean시킬 수 있고, 일들로 인해 결과를 왜곡시킬 수 있습니다. 그리고 만약 우리가max우리는 가장 극단적인 결과만 얻을 것이다 - 그러한 사건의 영향을 가장 많이 받을 것이다.

해설자는 다음과 같이 말합니다.

python 3.6.8에서는 평균값을 사용하는 경우, 이러한 작은 목록의 경우 이해력이 30% 정도 더 빠릅니다. 리스트의 는, 「」(10k 난수)입니다.dict통화 속도가 약 10% 빨라집니다.

제 생각엔dict(zip(...10k의상당히 이례적인 사용 사례로 들리는데요.대규모 데이터셋에서는 대부분의 직접 콜이 지배적인 것은 당연합니다.테스트를 실행하는 데 걸리는 시간을 고려하면 OS 행이 지배적이 되어도 숫자는 더욱 왜곡됩니다. 리그 and and and and and and를 사용하면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

이것을 시험해 보세요.

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

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

출력:

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

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

보다 자연스러운 방법은 사전 이해를 사용하는 것이다.

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

사전을 만들기 전에 키 또는 값을 변환해야 하는 경우 생성기 식을 사용할 수 있습니다.예:

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

Pythonista와 같은 코드 보기: 이디오토마틱 Python

Python 3.x에서는 dict comprehensions에 대응합니다.

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

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

print(dic)

dict comprehensions에 대한 자세한 내용은 다음과 같습니다.

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

zip:

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

이것은, 1 행의 코드로 실시할 수 있습니다.

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

다음 코드를 사용할 수 있습니다.

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)

키(list1)가 항상 첫 번째 파라미터에 있는지 확인합니다.

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

그래프와 관련된 문제를 풀려고 하다가 이런 의문이 들었습니다.문제는 빈 인접 목록을 정의해야 하고 빈 목록을 사용하여 모든 노드를 초기화해야 한다는 것입니다.그 때, 이것이 충분히 빠른지 어떤지를 확인하는 것이 좋을지 생각했습니다.즉, 단순한 할당 키와 값의 쌍이 아닌 zip 조작을 실행할 가치가 있는지를 확인하는 것입니다.대부분의 경우, 시간적 요인은 중요한 서먹서먹한 분위기입니다.그래서 두 가지 접근법에 대해 시간 연산을 수행했습니다.

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 = 1,000,000일 경우,

반복: 2.825081646999024 속기: 3.535717916001886

반복: 5.051560923002398 속기: 6.25507079499483

반복: 6.52859034499852 속기: 8.221581164998497

반복: 8.68365241699394 약자: 12.59918154399293

반복: 11.587241565001023 속기: 15.2729851100204

반복: 14.816342867001367 약자: 17.162912737003353

반복: 16.645022411001264 요약: 19.976680120998935

특정 포인트 이후 n_th 스텝의 반복 접근법이 n-1st 스텝의 속기 접근법에 의해 걸리는 시간을 앞지른다는 것을 명확하게 알 수 있습니다.

두 개 이상의 값 집합을 사용하고 있고 딕트 목록을 원하는 경우 다음을 사용할 수 있습니다.

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

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]

압축:

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}

Enumerate를 사용한 사전 이해 솔루션:

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

enumerate가 있는 루프의 경우 해결 방법:

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

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

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

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

언급URL : https://stackoverflow.com/questions/209840/how-can-i-make-a-dictionary-dict-from-separate-lists-of-keys-and-values