Wie kann ich eine Liste von Werten aus einem Diktat erhalten?

Question

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

In Java ist es einfach, die Werte einer Map als Liste zu erhalten, indem man list = map.values(); . Ich frage mich, ob es eine ähnlich einfache Möglichkeit in Python, eine Liste von Werten aus einem Diktat zu erhalten ist.

Answer 1

dict.values gibt eine siehe der Werte des Wörterbuchs, also müssen Sie es in list :

list(d.values())

Answer 2

Sie können verwenden * Betreiber zum Auspacken von dict_values:

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

oder Listenobjekt

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

Answer 3

Es sollte eine und vorzugsweise nur eine offensichtliche Möglichkeit geben, dies zu tun.

Deshalb list(dictionary.values()) ist die Einweg .

Doch was ist schneller, wenn man Python3 betrachtet?

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

Durchgeführt mit Intel(R) Core(TM) i7-8650U CPU @ 1.90GHz.

# Name                    Version                   Build
ipython                   7.5.0            py37h24bf2e0_0

Das Ergebnis

1. *Für kleine Wörterbücher ` operator` ist schneller**
2. Für große Wörterbücher, wo es darauf ankommt list() ist vielleicht etwas schneller

Answer 4

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

Answer 5

Wenn Sie die Werte als Liste einer Variablen zuweisen müssen, ist eine weitere Methode, die das Entpacken * Betreiber ist

*values, = d.values()

Abrufen einer Liste von Werten für bestimmte Schlüssel in einem Wörterbuch

Der einfachste Weg ist die Verwendung eines Verständnisses durch Iteration über list_of_keys . Wenn list_of_keys enthält Schlüssel, die nicht Schlüssel von d , .get() Methode kann verwendet werden, um einen Standardwert zurückzugeben ( None standardmäßig, kann aber geändert werden).

res = [d[k] for k in list_of_keys] 
# or
res = [d.get(k) for k in list_of_keys]

Wie so oft gibt es eine in Python integrierte Methode, die die Werte unter den Schlüsseln abrufen kann: itemgetter() aus dem eingebauten operator Modul.

from operator import itemgetter
res = list(itemgetter(*list_of_keys)(d))

Demonstration:

d = {'a':2, 'b':4, 'c':7}
list_of_keys = ['a','c']
print([d.get(k) for k in list_of_keys])
print(list(itemgetter(*list_of_keys)(d)))
# [2, 7]
# [2, 7]

Abrufen von Werten desselben Schlüssels aus einer Liste von Wörterbüchern

Auch hier funktioniert ein Verständnis (Iteration über eine Liste von Wörterbüchern). Ebenso wie das Mapping itemgetter() über die Liste, um die Werte eines bestimmten Schlüssels/bestimmter Schlüssel zu erhalten.

list_of_dicts = [ {"title": "A", "body": "AA"}, {"title": "B", "body": "BB"} ]

list_comp = [d['title'] for d in list_of_dicts]
itmgetter = list(map(itemgetter('title'), list_of_dicts))
print(list_comp)
print(itmgetter)
# ['A', 'B']
# ['A', 'B']