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

338

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

En Java, obtener los valores de un Mapa como Lista es tan fácil como hacerlo list = map.values();. Me pregunto si hay una manera similar en Python para obtener una lista de valores de un dict.

python list dictionary Muhd
fuente

Respuestas:

494

Sí, es exactamente lo mismo en Python 2 :

d.values()

En Python 3 (donde dict.valuesdevuelve una vista de los valores del diccionario):

list(d.values())
jamylak
fuente
3
@Muhd Los documentos de Python siempre tienen todo: docs.python.org/2/library/stdtypes.html
jamylak
16
o, alternativamente, [d[k] for k in d]que funciona tanto para python2.xy 3.x ( tenga en cuenta que en realidad no estoy sugiriendo que use esto ). Por lo general, no necesita una lista de valores, por lo que d.values()está bien.
mgilson
2
Un enlace ligeramente "mejor" (a un lugar específico en la página que publicó): docs.python.org/2/library/stdtypes.html#dict.values
mgilson
1
O d.itervalues()para devolver un iterador de valores de diccionario y evitar una lista.
101
@figs La pregunta es "lista de valores", pero sí, si estaba iterando un diccionario en Python 2 definitivamente use d.itervalues()y en la mayoría de los casos solo necesitará iterar y no necesitará una lista.
jamylak
25

Puede usar * operator para desempaquetar dict_values:

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

o objeto de lista

>>> d = {1: "a", 2: "b"}
>>> list(d.values())
['a', 'b']
Vlad Bezden
fuente
Buena solución, sabía que podía hacer esto con claves pero no con valores, es bueno saberlo: D
Timbus Calin
Nuevo uso genial de* operator
jamylak
19

Debe haber una, y preferiblemente solo una, forma obvia de hacerlo.

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

Sin embargo, considerando Python3, ¿qué es más 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)

Hecho en Intel (R) Core (TM) i7-8650U CPU @ 1.90GHz.

# Name                    Version                   Build
ipython                   7.5.0            py37h24bf2e0_0

El resultado

  1. Para diccionarios pequeños * operatores más rápido
  2. Para los grandes diccionarios donde importa list()es quizás un poco más rápido
Ronald Luc
fuente
1
list(L), porque "Debe haber una, y preferiblemente solo una, forma obvia de hacerlo".
Ovnis
1
Cambiado según lo propuesto, @Ufos
Ronald Luc
3

Sigue 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))))
Mohan UNA
fuente
-3 
out: dict_values([{1:a, 2:b}])

in:  str(dict.values())[14:-3]    
out: 1:a, 2:b

Puramente para fines visuales. No produce un producto útil ... Solo es útil si desea que se imprima un diccionario largo en forma de párrafo.

Raja jain
fuente