How can I get list of values from dict?

You can use * operator to unpack dict_values:

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

or list object

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

There should be one ‒ and preferably only one ‒ obvious way to do it.

Therefore list(dictionary.values()) is the one way.

Yet, considering Python3, what is quicker?

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

Done on Intel(R) Core(TM) i7-8650U CPU @ 1.90GHz.

# Name Version Build ipython 7.5.0 py37h24bf2e0_0 

The result

1. For small dictionaries * operator is quicker
2. For big dictionaries where it matters list() is maybe slightly quicker

Follow the below example --

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

If you need to assign the values as a list to a variable, another method using the unpacking * operator is

*values, = d.values() 

Get a list of values of specific keys in a dictionary

Most straightforward way is to use a comprehension by iterating over list_of_keys. If list_of_keys includes keys that are not keys of d, .get() method may be used to return a default value (None by default but can be changed).

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

As often the case, there's a method built into Python that can get the values under keys: itemgetter() from the built-in operator module.

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] 

Get values of the same key from a list of dictionaries

Again, a comprehension works here (iterating over list of dictionaries). As does mapping itemgetter() over the list to get the values of specific key(s).

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'] 

If you want return a list by default (as in python 2) instead of a view, one can create a new dict class and overwrite the values method:

class ldict(dict): # return a simple list instead of dict_values object values = lambda _: [*super().values()] d = ldict({'a': 1, 'b': 2}) d.values() # [1, 2] (instead of dict_values([1, 2]))