Hoe u woordenboektoetsen als lijst in Python retourneert?

In Python 2.7 , kan ik woordenboek toetsen , -waarden of Items als een lijst:

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

Nu, in Python & GT; = 3.3 , ik krijg zoiets:

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

Dus moet ik dit doen om een ​​lijst te krijgen:

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

Ik vraag me af, is er een betere manier om een ​​lijst in Python 3 te retourneren?


Antwoord 1, Autoriteit 100%

Probeer list(newdict.keys()).

Hiermee converteert u de dict_keysObject naar een lijst.

Aan de andere kant moet u uzelf afvragen of het al dan niet toe doet. De pythonische weg naar code is om eend te typen (als het eruit ziet als een eend en het kwak als een eend, het is een eend ). De dict_keysObject fungeert als een lijst voor de meeste doeleinden. Bijvoorbeeld:

for key in newdict.keys():
  print(key)

Uiteraard werken invoegingsexploitanten mogelijk niet, maar dat is toch niet veel logisch voor een lijst met woordenboektoetsen.


Antwoord 2, Autoriteit 30%

Python & GT; = 3,5 alternatief: Pak in een lijst Letterlijk [*newdict]

Nieuwe Uitpakkende generalisaties (PEP 448) werden geïntroduceerd met Python 3.5 U kunt nu gemakkelijk doen:

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

Uitpakken met *werkt met elkobject dat itereerbaar is en aangezien woordenboeken hun sleutels retourneren wanneer ze worden herhaald, kunt u eenvoudig een lijst maken door deze in een lijst te gebruiken letterlijk.

Het toevoegen van .keys()dwz [*newdict.keys()]kan helpen om je intentie wat explicieter te maken, hoewel het je een functie-look kost- op en aanroep. (wat, in alle eerlijkheid, niet iets is waar je je echtzorgen over hoeft te maken).


De *iterable-syntaxis is vergelijkbaar met het doen van list(iterable)en het gedrag ervan werd aanvankelijk gedocumenteerd in de Calls-sectievan de Python Reference-handleiding. Met PEP 448 werd de beperking op waar *iterablekon verschijnen versoepeld, waardoor het ook in list, set en tuple literals kon worden geplaatst, de referentiehandleiding op Expressielijstenis ook bijgewerkt om dit te vermelden.


Hoewel equivalent aan list(newdict)met het verschil dat het sneller is (tenminste voor kleine woordenboeken) omdat er geen functieaanroep wordt uitgevoerd:

%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

met grotere woordenboeken is de snelheid vrijwel hetzelfde (de overhead van het doorlopen van een grote verzameling overtreft de kleine kosten van een functieaanroep).


Op een vergelijkbare manier kunt u tuples en sets woordenboeksleutels maken:

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

Pas op voor de volgende komma in het geval van tuple!


Antwoord 3, autoriteit 4%

list(newdict)werkt in zowel Python 2 als Python 3 en biedt een eenvoudige lijst van de sleutels in newdict. keys()is niet nodig. (:


Antwoord 4, autoriteit 2%

Een beetje afwijkend van de definitie van “eend typen” — dict.keys()retourneert een itereerbaar object, geen lijst-achtig object. Het zal overal werken waar een iterable zal werken – niet op elke plaats waar een lijst zal werken. een lijst is ook een herhaling, maar een herhaling is GEEN lijst (of reeks…)

In echte use-cases is het meest gebruikelijke dat u met de sleutels in een dictaat kunt doen, ze doorlopen, dus dit is logisch. En als je ze als lijst nodig hebt, kun je list()aanroepen.

Zeer gelijkaardig voor zip()— in de overgrote meerderheid van de gevallen wordt het herhaald — waarom zou je een hele nieuwe lijst met tuples maken om er doorheen te bladeren en het dan weer weggooien ?

Dit maakt deel uit van een grote trend in Python om meer iterators (en generatoren) te gebruiken in plaats van overal kopieën van lijsten.

dict.keys()zou echter met begrip moeten werken — controleer zorgvuldig op typefouten of zoiets… het werkt prima voor mij:

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

Antwoord 5, autoriteit 2%

U kunt ook een lijstbegripgebruiken:

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

Of, korter,

>>> [k  for  k in  newdict]
[1, 2, 3]

Opmerking: Bestelling is niet gegarandeerd voor versies onder 3.7 (bestellen is nog steeds slechts een implementatiedetail met CPython 3.6).


Antwoord 6

Converteren naar een lijst zonder de keysmethode te gebruiken maakt het leesbaarder:

list(newdict)

en bij het doorbladeren van woordenboeken zijn keys()niet nodig:

for key in newdict:
    print key

tenzij je het binnen de lus aanpast waarvoor een vooraf gemaakte lijst met sleutels nodig is:

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

Op Python 2 is er een marginale prestatiewinst bij gebruik van keys().


Antwoord 7

Als je de sleutels apart moet opslaan, is hier een oplossing die minder typen vereist dan elke andere oplossing die tot nu toe is gepresenteerd, met behulp van 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                          │
            ╘═══════════════╧═════════════════════════════════════════╛

Antwoord 8

Ik kan nadenken over 2 manieren waarop we de sleutels uit het woordenboek kunnen extraheren.

Methode 1: –
Om de sleutels te krijgen met behulp van .Keys () -methode en converteer het vervolgens naar de lijst.

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

Methode 2: –
Een lege lijst maken en vervolgens de toetsen toevoegen aan de lijst via een lus.
Je kunt ook de waarden met deze lus krijgen (gebruik ze.keys () voor alleen sleutels en .items () voor zowel sleutels als waarden-extractie)

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

Antwoord 9

Ik weet dat dit een heel oud antwoord is, maar buiten de klassieke (en waarschijnlijk meer correcte) manier om dit te doen (some_dict.keys()) is er ook een meer “cool” en zeker Meer interessante manier om dit te doen:

some_dict = { "foo": "bar", "cool": "python!" }
print( [*some_dict] == ["foo", "cool"] )         # True  

Antwoord 10

Dit is de beste manier om de sleutellijst in één regel code

te krijgen

dict_variable = {1:"a",2:"b",3:"c"}  
[key_val for key_val in dict_variable.keys()]

Other episodes