Wie kann ich eine Liste der Werte von dict erhalten?

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.

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())

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

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

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))))

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.