Wie kann ich eine Liste der Werte von dict erhalten?

337

Wie kann ich eine Liste der Werte in einem Diktat in Python erhalten?

In Java ist das Abrufen der Werte einer Karte als Liste so einfach wie möglich list = map.values();. Ich frage mich, ob es in Python eine ähnlich einfache Möglichkeit gibt, eine Liste von Werten aus einem Diktat zu erhalten.

Muhd
quelle

Antworten:

492

Ja, in Python 2 ist es genau dasselbe :

d.values()

In Python 3 (wobei stattdessen dict.valueseine Ansicht der Wörterbuchwerte zurückgegeben wird):

list(d.values())
Jamylak
quelle
3
@ Muhd ​​Die Python-Dokumente haben immer alles: docs.python.org/2/library/stdtypes.html
Jamylak
16
oder alternativ, [d[k] for k in d]was sowohl für python2.x als auch für 3.x funktioniert ( Bitte beachten Sie, ich schlage nicht vor, dass Sie dies verwenden ). Normalerweise Sie eigentlich nicht brauchen eine Werteliste so d.values()gerade in Ordnung ist.
mgilson
2
Ein etwas "besserer" Link (zu einer bestimmten Stelle auf der von Ihnen geposteten Seite): docs.python.org/2/library/stdtypes.html#dict.values
mgilson
1
Oder d.itervalues()um einen Iterator von Wörterbuchwerten zurückzugeben und eine Liste zu vermeiden.
101
@figs Die Frage ist "Liste der Werte", aber ja, wenn Sie ein Wörterbuch unter Python 2 iterieren, verwenden Sie es definitiv d.itervalues()und in den meisten Fällen müssen Sie nur iterieren und benötigen keine Liste.
Jamylak
25

Sie können den Operator * verwenden , um dict_values ​​zu entpacken:

>>> d = {1: "a", 2: "b"}
>>> [*d.values()]
['a', 'b']

oder Listenobjekt

>>> d = {1: "a", 2: "b"}
>>> list(d.values())
['a', 'b']
Vlad Bezden
quelle
Gute Lösung, ich wusste, dass Sie dies mit Schlüsseln tun können, aber nicht mit Werten, gut zu wissen: D
Timbus Calin
Coole neue Verwendung von* operator
Jamylak
18

Es sollte einen - und vorzugsweise nur einen - offensichtlichen Weg geben, dies zu tun.

Daher list(dictionary.values())ist der eine Weg .

Was ist angesichts von Python3 jedoch schneller?

[*L]vs. [].extend(L)vs.list(L)

small_ds = {x: str(x+42) for x in range(10)}
small_df = {x: float(x+42) for x in range(10)}

print('Small Dict(str)')
%timeit [*small_ds.values()]
%timeit [].extend(small_ds.values())
%timeit list(small_ds.values())

print('Small Dict(float)')
%timeit [*small_df.values()]
%timeit [].extend(small_df.values())
%timeit list(small_df.values())

big_ds = {x: str(x+42) for x in range(1000000)}
big_df = {x: float(x+42) for x in range(1000000)}

print('Big Dict(str)')
%timeit [*big_ds.values()]
%timeit [].extend(big_ds.values())
%timeit list(big_ds.values())

print('Big Dict(float)')
%timeit [*big_df.values()]
%timeit [].extend(big_df.values())
%timeit list(big_df.values())
Small Dict(str)
256 ns ± 3.37 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
338 ns ± 0.807 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
336 ns ± 1.9 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

Small Dict(float)
268 ns ± 0.297 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
343 ns ± 15.2 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
336 ns ± 0.68 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

Big Dict(str)
17.5 ms ± 142 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
16.5 ms ± 338 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
16.2 ms ± 19.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

Big Dict(float)
13.2 ms ± 41 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
13.1 ms ± 919 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
12.8 ms ± 578 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

Fertig auf Intel (R) Core (TM) i7-8650U CPU bei 1,90 GHz.

# Name                    Version                   Build
ipython                   7.5.0            py37h24bf2e0_0

Das Ergebnis

  1. Für kleine Wörterbücher * operatorist das schneller
  2. Für große Wörterbücher, bei denen es darauf ankommt, list()ist es vielleicht etwas schneller
Ronald Luc
quelle
1
list(L), cuz "Es sollte einen - und vorzugsweise nur einen - offensichtlichen Weg geben, dies zu tun."
Ufos
1
Geändert wie vorgeschlagen, @Ufos
Ronald Luc
3

Folgen Sie dem folgenden Beispiel -

songs = [
{"title": "happy birthday", "playcount": 4},
{"title": "AC/DC", "playcount": 2},
{"title": "Billie Jean", "playcount": 6},
{"title": "Human Touch", "playcount": 3}
]

print("====================")
print(f'Songs --> {songs} \n')
title = list(map(lambda x : x['title'], songs))
print(f'Print Title --> {title}')

playcount = list(map(lambda x : x['playcount'], songs))
print(f'Print Playcount --> {playcount}')
print (f'Print Sorted playcount --> {sorted(playcount)}')

# Aliter -
print(sorted(list(map(lambda x: x['playcount'],songs))))
Mohan. EIN
quelle
-3
out: dict_values([{1:a, 2:b}])

in:  str(dict.values())[14:-3]    
out: 1:a, 2:b

Rein für visuelle Zwecke. Erzeugt kein nützliches Produkt ... Nur nützlich, wenn ein langes Wörterbuch in Form eines Absatztyps gedruckt werden soll.

Raja Jain
quelle