Получение списка значений из списка диктов

Question

У меня есть список таких диктовок:

[{'value': 'apple', 'blah': 2}, 
 {'value': 'banana', 'blah': 3} , 
 {'value': 'cars', 'blah': 4}]

хочу ['apple', 'banana', 'cars']

Какой лучший способ сделать это?

Answer 1

Предполагая, что каждый dict имеет клавишу value, вы можете написать (если ваш список называется l)

[d['value'] for d in l]

Если value может отсутствовать, вы можете использовать

[d['value'] for d in l if 'value' in d]

Answer 2

Вот еще один способ сделать это, используя функции map () и lambda:

>>> map(lambda d: d['value'], l)

, где l - список.Я вижу этот способ "самым сексуальным", но я бы сделал это, используя понимание списка.

Обновление: в случае, если это значение может отсутствовать в качестве ключевого слова:

>>> map(lambda d: d.get('value', 'default value'), l)

Обновление: Я также не большой поклонник лямбд, я предпочитаю называть вещи ... вот как я бы сделал это с учетом этого:

>>> import operator
>>> map(operator.itemgetter('value'), l)

Я бы даже пошел дальше и создал бы подошвуфункция, которая явно говорит о том, чего я хочу достичь:

>>> import operator, functools
>>> get_values = functools.partial(map, operator.itemgetter('value'))
>>> get_values(l)
... [<list of values>]

В Python 3, поскольку map возвращает итератор, используйте list для возврата списка, например, list(map(operator.itemgetter('value'), l)).

Answer 3

[x['value'] for x in list_of_dicts]

Answer 4

В очень простом случае, подобном этому, понимание, как в ответ Исмаила Бадави , определенно является подходом.

Но когда все усложняется, и вам нужно начать писать многоузловые или вложенные понимания со сложными выражениями в них, стоит поискать другие альтернативы. Существует несколько различных (квази) стандартных способов задания поиска в стиле XPath для вложенных структур dict-and-list, таких как JSONPath, DPath и KVC. И для них есть отличные библиотеки на PyPI.

Вот пример с библиотекой с именем dpath, показывающий, как она может упростить что-то немного более сложное:

>>> dd = {
...     'fruits': [{'value': 'apple', 'blah': 2}, {'value': 'banana', 'blah': 3}],
...     'vehicles': [{'value': 'cars', 'blah':4}]}

>>> {key: [{'value': d['value']} for d in value] for key, value in dd.items()}
{'fruits': [{'value': 'apple'}, {'value': 'banana'}],
 'vehicles': [{'value': 'cars'}]}

>>> dpath.util.search(dd, '*/*/value')
{'fruits': [{'value': 'apple'}, {'value': 'banana'}],
 'vehicles': [{'value': 'cars'}]}

Или, используя jsonpath-ng:

>>> [d['value'] for key, value in dd.items() for d in value]
['apple', 'banana', 'cars']
>>> [m.value for m in jsonpath_ng.parse('*.[*].value').find(dd)]
['apple', 'banana', 'cars']

На первый взгляд это может показаться не таким простым, потому что find возвращает объекты соответствия, которые включают в себя все виды вещей, кроме только совпадающего значения, например путь непосредственно к каждому элементу. Но для более сложных выражений возможность указать путь типа '*.[*].value' вместо условия понимания для каждого * может иметь большое значение. Кроме того, JSONPath является независимой от языка спецификацией, и даже есть онлайн-тестеры , которые могут быть очень удобны для отладки.

Answer 5

Я думаю, что простое, как показано ниже, даст вам то, что вы ищете.

In[5]: ll = [{'value': 'apple', 'blah': 2}, {'value': 'banana', 'blah': 3} , {'value': 'cars', 'blah':4}]
In[6]: ld = [d.get('value', None) for d in ll]
In[7]: ld
Out[7]: ['apple', 'banana', 'cars']

Вы также можете сделать это с помощью комбинации map и lambda, но понимание списка выглядит более элегантнои pythonic.

Для меньшего входного списка понимание - путь, но если вход действительно большой, тогда я предполагаю, что генераторы - идеальный путь.

In[11]: gd = (d.get('value', None) for d in ll)
In[12]: gd
Out[12]: <generator object <genexpr> at 0x7f5774568b10>
In[13]: '-'.join(gd)
Out[13]: 'apple-banana-cars'

Вот сравнение всехвозможные решения для большего ввода

 In[2]: l = [{'value': 'apple', 'blah': 2}, {'value': 'banana', 'blah': 3} , {'value': 'cars', 'blah':4}] * 9000000
In[3]: def gen_version():
  ...:     for i in l:
  ...:         yield i.get('value', None)
  ...: 
In[4]: def list_comp_verison():
  ...:     return [i.get('value', None) for i in l]
  ...: 
In[5]: def list_verison():
  ...:     ll = []
  ...:     for i in l:
  ...:         ll.append(i.get('value', None))
  ...:     return ll
In[10]: def map_lambda_version():
   ...:      m = map(lambda i:i.get('value', None), l)
   ...:      return m
   ...: 
In[11]: %timeit gen_version()
172 ns ± 0.393 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
In[12]: %timeit map_lambda_version()
203 ns ± 2.31 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
In[13]: %timeit list_comp_verison()
1.61 s ± 20.4 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
In[14]: %timeit list_verison()
2.29 s ± 4.58 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

Как вы можете видеть, генераторы являются лучшим решением по сравнению с другими, карта также медленнее по сравнению с генератором, поэтому я оставлю до OP, чтобы выяснить.

Answer 6

Следуйте примеру -

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

Answer 7

Очень простой способ сделать это:

list1=['']
j=0
for i in com_list:
    if j==0:
        list1[0]=(i['value'])
    else:
        list1.append(i['value'])
    j+=1

Выход:

['яблоко', 'банан', 'автомобили']