Dicts की सूची से मूल्यों की एक सूची प्राप्त करना

Question

मैं इस तरह से dicts की एक सूची है:

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

मुझे चाहिए ['apple', 'banana', 'cars']

ऐसा करने का सबसे अच्छा तरीका क्या है?

Answer 1

यह मानते हुए कि हर तानाशाह के पास एक valueकुंजी है, आप लिख सकते हैं (यह मानते हुए कि आपकी सूची का नाम है l)

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

यदि valueआप गायब हो सकते हैं, तो आप उपयोग कर सकते हैं

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

Comments

एक कुंजी के लिए लापता मूल्य का इलाज करने के लिए, कोई भी d.get ("key_to_lookup", "alternate_valp") का उपयोग कर सकता है। फिर, यह ऐसा दिखेगा: [d.get ('value', 'alt') d में l के लिए]। यदि मान कुंजी के रूप में मौजूद नहीं है, तो यह केवल 'alt' लौटाएगा।

— अभिनव

समाधान के लिए धन्यवाद

— अजय कुमार

इस "मैजिक" को लिस्ट कॉम्प्रिहेंशन docs.python.org/3/tutorial/… के

— विलियम

Answer 2

यह मानचित्र () और लंबो कार्यों का उपयोग करने का एक और तरीका है:

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

पायथन 3 के साथ, mapएक पुनरावर्तक रिटर्न के बाद से list, उदाहरण के लिए, एक सूची वापस करने के लिए उपयोग करें list(map(operator.itemgetter('value'), l))।

Comments

कुल! सूची की समझ यहाँ बहुत अधिक है।

— माइक ग्राहम

यदि आप पहली बार उपयोग करने जा रहे हैं map, तो उपयोग करें operator.itemgetter('value'), नहीं lambda।

— एजीएफ

Answer 3

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

Comments

या [d.getkey ('मान') d के लिए तानाशाही में]

— rplnt

@rpInt उम, ऐसी कोई बात नहीं है getkey.. क्या आपका मतलब है d.get('value')? यह @ के रूप में ही है।

— एजीएफ

हाँ, क्षमा करें, मेरा मतलब था। और मेरा मतलब था कि कुछ ऐसा है जो अपवाद को छोड़ देगा यदि कुंजी गायब नहीं है। लेकिन @ .adadawi का समाधान बेहतर है क्योंकि कुंजी गायब होने पर (या हम जो भी डिफ़ॉल्ट के रूप में निर्दिष्ट करते हैं) कोई भी आपूर्ति करेगा।

— 15

Answer 4

इस तरह के एक बहुत ही साधारण मामले के लिए, एक समझ, इस्माइल बदावी के जवाब में में निश्चित रूप से जाने का रास्ता है।

लेकिन जब चीजें अधिक जटिल हो जाती हैं, और आपको उनमें जटिल अभिव्यक्तियों के साथ बहु-खंड या नेस्टेड कॉम्प्रिहेंशन लिखना शुरू करने की आवश्यकता होती है, तो यह अन्य विकल्पों में देखने लायक है। कुछ अलग (क्वासी-) मानक तरीके हैं जो कि नेस्टेड तानाशाह और सूची संरचनाओं जैसे कि JSONPath, DPath और KVC पर XPath- शैली खोजों को निर्दिष्ट करते हैं। और उनके लिए 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साथ ही साथ सूची बोध भी अधिक सुरुचिपूर्ण और पाइथोनिक लगता है।

एक छोटी इनपुट सूची के लिए समझ में आने का रास्ता है लेकिन अगर इनपुट वास्तव में बड़ा है तो मुझे लगता है कि जनरेटर आदर्श तरीका है।

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)

जैसा कि आप देख सकते हैं, जनरेटर दूसरों की तुलना में एक बेहतर समाधान है, कारण के लिए जनरेटर की तुलना में नक्शा भी धीमा है क्योंकि मैं यह पता लगाने के लिए ओपी तक छोड़ दूंगा।

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

अजगर में शब्दकोशों की सूची से महत्वपूर्ण मान प्राप्त करें?

1. अजगर में शब्दकोशों की सूची से महत्वपूर्ण मान प्राप्त करें?

उदाहरण के लिए:

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

Answer 8

यह करने के लिए एक बहुत ही सरल तरीका है:

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

आउटपुट:

['सेब', 'केला', 'कारें']