Comment renvoyer des clés de dictionnaire sous forme de liste en Python?

En Python 2.7 , je pouvais obtenir des clés de dictionnaire , des valeurs ou des éléments sous forme de liste:

>>> newdict = {1:0, 2:0, 3:0}
>>> newdict.keys()
[1, 2, 3]

Maintenant, en Python> = 3.3 , j'obtiens quelque chose comme ceci:

>>> newdict.keys()
dict_keys([1, 2, 3])

Donc, je dois le faire pour obtenir une liste:

newlist = list()
for i in newdict.keys():
    newlist.append(i)

Je me demande, y a-t-il une meilleure façon de retourner une liste en Python 3 ?

Essayez list(newdict.keys()).

Cela convertira l' dict_keysobjet en une liste.

D'un autre côté, vous devez vous demander si cela importe ou non. La façon Pythonique de coder consiste à assumer la frappe de canard ( si cela ressemble à un canard et qu'il se casse comme un canard, c'est un canard ). L' dict_keysobjet 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 peuvent ne pas fonctionner, mais cela n'a pas beaucoup de sens pour une liste de clés de dictionnaire de toute façon.

Python> = 3.5 alternative: décompresser dans une liste littérale [*newdict]

De nouvelles généralisations de déballage (PEP 448) ont été introduites avec Python 3.5 vous permettant désormais de faire facilement:

>>> newdict = {1:0, 2:0, 3:0}
>>> [*newdict]
[1, 2, 3]

Le décompactage *fonctionne avec n'importe quel objet qui est itérable et, puisque les dictionnaires renvoient leurs clés lorsqu'ils sont itérés, vous pouvez facilement créer une liste en l'utilisant dans un littéral de liste.

L'ajout de .keys()ie [*newdict.keys()]pourrait aider à rendre votre intention un peu plus explicite, mais cela vous coûtera une recherche et une invocation de fonction. (ce qui, en toute honnêteté, n'est pas quelque chose dont vous devriez vraiment vous inquiéter).

_{La *iterablesyntaxe est similaire à faire list(iterable)et son comportement a été initialement documenté dans la section Appels du manuel de référence Python. Avec le PEP 448, la restriction sur l'endroit où *iterablepourrait apparaître a été assouplie, ce qui permet de le placer également dans les littéraux de liste, de set et de tuple, le manuel de référence sur les listes d'expressions a également été mis à jour pour l'indiquer.}

Bien qu'équivalent à list(newdict)la différence qu'il est plus rapide (au 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 grands, la vitesse est à peu près la même (le surcoût lié à l'itération dans une grande collection l'emporte sur le faible coût d'un appel de fonction).

De la même manière, vous pouvez créer des tuples et des ensembles de clés de dictionnaire:

>>> *newdict,
(1, 2, 3)
>>> {*newdict}
{1, 2, 3}

méfiez-vous de la virgule de fin dans le tuple case!

list(newdict)fonctionne à la fois dans Python 2 et Python 3, fournissant une liste simple des clés dans newdict. keys()n'est pas nécessaire. (:

Un peu sur la définition de "typage du canard" - dict.keys()renvoie un objet itérable, pas un objet de type liste. Cela fonctionnera partout où un itérable fonctionnera - pas n'importe où une liste fonctionnera. une liste est aussi un itérable, mais un itérable n'est PAS une liste (ou séquence ...)

Dans les cas d'utilisation réels, la chose la plus courante à faire avec les touches d'un dict est de les parcourir, donc cela a du sens. Et si vous en avez besoin comme liste, vous pouvez appeler list().

De la même manière, car zip()- dans la grande majorité des cas, elle est répétée - pourquoi créer une toute nouvelle liste de tuples juste pour l'itérer puis la jeter à nouveau?

Cela fait partie d'une grande tendance en python à utiliser plus d'itérateurs (et de générateurs), plutôt que des copies de listes partout.

dict.keys() devrait fonctionner avec des compréhensions, cependant - vérifiez attentivement les fautes de frappe ou quelque chose ... cela fonctionne 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 une compréhension de 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: L'ordre n'est pas garanti sur les versions sous 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 keysméthode la rend plus lisible:

list(newdict)

et, lorsque vous parcourez les dictionnaires, vous n'avez pas besoin de keys():

for key in newdict:
    print key

sauf si vous le modifiez dans la boucle qui nécessiterait une liste de clés préalablement créée:

for key in list(newdict):
    del newdict[key]

Sur Python 2, il y a un gain de performance marginal en utilisantkeys() .

Si vous devez stocker les clés séparément, voici une solution qui nécessite moins de saisie que toutes les autres solutions présentées jusqu'à présent, en utilisant Extended Iterable Unpacking (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                          │
            ╘═══════════════╧═════════════════════════════════════════╛

Je peux penser à 2 façons d'extraire les clés du dictionnaire.

Méthode 1: - Pour obtenir les clés à l'aide de la méthode .keys () puis les convertir en liste.

some_dict = {1: 'one', 2: 'two', 3: 'three'}
list_of_keys = list(some_dict.keys())
print(list_of_keys)
-->[1,2,3]

Méthode 2: - Pour créer une liste vide, puis ajouter des clés à la liste via une boucle. Vous pouvez également obtenir les valeurs avec cette boucle (utilisez .keys () pour les clés uniquement et .items () pour l'extraction des clés et des valeurs)

list_of_keys = []
list_of_values = []
for key,val in some_dict.items():
    list_of_keys.append(key)
    list_of_values.append(val)

print(list_of_keys)
-->[1,2,3]

print(list_of_values)
-->['one','two','three']