Saya memiliki daftar dicts seperti ini:
[{'value': 'apple', 'blah': 2},
{'value': 'banana', 'blah': 3} ,
{'value': 'cars', 'blah': 4}]
Aku ingin ['apple', 'pisang', 'mobil']
Whats cara terbaik untuk melakukan hal ini?
Berikut ini's cara lain untuk melakukannya dengan menggunakan peta() dan lambda fungsi:
>>> map(lambda d: d['value'], l)
dimana l adalah daftar. Saya melihat cara ini "terseksi", tapi saya akan melakukannya dengan menggunakan daftar pemahaman.
Update: Dalam kasus yang 'nilai' mungkin hilang sebagai kunci yang digunakan:
>>> map(lambda d: d.get('value', 'default value'), l)
Update: saya'm juga bukan penggemar besar dari lambdas, saya lebih suka untuk menyebutkan hal-hal... ini adalah cara yang akan saya lakukan dengan itu dalam pikiran:
>>> import operator
>>> map(operator.itemgetter('value'), l)
Aku bahkan akan pergi lebih jauh dan membuat satu-satunya fungsi yang secara eksplisit mengatakan apa yang ingin saya capai:
>>> import operator, functools
>>> get_values = functools.partial(map, operator.itemgetter('value'))
>>> get_values(l)
... [<list of values>]
Dengan Python 3, karena peta
mengembalikan sebuah iterator, gunakan daftar
untuk kembali ke daftar, misal daftar(peta(operator.itemgetter('nilai'), l))
.
Untuk kasus sederhana seperti ini, pemahaman, seperti di Ismail Badawi's jawaban adalah pasti cara untuk pergi.
Tapi ketika hal-hal menjadi lebih rumit, dan anda perlu untuk mulai menulis multi-klausul atau bersarang pemahaman dengan ekspresi yang kompleks di dalamnya, it's layak melihat ke alternatif lain. Ada beberapa yang berbeda (quasi)cara standar untuk menentukan XPath-style pencarian di bersarang dict-dan-daftar struktur, seperti JSONPath, DPath, dan KVC. Dan tidak ada perpustakaan di PyPI untuk mereka.
Berikut ini's contoh dengan perpustakaan bernama dpath
, menunjukkan bagaimana hal ini dapat menyederhanakan sesuatu yang hanya sedikit lebih rumit:
>>> 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'}]}
Atau, menggunakan 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']
Yang satu ini mungkin tidak terlihat cukup sederhana pada pandangan pertama, karena menemukan
kembali benda pertandingan, yang mencakup semua jenis hal-hal selain hanya cocok nilai, seperti jalan langsung ke masing-masing item. Tapi untuk ekspresi yang lebih rumit, mampu menentukan jalan seperti'*.[*].nilai'
bukan pemahaman klausul untuk masing-masing *
dapat membuat perbedaan besar. Plus, JSONPath adalah bahasa-agnostik spesifikasi, dan bahkan ada online penguji yang dapat menjadi sangat berguna untuk debugging.
Mendapatkan nilai-nilai kunci dari daftar kamus dalam python?
Ex:
data =
[{'obj1':[{'cpu_percentage':'15%','ram':3,'memory_percentage':'66%'}]},
{'obj2': [{'cpu_percentage':'0','ram':4,'memory_percentage':'35%'}]}]
untuk d data:
for key,value in d.items():
z ={key: {'cpu_percentage': d['cpu_percentage'],'memory_percentage': d['memory_percentage']} for d in value}
print(z)
Output:
{'obj1': {'cpu_percentage': '15%', 'memory_percentage': '66%'}}
{'obj2': {'cpu_percentage': '0', 'memory_percentage': '35%'}}
Saya berpikir sederhana seperti di bawah ini akan memberikan apa yang anda cari.
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']
Anda dapat melakukan ini dengan kombinasi dari peta
dan lambda
juga tapi daftar pemahaman terlihat lebih elegan dan pythonic.
Untuk input yang lebih kecil daftar pemahaman adalah cara untuk pergi tetapi jika masukan adalah benar-benar besar maka saya kira generator adalah cara yang 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'
Berikut ini adalah perbandingan dari semua solusi yang mungkin untuk input yang lebih besar
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)
Seperti yang anda lihat, generator adalah solusi yang lebih baik dibandingkan dengan yang lain, peta juga lebih lambat dibandingkan dengan generator untuk alasan aku akan meninggalkan terserah OP untuk mencari tahu.
Ikuti contoh --
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))))