dict 목록에서 값 목록 가져오기

dict 목록에서 값 목록 가져오기

다음과 같은 딕트 목록이 있습니다.

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

나는 되고 싶다.['apple', 'banana', 'cars']

어떻게 하면 좋을까요?

모든 딕트에는value키는 쓸 수 있습니다(목록이 명명된 경우).l)

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

한다면value찾을 수 없을 수도 있습니다.

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

map() 및 lambda 함수를 사용하여 이를 수행하는 다른 방법은 다음과 같습니다.

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

여기서 i는 리스트입니다.저는 이런 식으로 "가장 섹시하다"고 생각하지만, 저는 목록 이해력을 사용해서 그렇게 할 것입니다.

업데이트: 'value'가 주요 용도로 누락될 수 있는 경우:

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

업데이트: 저도 람다를 별로 좋아하지 않습니다.이름을 붙이는 것을 좋아합니다.이 점을 염두에 두고 하는 방법은 다음과 같습니다.

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

저는 더 나아가 제가 달성하고자 하는 것을 명확하게 말할 수 있는 유일한 기능을 만들 것입니다.

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

Python 3에서는 이후map반복기를 반환합니다. 사용list예를 들어 목록을 반환한다.list(map(operator.itemgetter('value'), l)).

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

이와 같이 매우 간단한 경우라면, 이스마일 바다위의 답변과 같이 이해력이 분명히 바람직한 방법입니다.

하지만 일이 더 복잡해져서 복잡한 표현이 포함된 다중 절 또는 중첩된 이해의 작성을 시작해야 할 때는 다른 대안을 생각해 볼 가치가 있습니다.JSONPath, DPath, KVC 등 네스트된 딕트 앤 리스트 구조에서 XPath 스타일의 검색을 지정하는 표준 방법이 몇 가지 있습니다.PyPI에는 이들을 위한 멋진 라이브러리가 있습니다.

라이브러리의 예를 다음에 나타냅니다.이 예에서는, 보다 복잡한 것을 심플하게 하는 방법을 나타냅니다.

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

또는 다음을 사용합니다.

>>> [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는 언어에 구애받지 않는 사양으로 디버깅에 매우 편리한 온라인 테스터도 있습니다.

저는 아래와 같이 간단하게 당신이 찾고 있는 것을 얻을 수 있을 것이라고 생각합니다.

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하지만 목록 이해는 더 우아하고 피조어처럼 보입니다.

입력목록의 크기가 작을 경우 이해가 가능하지만 입력이 매우 크다면 제너레이터가 이상적인 방법이라고 생각합니다.

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에 의한 판단은 맡기겠습니다.

목록 이해 사용

입력:

d = [{'value': 'apple', 'blah': 2}, {'value': 'banana', 'blah': 3}, {'value': 'cars', 'blah': 4}]
    
        
values = [i['value'] for i in d]

print(values)

출력:

['apple', 'banana', 'cars']

예를 따르세요 --

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

python 사전 목록에서 키 값을 가져오시겠습니까?

1. python 사전 목록에서 키 값을 가져오시겠습니까?

예:

data = 
[{'obj1':[{'cpu_percentage':'15%','ram':3,'memory_percentage':'66%'}]},
{'obj2': [{'cpu_percentage':'0','ram':4,'memory_percentage':'35%'}]}]

d의 데이터:

  for key,value in d.items(): 

      z ={key: {'cpu_percentage': d['cpu_percentage'],'memory_percentage': d['memory_percentage']} for d in value} 
      print(z)

출력:

{'obj1': {'cpu_percentage': '15%', 'memory_percentage': '66%'}}
{'obj2': {'cpu_percentage': '0', 'memory_percentage': '35%'}}

이거 한번 입어보세요.

d =[{'value': 'apple', 'blah': 2},  {'value': 'banana', 'blah': 3} , {'value': 
'cars', 'blah': 4}] 
b=d[0]['value']
c=d[1]['value']
d=d[2]['value']
new_list=[b,c,d]
print(new_list)

출력:

['apple', 'banana', 'cars']

매우 간단한 방법은 다음과 같습니다.

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

출력:

['apple' 'cars']

언급URL : https://stackoverflow.com/questions/7271482/getting-a-list-of-values-from-a-list-of-dicts