Comment retourner des clés de dictionnaire sous forme de liste en Python?
Dans Python 2.7, je pourrais obtenir le dictionnaire clés, valeurs, ou éléments sous forme de liste:
>>> newdict = {1:0, 2:0, 3:0}
>>> newdict.keys()
[1, 2, 3]
Maintenant, dans Python> = 3., j'obtiens quelque chose comme ceci:
>>> newdict.keys()
dict_keys([1, 2, 3])
Donc, je dois faire ceci pour obtenir une liste:
newlist = list()
for i in newdict.keys():
newlist.append(i)
Je me demande s'il existe un meilleur moyen de renvoyer une liste dans Python?
Essayez list(newdict.keys()).
Ceci convertira l'objet dict_keys en une liste.
D'autre part, vous devriez vous demander si cela compte ou non. La méthode pythonique pour coder consiste à supposer que vous tapez du canard (si cela ressemble à un canard et que ce dernier est comme un canard, c’est un canard). L'objet dict_keys agira comme une liste dans la plupart des cas. Par exemple:
for key in newdict.keys():
print(key)
De toute évidence, les opérateurs d’insertion risquent de ne pas fonctionner, mais cela n’a pas beaucoup de sens pour une liste de clés de dictionnaire.
Python> = 3.5 alternative: décompresser dans un littéral de liste [*newdict]
Nouveau généralisations de décompression (PEP 448) ont été introduits avec Python 3.5 vous permettant maintenant de faire facilement:
>>> newdict = {1:0, 2:0, 3:0}
>>> [*newdict]
[1, 2, 3]
La décompression avec * fonctionne avec un objet tout qui est itérable et, comme les dictionnaires renvoient leurs clés lors de leur itération, vous pouvez facilement créer une liste en l'utilisant dans un littéral de liste.
Ajouter .keys() c'est-à-dire [*newdict.keys()] peut vous aider à rendre votre intention un peu plus explicite, bien que cela vous coûtera une recherche et un appel de fonction. (ce qui, en toute honnêteté, n'est pas quelque chose que vous devriez vraiment vous inquiéter).
La syntaxe *iterable est similaire à l'opération list(iterable) et son comportement a été documenté dans le manuel section Appels du manuel de référence Python. Avec PEP 448, la restriction sur l'endroit où *iterable pouvait apparaître a été relâchée, ce qui a permis de le placer également dans les littéraux liste, set et Tuple. Le manuel de référence sur Listes d'expressions a également été mis à jour pour l'indiquer.
Quoique équivalent à list(newdict), à la différence qu'il est plus rapide (du moins pour les petits dictionnaires) car aucun appel de fonction n'est réellement effectué:
%timeit [*newdict]
1000000 loops, best of 3: 249 ns per loop
%timeit list(newdict)
1000000 loops, best of 3: 508 ns per loop
%timeit [k for k in newdict]
1000000 loops, best of 3: 574 ns per loop
avec des dictionnaires plus volumineux, la vitesse est à peu près la même (les frais généraux liés à une itération dans une collection volumineuse l'emportent sur le faible coût d'un appel de fonction).
De la même manière, vous pouvez créer des n-uplets et des jeux de clés de dictionnaire:
>>> *newdict,
(1, 2, 3)
>>> {*newdict}
{1, 2, 3}
méfiez-vous de la virgule dans le cas de Tuple!
list(newdict) fonctionne à la fois en Python 2 et Python 3, en fournissant une simple liste des clés dans newdict. keys() n'est pas nécessaire. (:
Un petit peu sur la définition de "saisie de canard" - dict.keys() renvoie un objet itérable, pas un objet de type liste. Cela fonctionnera partout où un travail itératif fonctionnera - pas n'importe quel endroit qu'une liste. une liste est aussi un itérable, mais un itérable n'est PAS une liste (ou une séquence ...)
Dans les cas d'utilisation réels, la chose la plus courante avec les clés dans un dict est de les parcourir, ce qui est donc logique. Et si vous en avez besoin sous forme de liste, vous pouvez appeler list().
De manière très similaire pour Zip() - dans la grande majorité des cas, il est itéré - pourquoi créer une nouvelle liste de n-uplets juste pour le parcourir et le jeter à nouveau?
Cela fait partie d'une grande tendance à utiliser python plus d'itérateurs (et de générateurs), plutôt que des copies de listes un peu partout.
dict.keys() devrait fonctionner avec des compréhensions, cependant - vérifiez attentivement les fautes de frappe ou quelque chose comme ça ... ça marche très bien pour moi:
>>> d = dict(Zip(['Sounder V Depth, F', 'Vessel Latitude, Degrees-Minutes'], [None, None]))
>>> [key.split(", ") for key in d.keys()]
[['Sounder V Depth', 'F'], ['Vessel Latitude', 'Degrees-Minutes']]
Vous pouvez également utiliser un compréhension de la liste:
>>> newdict = {1:0, 2:0, 3:0}
>>> [k for k in newdict.keys()]
[1, 2, 3]
Ou, plus court,
>>> [k for k in newdict]
[1, 2, 3]
Remarque: La commande n'est pas garantie sur les versions de version 3.7 (la commande n'est encore qu'un détail d'implémentation avec CPython 3.6).
La conversion en liste sans utiliser la méthode keys le rend plus lisible:
list(newdict)
et, lors de la lecture en boucle des dictionnaires, il n'est pas nécessaire d'utiliser keys():
for key in newdict:
print key
à moins que vous ne le modifiiez dans la boucle, ce qui nécessiterait une liste de clés créée au préalable:
for key in list(newdict):
del newdict[key]
Sur Python 2, il y a un gain de performance marginal qui utilise keys().
Si vous devez stocker les clés séparément, voici une solution qui nécessite moins de frappe que toutes les autres solutions présentées jusqu'à présent, à l'aide de décompression itérative étendue (python3.x +).
newdict = {1: 0, 2: 0, 3: 0}
*k, = newdict
k
# [1, 2, 3]
╒═══════════════╤═════════════════════════════════════════╕
│ k = list(d) │ 9 characters (excluding whitespace) │
├───────────────┼─────────────────────────────────────────┤
│ k = [*d] │ 6 characters │
├───────────────┼─────────────────────────────────────────┤
│ *k, = d │ 5 characters │
╘═══════════════╧═════════════════════════════════════════╛
Vous pouvez aussi faire une Tuple(dict) ou set(dict):
>>> list(set(newdict))
[1, 2, 3]
>>> list(Tuple(newdict))
[1, 2, 3]
list(newdict)
C'est la solution la plus simple et a fonctionné comme un charme!
Outre les moyens mentionnés sur cette page, vous pouvez utiliser itemgetter à partir du module opérateur:
>>> from operator import itemgetter
>>> list(map(itemgetter(0), dd.items()))
[1, 2, 3]
liste (newdict.keys ())
list(newdict.keys())