두 목록을 사전으로 어떻게 변환합니까?

질문자 :Guido

다음 목록이 있다고 상상해보십시오.

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

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

 a_dict = {'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}

짜잔 :-) pairwise dict 생성자와 zip 함수는 엄청나게 유용합니다.

Dan Lenski

다음이 있다고 상상해보십시오.

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

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

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

가장 성능이 좋은 zip dict

 new_dict = dict(zip(keys, values))

Python 3에서 zip은 이제 게으른 반복자를 반환하며 이것이 이제 가장 성능이 좋은 접근 방식입니다.

dict(zip(keys, values)) dict 및 zip 각각에 대해 일회성 전역 조회가 필요하지만 불필요한 중간 데이터 구조를 형성하지 않거나 함수 응용 프로그램에서 로컬 조회를 처리해야 합니다.

준우승, dict 이해력:

dict 생성자를 사용하는 것에 대한 가까운 2위는 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

그래서 그것은 여전히 (2.7)입니다 :

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

<= 2.6에 이상적인 Python 2

izip 에서 itertools 된다 zip 3. 파이썬 izip 파이썬 2 우편보다 더 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)

최적의 접근 방식은 불필요한 데이터 구조 생성을 피하면서 iterable을 사용하는 것입니다. 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 를 사용하면 이러한 이벤트의 영향을 가장 많이 받는 극단적인 결과만 얻을 수 있습니다.

댓글 작성자는 다음과 같이 말합니다.

python 3.6.8에서 평균값을 사용하면 이러한 작은 목록에 대해 dict 이해가 약 30% 더 빠릅니다. 더 큰 목록(10k 난수)의 경우 dict 호출이 약 10% 더 빠릅니다.

나는 우리가 dict(zip(... 10k 난수 포함. 그것은 상당히 특이한 사용 사례처럼 들립니다. 가장 직접적인 호출이 큰 데이터 세트에서 지배적이라는 것은 의미가 있습니다. 해당 테스트를 실행하는 데 걸리는 시간을 감안할 때 중단이 지배적이어서 숫자가 더 왜곡됩니다. 그리고 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

Aaron Hall

이 시도:

 >>> import itertools >>> keys = ('name', 'age', 'food') >>> values = ('Monty', 42, 'spam') >>> adict = dict(itertools.izip(keys,values)) >>> adict {'food': 'spam', 'age': 42, 'name': 'Monty'}

zip 비해 메모리 소비 면에서도 더 경제적입니다.

Mike Davis

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

iny

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

Brendan Berg

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

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

Polla A. Fattah

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

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

Code Like a Pythonista: Idiomatic Python 을 살펴보십시오.

jfs

Python 3.x에서는 사전 이해로 이동합니다.

 keys = ('name', 'age', 'food') values = ('Monty', 42, 'spam') dic = {k:v for k,v in zip(keys, values)} print(dic)

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

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

kiriloff

zip 익숙하지 않은 사람들을 위해:

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

이것은 한 줄의 코드로 수행할 수 있습니다.

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

exploitprotocol

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

AbstProcDo

코드 아래에서 이것을 사용할 수 있습니다.

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

그러나 목록의 길이가 동일한지 확인하십시오. 길이가 동일하지 않으면 zip 기능이 더 긴 것을 차례대로 변환합니다.

Akash Nayak

다음은 사전에 목록 값을 추가하는 예입니다.

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

항상 "Key"(list1)가 항상 첫 번째 매개변수에 있는지 확인하십시오.

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

Cyd

그래프 관련 문제를 풀려고 하다가 이런 의문이 들었습니다. 내가 가진 문제는 빈 인접 목록을 정의해야 하고 빈 목록으로 모든 노드를 초기화하고 싶었습니다. 그때 나는 그것이 충분히 빠른지 확인하는 방법에 대해 생각했습니다. 즉, 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 = 10,000,000의 경우,

반복: 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번째 단계의 속기 접근에 걸리는 시간을 추월한다는 것을 분명히 알 수 있습니다.

Mayank Prakash

enumerate를 사용한 사전 이해로서의 솔루션:

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

enumerate가 있는 for 루프에 대한 솔루션:

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

jay123

둘 이상의 값 세트로 작업하고 사전 목록 을 갖고 싶다면 다음을 사용할 수 있습니다.

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

실제 예는 동일한 쿼리의 열 튜플과 쌍을 이루는 db 쿼리의 튜플 목록입니다. 기타 답변은 1:1로만 제공됩니다.

DonkeyKong

이 작업을 수행하는 방법에는 여러 가지가 있지만 가장 기본적인 접근 방법이라고 생각합니다. 루프와 사전을 만들고 그 사전에 값을 저장합니다 . 재귀적 접근 방식에서 아이디어는 여전히 동일하지만 루프를 사용하는 대신 함수가 끝에 도달할 때까지 자체적으로 호출됩니다. 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'}

Franco

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

Zeinab Mardi

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

xiyurui

출처 : http:www.stackoverflow.com/questions/209840/how-do-i-convert-two-lists-into-a-dictionary