Am o lista de previziuni ca aceasta:
[{'value': 'apple', 'blah': 2},
{'value': 'banana', 'blah': 3} ,
{'value': 'cars', 'blah': 4}]
Vreau ['mar', 'banana', 'masinile']
Ce este cel mai bun mod de a face acest lucru?
Aici's un alt mod de a face acest lucru folosind harta() și lambda funcții:
>>> map(lambda d: d['value'], l)
unde l este lista. Eu văd în acest fel "sexy", dar aș face-o folosind lista de înțelegere.
Update: În cazul în care 'valoare' ar putea fi dispărut ca o cheie de utilizare:
>>> map(lambda d: d.get('value', 'default value'), l)
Update: am'm, de asemenea, nu sunt un mare fan de lambda, am prefera să spunem lucrurilor pe nume... asta e ce as face-o cu asta în minte:
>>> import operator
>>> map(operator.itemgetter('value'), l)
Aș merge chiar mai departe și de a crea o singură funcție care în mod explicit spune ceea ce doresc să realizeze:
>>> import operator, functools
>>> get_values = functools.partial(map, operator.itemgetter('value'))
>>> get_values(l)
... [<list of values>]
Cu Python 3, deoarece "harta" se întoarce un iterator, utilizați "lista" pentru a returna o listă, de exemplu, listă(map(operator.itemgetter('valoare'), l))
.
Pentru un caz foarte simplu ca asta, o înțelegere, ca în Ismail raif Badawi's a răspunde este cu siguranta modul de a merge.
Dar când lucrurile devin mai complicate, și aveți nevoie pentru a începe să scrie multi-clauza sau imbricate comprehensions cu expresii complexe în ei, l's valoare de căutați în alte alternative. Există câteva diferite (cvasi-)standard moduri de a specifica XPath-stil căutări pe imbricate dict-și-listă de structuri, cum ar fi JSONPath, DPath, și KVC. Și acolo sunt frumoase biblioteci pe PyPI pentru ei.
Aici's un exemplu cu biblioteca nume dpath
, care arată cum se poate simplifica ceva doar un pic mai complicat:
>>> 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'}]}
Sau, folosind 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']
Asta nu poate arata la fel de simplu la prima vedere, pentru că "găsi" se întoarce meci de obiecte, care include tot felul de lucruri, în afară de valoare potrivire, cum ar fi un drum direct la fiecare element. Dar pentru expresii mai complexe, fiind capabil să specificați o cale ca'*.[*].valoarea'
în loc de o înțelegere clauza pentru fiecare *
poate face o mare diferenta. În Plus, JSONPath este un limbaj-agnostic caietul de sarcini, și există chiar online testere, care poate fi foarte util pentru depanare.
Obține valori-cheie din lista de dicționare în python?
Ex:
data =
[{'obj1':[{'cpu_percentage':'15%','ram':3,'memory_percentage':'66%'}]},
{'obj2': [{'cpu_percentage':'0','ram':4,'memory_percentage':'35%'}]}]
pentru d în date:
for key,value in d.items():
z ={key: {'cpu_percentage': d['cpu_percentage'],'memory_percentage': d['memory_percentage']} for d in value}
print(z)
Ieșire:
{'obj1': {'cpu_percentage': '15%', 'memory_percentage': '66%'}}
{'obj2': {'cpu_percentage': '0', 'memory_percentage': '35%'}}
Cred că la fel de simplu ca mai jos ar oferi ceea ce cauti.
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']
Puteți face acest lucru cu o combinație de "harta" și "lambda" la fel de bine, dar lista de înțelegere arată mai elegant și pythonic.
Pentru o mai mici, lista de intrare înțelegerea este mod de a merge, dar dacă la intrare este foarte mare atunci cred ca generatoare sunt modul ideal.
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'
Aici este o comparație a tuturor soluțiilor posibile pentru o mai mare intrare
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)
După cum puteți vedea, generatoare sunt o soluție mai bună în comparație cu alții, harta este, de asemenea, mai lent comparativ cu generator de motiv, nu voi pleca până la OP sa-mi dau seama.
Urmați exemplul ...
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))))