Como posso obter uma lista de valores do dict?

338

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.

python list dictionary Muhd
fonte

Respostas:

494

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())
jamylak
fonte
3
Docs @Muhd O Python sempre ter tudo: docs.python.org/2/library/stdtypes.html
jamylak
16
ou, alternativamente, [d[k] for k in d]que funcione para python2.xe 3.x (por favor, esteja ciente de que não estou sugerindo que você use isso ). Normalmente você não precisa de uma lista de valores, então d.values()tudo bem.
mgilson
2
Um link ligeiramente "melhor" (para um local específico na página que você postou): docs.python.org/2/library/stdtypes.html#dict.values
mgilson
1
Ou d.itervalues()por retornar um iterador de valores do dicionário e evitar uma lista.
101
@figs A questão é "lista de valores", mas sim, se você estiver repetindo um dicionário no Python 2, definitivamente usará d.itervalues()e, na maioria dos casos, você precisará apenas repetir e não precisará de uma lista.
jamylak
25

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']
Vlad Bezden
fonte
Boa solução, eu sabia que você poderia fazer isso com chaves, mas não com os valores, é bom saber: D
Timbus Calin
Novo uso legal de* operator
jamylak
19

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
Ronald Luc
fonte
1
list(L), porque "Deve haver uma - e de preferência apenas uma - maneira óbvia de fazer isso".
Ufos
1
Alterado como proposto, @Ufos
Ronald Luc
3

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))))
Mohan. UMA
fonte
-3 
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.

Raja jain
fonte