Créer un dictionnaire avec une compréhension de liste
J'aime la syntaxe de compréhension de la liste Python.
Peut-il aussi être utilisé pour créer des dictionnaires? Par exemple, en itérant sur des paires de clés et de valeurs:
mydict = {(k,v) for (k,v) in blah blah blah} # doesn't work
À partir de Python 2.7 et 3, vous devez simplement utiliser la syntaxe de compréhension de la dictée :
{key: value for (key, value) in iterable}
Dans Python2.6 et versions antérieures, la fonction intégrée dict peut recevoir un nombre de paires clé/valeur pouvant être ité, de sorte que vous puissiez lui transmettre une compréhension de liste ou une expression génératrice. Par exemple:
dict((key, func(key)) for key in keys)
Toutefois, si vous possédez déjà des valeurs itérables et/ou des clés, vous n'avez pas besoin de comprendre du tout - c'est plus simple: appelez directement le dict intégré:
# consumed from any iterable yielding pairs of keys/vals
dict(pairs)
# "zipped" from two separate iterables of keys/vals
dict(Zip(list_of_keys, list_of_values))
Dans Python 3 et Python 2.7+, la compréhension du dictionnaire ressemble à celle ci-dessous:
d = {k:v for k, v in iterable}
Pour Python2.6 ou version antérieure, voir réponse de fortran .
En fait, vous n'avez même pas besoin de parcourir l'itéré s'il comprend déjà une sorte de mapping, le constructeur de dict le fait 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}
Dans Python2.7, il se présente comme suit:
>>> list1, list2 = ['a', 'b', 'c'], [1,2,3]
>>> dict( Zip( list1, list2))
{'a': 1, 'c': 3, 'b': 2}
Zip les!
Pour ajouter à la réponse de @ fortran, si vous souhaitez parcourir une liste de clés 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 une compréhension de liste en Python
J'aime la syntaxe de compréhension de liste Python.
Peut-il aussi être utilisé pour créer des dictionnaires? Par exemple, en itérant sur des paires de clés et de valeurs:
mydict = {(k,v) for (k,v) in blah blah blah}
Vous recherchez l'expression "compréhension compréhensive" - c'est en fait:
mydict = {k:v for k,v in iterable}
Ceci est presque valable sauf pour bla bla bla:
mydict = {(k,v) for (k,v) in blah blah blah}
^^^^^^--invalid syntax
En supposant que blah blah blah est un itérable de deux-tuples - vous êtes si proche. Créons des "blahs" comme ça:
blahs = [('blah0', 'blah'), ('blah1', 'blah'), ('blah2', 'blah'), ('blah3', 'blah')]
Syntaxe de compréhension dictée:
Maintenant, la syntaxe est la partie mappage. Ce qui en fait une compréhension dict au lieu d'une compréhension set (qui correspond à ce que votre pseudo-code se rapproche) est le deux-points, : comme ci-dessous:
mydict = {k: v for k, v in blahs}
Et nous voyons que cela a fonctionné et qu'il devrait conserver l'ordre d'insertion dès Python 3.7:
>>> mydict
{'blah0': 'blah', 'blah1': 'blah', 'blah2': 'blah', 'blah3': 'blah'}
Dans Python 2 et jusqu'à 3.6, l'ordre n'était pas garanti:
>>> mydict
{'blah0': 'blah', 'blah1': 'blah', 'blah3': 'blah', 'blah2': 'blah'}
Ajout d'un filtre:
Toutes les compréhensions comportent un composant de mappage et un composant de filtrage que vous pouvez fournir avec des expressions arbitraires.
Vous pouvez donc 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'}
Ici, nous testons simplement si le dernier caractère est divisible par 2 pour filtrer les données avant de mapper les clés et les valeurs.
version Python <2.7, procédez comme suit:
d = dict((i,True) for i in [1,2,3])
version Python> = 2.7, procédez comme suit:
d = {i: True for i in [1,2,3]}
Voici un autre exemple de création de dictionnaire utilisant la compréhension dictée:
Ce que je cherche à faire ici est de créer un dictionnaire alphabétique 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}
>>>
Remarquez l'utilisation d'énumérer ici pour obtenir une liste des alphabets et leurs index dans la liste et permuter les alphabets et les index pour générer la paire valeur/clé pour dictionnaire.
J'espère que cela vous donnera une bonne idée de la compilation de dictionnaires et vous encouragera à l'utiliser plus souvent pour rendre votre code compact
Essaye ça,
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']
Créez ensuite un dictionnaire à partir des deux listes:
print get_dic_from_two_lists(country, capital)
La sortie est comme ça,
{'Pakistan': 'Islamabad', 'China': 'Beijing', 'India': 'New Delhi'}
Juste pour donner un autre exemple. Imaginez que vous ayez la liste suivante:
nums = [4,2,2,1,3]
et vous voulez en faire un dict où la clé est l’index et la valeur l’élément de la liste. Vous pouvez le faire avec la ligne de code suivante:
{index:nums[index] for index in range(0,len(nums))}
>>> {k: v**3 for (k, v) in Zip(string.ascii_lowercase, range(26))}
Python prend en charge les interprétations dict, qui vous permettent d’exprimer la création de dictionnaires au moment de l’exécution en utilisant une syntaxe similaire.
Une compréhension du dictionnaire prend la forme {clé: valeur pour (clé, valeur) en itérable}. Cette syntaxe a été introduite dans Python 3 et rétroportée jusqu'à Python 2.7, vous devriez donc pouvoir l'utiliser quelle que soit la version de Python que vous avez installée. .
Un exemple canonique prend deux listes et crée un dictionnaire dans lequel l'élément à chaque position dans la première liste devient une clé et l'élément à la position correspondante dans la seconde liste devient la valeur.
La fonction Zip utilisée dans cette compréhension renvoie un itérateur de tuples, où chaque élément du Tuple est pris à la même position dans chacun des itérables en entrée. Dans l'exemple ci-dessus, l'itérateur renvoyé contient les nuplets (“a”, 1), (“b”, 2), etc.
Sortie:
{'i': 512, 'e': 64, 'o': 2744, 'h': 343, 'l': 1331, 's': 5832, 'b': 1, 'w': 10648, ' c ': 8,' x ': 12167,' y ': 13824,' t ': 6859,' p ': 3375,' d ': 27,' j ': 729,' a ': 0,' z ' : 15625, 'f': 125, 'q': 4096, 'u': 8000, 'n': 2197, 'm': 1728, 'r': 4913, 'k': 1000, 'g': 216 , 'v': 9261}
Ce code créera un dictionnaire utilisant la compréhension de liste pour plusieurs listes avec différentes valeurs pouvant être utilisées pour pd.DataFrame()
#Multiple lists
model=['A', 'B', 'C', 'D']
launched=[1983,1984,1984,1984]
discontinued=[1986, 1985, 1984, 1986]
#Dictionary with list comprehension
keys=['model','launched','discontinued']
vals=[model, launched,discontinued]
data = {key:vals[n] for n, key in enumerate(keys)}
enumerate passera n à vals pour faire correspondre chaque key à sa liste