ডিক্টের একটি তালিকা থেকে মানগুলির একটি তালিকা পাওয়া

Question

আমার কাছে এর মতো নালাগুলির একটি তালিকা রয়েছে:

[{'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 ("কী_ট_লুপআপ", "বিকল্প_মূল্য") ব্যবহার করতে পারে। তারপরে, এটি দেখতে পাবেন: [d.get ('মান', 'Alt') for d in l] মানটি কী হিসাবে উপস্থিত না থাকলে এটি কেবল 'Alt' ফেরত দেয়।

— অভিনব

সমাধানের জন্য ধন্যবাদ

— অজয় কুমার

এই "ম্যাজিক" তালিকা ধী হিসাবে পরিচিত হয় docs.python.org/3/tutorial/...

— উইলিয়াম Ardila

Answer 2

মানচিত্র () এবং ল্যাম্বদা ফাংশন ব্যবহার করে এটি করার আরও একটি উপায় এখানে রয়েছে:

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

যেখানে আমি তালিকা। আমি এইভাবে "সেক্সিয়েস্ট" দেখছি, তবে আমি তালিকা বোধগম্যতা ব্যবহার করে এটি করব would

আপডেট: যদি সেই 'মান' মূল ব্যবহার হিসাবে নিখোঁজ থাকে:

>>> 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')? এটি মিছাল নয়, @ ইসদাবির দ্বিতীয় তালিকা অনুধাবনের সমান হবে।

— এগ্রেফ

হ্যাঁ, দুঃখিত, আমি পেয়েছিলাম। এবং আমি এটিকে এমন কিছু হিসাবে বোঝাতে চাইছি যা কীটি অনুপস্থিত থাকলে ব্যতিক্রম করবে না। তবে @ ইসবাদাবীর সমাধানটি আরও ভাল কারণ পাওয়ার () যখন কীটি নিখোঁজ থাকে তখন কিছুই সরবরাহ করা হয় না (বা আমরা ডিফল্ট হিসাবে নির্দিষ্ট করে যাই)।

— rplnt

Answer 4

এর মতো খুব সাধারণ মামলার জন্য, বোধগম্যতা যেমন, ইসমাইল বাদামীর উত্তর অবশ্যই যাওয়ার উপায়।

তবে যখন জিনিসগুলি আরও জটিল হয়ে ওঠে এবং আপনার মধ্যে জটিল অভিব্যক্তিগুলির সাথে মাল্টি-ক্লজ বা নেস্টেড বোধগম্যগুলি লেখা শুরু করা দরকার তখন এটি অন্যান্য বিকল্পগুলির দিকে তাকাতে মূল্যবান। নেস্টেড ডিক-অ্যান্ড-লিস্ট স্ট্রাকচার, যেমন জেএসওনপথ, ডিপ্যাথ এবং কেভিসিতে এক্সপথ-স্টাইল অনুসন্ধানগুলি নির্দিষ্ট করার জন্য কয়েকটি পৃথক (কোয়াসি) মানক উপায় রয়েছে। এবং তাদের জন্য পিপিআইতে দুর্দান্ত লাইব্রেরি রয়েছে।

নামকৃত লাইব্রেরিটির সাথে এখানে উদাহরণ রয়েছে যা 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'ভাবের জন্য, প্রত্যেকের জন্য বোঝার ধারাটির পরিবর্তে একটি পথ নির্দিষ্ট করতে সক্ষম হওয়া *একটি বড় পার্থক্য করতে পারে। প্লাস, জেএসওনপথ একটি ভাষা-অজ্ঞাত সম্পর্কিত স্পেসিফিকেশন এবং এমন কোনও অনলাইন পরীক্ষকও রয়েছে যা ডিবাগিংয়ের জন্য খুব কার্যকর হতে পারে।

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

ডেটা জন্য ডি:

  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

আউটপুট:

['আপেল', 'কলা', 'গাড়ি']