en Python 3 et python 2.7+, les interprétations du dictionnaire ressemblent à ce qui suit:

d = {k:v for k, v in iterable}

Pour Python 2.6 ou version antérieure, voir fortran réponse .

en fait, vous n'avez même pas besoin d'itérer sur l'itérable si elle comprend déjà une sorte de cartographie, le constructeur DCT le faisant gracieusement pour vous:

>>> ts = [(1, 2), (3, 4), (5, 6)]
>>> dict(ts)
{1: 2, 3: 4, 5: 6}
>>> gen = ((i, i+1) for i in range(1, 6, 2))
>>> gen
<generator object <genexpr> at 0xb7201c5c>
>>> dict(gen)
{1: 2, 3: 4, 5: 6}

en Python 2.7, ça fait:

>>> list1, list2 = ['a', 'b', 'c'], [1,2,3]
>>> dict( zip( list1, list2))
{'a': 1, 'c': 3, 'b': 2}

Zip !

À ajouter sur @fortran réponse, si vous voulez parcourir une liste de touches key_list ainsi qu'une liste de valeurs value_list :

d = dict((key, value) for (key, value) in zip(key_list, value_list))

ou

d = {(key, value) for (key, value) in zip(key_list, value_list)}

créer un dictionnaire avec la compréhension de liste en Python

j'aime la syntaxe de compréhension de la liste Python.

peut-il aussi être utilisé pour créer des dictionnaires? Par exemple, par l'itération sur des paires de clés et de valeurs:

mydict = {(k,v) for (k,v) in blah blah blah}

en supposant que blah blah blah est un itérable de deux tuples-tu es si proche. Créons des "blahs" comme ça:

blahs = [('blah0', 'blah'), ('blah1', 'blah'), ('blah2', 'blah'), ('blah3', 'blah')]

syntaxe de compréhension Dict:

maintenant la syntaxe ici est la partie mapping. Ce qui fait que c'est une compréhension dict au lieu d'une compréhension set (ce qui est l'approximation de votre pseudo-code) est le deux-points, : comme ci-dessous:

mydict = {k: v for k, v in blahs}

et maintenant quand vous faites:

>>> mydict
{'blah0': 'blah', 'blah1': 'blah', 'blah3': 'blah', 'blah2': 'blah'}

Ajouter un filtre:

tout comme les compréhensions de liste, vous pouvez ajouter une partie de filtre à la fin:

>>> mydict = {k: v for k, v in blahs if not int(k[-1]) % 2}
>>> mydict
{'blah0': 'blah', 'blah2': 'blah'}

nous vérifions ici si le dernier caractère est divisible par 2.

pour la version python < 2.7, faites ce qui suit:

d = dict((i,True) for i in [1,2,3])

pour la version python > = 2.7, faites ce qui suit:

d = {i: True for i in [1,2,3]}

voici un autre exemple de création de dictionnaire utilisant la compréhension dict:

ce que j'essaie de faire ici est de créer un dictionnaire de l'alphabet où chaque paire; est la lettre anglaise et sa position correspondante dans l'alphabet anglais

>>> import string
>>> dict1 = {value: (int(key) + 1) for key, value in 
enumerate(list(string.ascii_lowercase))}
>>> dict1
{'a': 1, 'c': 3, 'b': 2, 'e': 5, 'd': 4, 'g': 7, 'f': 6, 'i': 9, 'h': 8, 
'k': 11, 'j': 10, 'm': 13, 'l': 12, 'o': 15, 'n': 14, 'q': 17, 'p': 16, 's': 
19, 'r': 18, 'u': 21, 't': 20, 'w': 23, 'v': 22, 'y': 25, 'x': 24, 'z': 26}
>>> 

noter l'utilisation d'énumérer ici pour obtenir une liste des alphabets et leurs index dans la liste et l'échange des alphabets et des indices pour générer la paire de valeur clé pour le dictionnaire

espérons qu'il donne une bonne idée de dictionnaire comp à vous et vous encourage à l'utiliser plus souvent pour faire votre code compact

Essayez cette,

def get_dic_from_two_lists(keys, values):
    return { keys[i] : values[i] for i in range(len(keys)) }

supposons que nous ayons deux listes pays et capital

country = ['India', 'Pakistan', 'China']
capital = ['New Delhi', 'Islamabad', 'Beijing']

puis créer dictionnaire à partir des deux listes:

print get_dic_from_two_lists(country, capital)

la sortie est comme ceci,

{'Pakistan': 'Islamabad', 'China': 'Beijing', 'India': 'New Delhi'}

pour donner un autre exemple. Imaginez que vous ayez la liste suivante:

nums = [4,2,2,1,3]

et vous voulez le transformer en un dict où la clé est l'index et la valeur est l'élément dans la liste. Vous pouvez le faire avec la ligne de code suivante:

{index:nums[index] for index in range(0,len(nums))}