¿Cómo puedo obtener una lista de valores de dict?

¿Cómo puedo obtener una lista de los valores en un dict en Python?

En Java, obtener los valores de un mapa como una lista es tan fácil como hacerlo list = map.values();. Me pregunto si existe una forma igualmente sencilla en Python de obtener una lista de valores de un dict.

Apr 26 '13 10:04 Muhd

Puede utilizar el operador * para descomprimir dict_values:

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

o listar objeto

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

Apr 02 '2019 18:04 Vlad Bezden

Debería haber una, y preferiblemente sólo una, manera obvia de hacerlo.

Por lo tanto, list(dictionary.values())es el único camino .

Sin embargo, considerando Python3, ¿qué es más rápido?

[*L]vs [].extend(L)vs vslist(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)

Hecho en CPU Intel(R) Core(TM) i7-8650U a 1,90 GHz.

# Name                    Version                   Build
ipython                   7.5.0            py37h24bf2e0_0

El resultado

1. Para diccionarios pequeños * operatores más rápido
2. Para diccionarios grandes donde importa, list()quizás sea un poco más rápido

Jun 24 '2019 12:06 Ronald Luc

Siga el siguiente ejemplo:

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

Feb 14 '2019 11:02 Mohan. A