dictionary {} - Converti due liste in un dizionario in Python




append salvare (11)

metodo senza funzione 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'}

Immagina di avere:

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

Qual è il modo più semplice per produrre il seguente dizionario?

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

Come questo:

>>> keys = ['a', 'b', 'c']
>>> values = [1, 2, 3]
>>> dictionary = dict(zip(keys, values))
>>> print(dictionary)
{'a': 1, 'b': 2, 'c': 3}

Voila :-) Le funzioni di constructor e zip pairwise sono incredibilmente utili: https://docs.python.org/3/library/functions.html#func-dict


Un modo più naturale è usare la comprensione del dizionario

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

Per coloro che hanno bisogno di un codice semplice e non hanno familiarità con lo zip :

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

Questo può essere fatto da una riga di codice:

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

  • 2018/04/18

La migliore soluzione è ancora:

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

Lo metti in pratica:

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

Prova questo:

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

In Python 2, è anche più economico nel consumo di memoria rispetto a zip .


Puoi anche usare le comprensibilità del dizionario in 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(zip(keys, values))
{'food': 'spam', 'age': 42, 'name': 'Monty'}


con Python 3.x, vale per la comprensione del Dict

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

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

print(dic)

Maggiori informazioni sulla comprensione del ditt qui , un esempio è lì:

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

Nota : qui sotto si applica a Python 3.3+ perché utilizza yield_from. sixè anche un pacchetto di terze parti, sebbene sia stabile. In alternativa, è possibile utilizzare sys.version.

Nel caso di obj = [[1, 2,], [3, 4], [5, 6]], tutte le soluzioni qui sono buone, compresa la comprensione delle liste e itertools.chain.from_iterable.

Tuttavia, considera questo caso leggermente più complesso:

>>> obj = [[1, 2, 3], [4, 5], 6, 'abc', [7], [8, [9, 10]]]

Ci sono diversi problemi qui:

  • Un elemento,, 6è solo uno scalare; non è iterable, quindi le rotte di cui sopra falliranno qui.
  • Un elemento, 'abc', è tecnicamente iterabile (tutti strs sono). Tuttavia, leggendo tra le righe un po ', non si vuole trattarlo come tale - si vuole trattarlo come un singolo elemento.
  • L'elemento finale, [8, [9, 10]]è esso stesso un iterabile nidificato. Comprensione di base delle liste e chain.from_iterablesolo estrarre "1 livello in basso".

Puoi rimediare a questo come segue:

>>> from collections import Iterable
>>> from six import string_types

>>> def flatten(obj):
...     for i in obj:
...         if isinstance(i, Iterable) and not isinstance(i, string_types):
...             yield from flatten(i)
...         else:
...             yield i


>>> list(flatten(obj))
[1, 2, 3, 4, 5, 6, 'abc', 7, 8, 9, 10]

Qui, si controlla che l'elemento secondario (1) sia iterabile con Iterable, un ABC da itertools, ma si desidera anche assicurarsi che (2) l'elemento non sia "simile a una stringa".





python list dictionary