Como posso obter uma lista de valores do dict?

Como posso obter uma lista dos valores em um dict no Python?

Em Java, obter os valores de um mapa como uma lista é tão fácil quanto fazer list = map.values();. Gostaria de saber se existe uma maneira igualmente simples em Python para obter uma lista de valores de um dict.

Sim, é exatamente a mesma coisa no Python 2 :

d.values()

No Python 3 (onde dict.valuesretorna uma visão dos valores do dicionário):

list(d.values())

Você pode usar o operador * para descompactar dict_values:

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

ou listar objeto

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

Deve haver uma - e de preferência apenas uma - maneira óbvia de fazê-lo.

Portanto, list(dictionary.values())é o único caminho .

No entanto, considerando o Python3, o que é mais rápido?

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

Feito na CPU Intel (R) Core (TM) i7-8650U a 1.90GHz.

# Name                    Version                   Build
ipython                   7.5.0            py37h24bf2e0_0

O resultado

1. Para pequenos dicionários * operatoré mais rápido
2. Para grandes dicionários onde importa, list()talvez seja um pouco mais rápido

Siga o exemplo abaixo -

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

Puramente para fins visuais. Não produz um produto útil ... Útil apenas se você desejar que um dicionário longo seja impresso em um formulário do tipo parágrafo.