2つのリストを辞書に変換する

あなたが持っていると想像してください：

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}

出来上がり:-)ペアワイズdictコンストラクターとzip関数は非常に便利です：https ://docs.python.org/3/library/functions.html#func-dict

あなたが持っていると想像してください：

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

次の辞書を作成する最も簡単な方法は何ですか？

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

最もパフォーマンスの高い、dictコンストラクタzip

new_dict = dict(zip(keys, values))

Python 3では、zipが遅延イテレータを返すようになり、これが現在最もパフォーマンスの高いアプローチです。

dict(zip(keys, values))各一回グローバル・ルックアップを必要としないdictとzip、それが不要な中間データ構造を形成するか、機能のアプリケーション内のローカル検索に対処する必要はありません。

次点、口述理解：

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

したがって、それはまだ（2.7）です。

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

Python 2、2.6以下に最適

izipitertoolsなり、zipPythonの3のizipPythonの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)

最適なアプローチは、不必要なデータ構造の作成を避けながら、イテラブルを使用することです。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)])

最初の2つのケースでは、動作しない（したがって不要な）計算の追加レイヤーが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％高速です。大きなリスト（1万個の乱数）の場合、dict呼び出しは約10％速くなります。

私dict(zip(...は10kの乱数を意味していると思います。それはかなり珍しい使用例のように聞こえます。大規模なデータセットでは、最も直接的な呼び出しが支配的であることは理にかなっており、そのテストの実行にかかる時間を考慮してOSのハングが支配的であっても、数値がさらに歪んでも驚くことはありません。そして、あなたが使用した場合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')
>>> 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の理解に役立ちます

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

単純なコードが必要で、慣れていない人のためにzip：

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

これは、1行のコードで実行できます。

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

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

以下のコードを使用できます：

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

ただし、リストの長さが同じであることを確認してください。長さが同じでない場合は、zip関数で長い方を回転してください。

グラフ関連の問題を解決しようとしているときに、この疑問がありました。私が持っていた問題は、空の隣接リストを定義する必要があり、空のリストですべてのノードを初期化したかったことです。それは、それが十分に高速かどうかを確認する方法を考えたときです。つまり、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 = 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_thステップでの反復アプローチは、n-1_thステップでのショートハンドアプローチにかかる時間を追い越していることがはっきりとわかります。

これも辞書にリスト値を追加する例です

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

enumerateを使用した辞書内包としてのソリューション：

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

enumerateを使用したループの解決策：

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

2つのリストを組み合わせた1つのリストを試すこともできます;）

a = [1,2,3,4]
n = [5,6,7,8]

x = []
for i in a,n:
    x.append(i)

print(dict(zip(x[0], x[1])))

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