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




list sorting (14)

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

इस

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

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

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

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

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


पांडा पैकेज का उपयोग करना एक और तरीका है, हालांकि यह बड़े पैमाने पर रनटाइम दूसरों द्वारा प्रस्तावित अधिक पारंपरिक तरीकों की तुलना में बहुत धीमी है:

import pandas as pd

listOfDicts = [{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}]
df = pd.DataFrame(listOfDicts)
df = df.sort_values('name')
sorted_listOfDicts = df.T.to_dict().values()

यहां एक छोटी सूची और डिक्ट्स की एक बड़ी (100k +) सूची के लिए कुछ बेंचमार्क मान दिए गए हैं:

setup_large = "listOfDicts = [];\
[listOfDicts.extend(({'name':'Homer', 'age':39}, {'name':'Bart', 'age':10})) for _ in range(50000)];\
from operator import itemgetter;import pandas as pd;\
df = pd.DataFrame(listOfDicts);"

setup_small = "listOfDicts = [];\
listOfDicts.extend(({'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}));\
from operator import itemgetter;import pandas as pd;\
df = pd.DataFrame(listOfDicts);"

method1 = "newlist = sorted(listOfDicts, key=lambda k: k['name'])"
method2 = "newlist = sorted(listOfDicts, key=itemgetter('name')) "
method3 = "df = df.sort_values('name');\
sorted_listOfDicts = df.T.to_dict().values()"

import timeit
t = timeit.Timer(method1, setup_small)
print('Small Method LC: ' + str(t.timeit(100)))
t = timeit.Timer(method2, setup_small)
print('Small Method LC2: ' + str(t.timeit(100)))
t = timeit.Timer(method3, setup_small)
print('Small Method Pandas: ' + str(t.timeit(100)))

t = timeit.Timer(method1, setup_large)
print('Large Method LC: ' + str(t.timeit(100)))
t = timeit.Timer(method2, setup_large)
print('Large Method LC2: ' + str(t.timeit(100)))
t = timeit.Timer(method3, setup_large)
print('Large Method Pandas: ' + str(t.timeit(1)))

#Small Method LC: 0.000163078308105
#Small Method LC2: 0.000134944915771
#Small Method Pandas: 0.0712950229645
#Large Method LC: 0.0321750640869
#Large Method LC2: 0.0206089019775
#Large Method Pandas: 5.81405615807

यह एक 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)

import operator

कुंजी = 'नाम' द्वारा शब्दकोशों की सूची को सॉर्ट करने के लिए:

list_of_dicts.sort(key=operator.itemgetter('name'))

कुंजी = 'आयु' द्वारा शब्दकोशों की सूची क्रमबद्ध करने के लिए:

list_of_dicts.sort(key=operator.itemgetter('age'))

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

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


यदि आपको 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}]


कभी-कभी हमें 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}]

यदि आप सूची को एकाधिक कुंजियों से सॉर्ट करना चाहते हैं तो आप निम्न कार्य कर सकते हैं:

my_list = [{'name':'Homer', 'age':39}, {'name':'Milhouse', 'age':10}, {'name':'Bart', 'age':10} ]
sortedlist = sorted(my_list , key=lambda elem: "%02d %s" % (elem['age'], elem['name']))

यह बदले में हैकिश है, क्योंकि यह मानों को तुलना के लिए एक स्ट्रिंग प्रस्तुति में परिवर्तित करने पर निर्भर करता है, लेकिन यह नकारात्मक लोगों सहित संख्याओं के लिए अपेक्षित काम करता है (हालांकि यदि आप संख्याओं का उपयोग कर रहे हैं तो आपको शून्य स्ट्रिंग के साथ उचित रूप से अपनी स्ट्रिंग को प्रारूपित करने की आवश्यकता होगी)



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

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

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

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

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

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

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


यहां वैकल्पिक सामान्य समाधान है - यह कुंजी और मूल्यों से dict के तत्वों को प्रकार देता है। इसका लाभ - कुंजी निर्दिष्ट करने की कोई आवश्यकता नहीं है, और यह अभी भी काम करेगा यदि कुछ शब्दकोशों में कुछ कुंजियां गायब हैं।

def sort_key_func(item):
    """ helper function used to sort list of dicts

    :param item: dict
    :return: sorted list of tuples (k, v)
    """
    pairs = []
    for k, v in item.items():
        pairs.append((k, v))
    return sorted(pairs)
sorted(A, key=sort_key_func)




data-structures