python - मैं पायथन में शब्दकोश के मूल्यों से शब्दकोशों की सूची कैसे क्रमबद्ध करूं?




list sorting (12)

मुझे शब्दकोशों की एक सूची मिली है और चाहते हैं कि उस शब्दकोश के मूल्य से क्रमबद्ध किया जाए।

इस

[{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}]

नाम से क्रमबद्ध, बनना चाहिए

[{'name':'Bart', 'age':10}, {'name':'Homer', 'age':39}]

आइए कहें कि मैं नीचे तत्वों के साथ एक शब्दकोश डी है। नीचे दिए गए कस्टम फ़ंक्शन को पास करने के लिए क्रमबद्ध कुंजी तर्क का उपयोग करने के लिए

D = {'eggs': 3, 'ham': 1, 'spam': 2}

def get_count(tuple):
    return tuple[1]

sorted(D.items(), key = get_count, reverse=True)
or
sorted(D.items(), key = lambda x: x[1], reverse=True)  avoiding get_count function call

https://wiki.python.org/moin/HowTo/Sorting/#Key_Functions


आप कस्टम तुलना फ़ंक्शन का उपयोग कर सकते हैं, या आप उस फ़ंक्शन में पास कर सकते हैं जो एक कस्टम सॉर्ट कुंजी की गणना करता है। आमतौर पर यह अधिक कुशल होता है क्योंकि कुंजी केवल प्रति आइटम एक बार गणना की जाती है, जबकि तुलना समारोह को कई बार बुलाया जाएगा।

आप इसे इस तरह से कर सकते हैं:

def mykey(adict): return adict['name']
x = [{'name': 'Homer', 'age': 39}, {'name': 'Bart', 'age':10}]
sorted(x, key=mykey)

लेकिन मानक पुस्तकालय में मनमानी वस्तुओं की वस्तुएं प्राप्त करने के लिए एक सामान्य दिनचर्या होती है: itemgetter । तो इसके बजाय इसे आजमाएं:

from operator import itemgetter
x = [{'name': 'Homer', 'age': 39}, {'name': 'Bart', 'age':10}]
sorted(x, key=itemgetter('name'))

कभी-कभी हमें lower() उदाहरण के लिए उपयोग करने की आवश्यकता होती है

lists = [{'name':'Homer', 'age':39},
  {'name':'Bart', 'age':10},
  {'name':'abby', 'age':9}]

lists = sorted(lists, key=lambda k: k['name'])
print(lists)
# [{'name':'Bart', 'age':10}, {'name':'Homer', 'age':39}, {'name':'abby', 'age':9}]

lists = sorted(lists, key=lambda k: k['name'].lower())
print(lists)
# [ {'name':'abby', 'age':9}, {'name':'Bart', 'age':10}, {'name':'Homer', 'age':39}]

पर्ल से श्वार्टज़ियन परिवर्तन का उपयोग करना,

py = [{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}]

कर

sort_on = "name"
decorated = [(dict_[sort_on], dict_) for dict_ in py]
decorated.sort()
result = [dict_ for (key, dict_) in decorated]

देता है

>>> result
[{'age': 10, 'name': 'Bart'}, {'age': 39, 'name': 'Homer'}]

पर्ल श्वार्टज़ियन पर अधिक परिवर्तन

कंप्यूटर विज्ञान में, श्वार्टज़ियन ट्रांसफॉर्म एक पर्ल प्रोग्रामिंग मुहावरे है जो वस्तुओं की सूची को क्रमबद्ध करने की दक्षता में सुधार करने के लिए उपयोग किया जाता है। यह मुहावरा तुलना-आधारित सॉर्टिंग के लिए उपयुक्त है जब ऑर्डरिंग वास्तव में तत्वों की एक निश्चित संपत्ति (कुंजी) के क्रम पर आधारित होती है, जहां उस संपत्ति की गणना करना एक गहन ऑपरेशन होता है जिसे कम से कम कई बार किया जाना चाहिए। श्वार्टज़ियन ट्रांसफॉर्म उल्लेखनीय है कि यह नामित अस्थायी सरणी का उपयोग नहीं करता है।


मुझे लगता है कि आपका मतलब है:

[{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}]

यह इस तरह हल किया जाएगा:

sorted(l,cmp=lambda x,y: cmp(x['name'],y['name']))

मैंने ऐसा कुछ करने की कोशिश की:

my_list.sort(key=lambda x: x['name'])

यह पूर्णांक के लिए भी काम किया।


यदि आपको dictionaries की मूल list की आवश्यकता नहीं है, तो आप कस्टम कुंजी फ़ंक्शन का उपयोग करके sort() विधि के साथ इन-प्लेस को संशोधित कर सकते हैं।

मुख्य समारोह:

def get_name(d):
    """ Return the value of a key in a dictionary. """

    return d["name"]

सॉर्ट करने की list :

data_one = [{'name': 'Homer', 'age': 39}, {'name': 'Bart', 'age': 10}]

इसे जगह में छंटनी:

data_one.sort(key=get_name)

यदि आपको मूल list की आवश्यकता है, तो sorted() फ़ंक्शन को list और कुंजी फ़ंक्शन पास करके कॉल करें, फिर वापस किए गए क्रमबद्ध list को एक नए चर पर असाइन करें:

data_two = [{'name': 'Homer', 'age': 39}, {'name': 'Bart', 'age': 10}]
new_data = sorted(data_two, key=get_name)

प्रिंटिंग data_one और new_data

>>> print(data_one)
[{'name': 'Bart', 'age': 10}, {'name': 'Homer', 'age': 39}]
>>> print(new_data)
[{'name': 'Bart', 'age': 10}, {'name': 'Homer', 'age': 39}]

यह एक cmp के बजाय एक कुंजी का उपयोग कर क्लीनर देख सकते हैं:

newlist = sorted(list_to_be_sorted, key=lambda k: k['name']) 

या जेएफएसबेस्टियन और अन्य ने सुझाव दिया है,

from operator import itemgetter
newlist = sorted(list_to_be_sorted, key=itemgetter('name')) 

पूर्णता के लिए (जैसा कि fitzgeraldsteele द्वारा टिप्पणियों में बताया गया है), अवरोही क्रमबद्ध करने के लिए reverse=True जोड़ें

newlist = sorted(l, key=itemgetter('name'), reverse=True)


a = [{'name':'Homer', 'age':39}, ...]

# This changes the list a
a.sort(key=lambda k : k['name'])

# This returns a new list (a is not modified)
sorted(a, key=lambda k : k['name']) 

import operator
a_list_of_dicts.sort(key=operator.itemgetter('name'))

'कुंजी' का उपयोग मनमाना मूल्य और 'itemgetter' सेट द्वारा क्रमबद्ध करने के लिए किया जाता है जो प्रत्येक आइटम के 'नाम' विशेषता के लिए मूल्यवान होता है।


my_list = [{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}]

my_list.sort(lambda x,y : cmp(x['name'], y['name']))

my_list अब आप जो चाहते हैं my_list होगा।

(3 साल बाद) जोड़ने के लिए संपादित:

नया key तर्क अधिक कुशल और neater है। एक बेहतर जवाब अब इस तरह दिखता है:

my_list = sorted(my_list, key=lambda k: k['name'])

... लैम्ब्डा है, आईएमओ, ऑपरेटर.इटमेटेटर से समझने में आसान है, लेकिन वाईएमएमवी।





data-structures