मेरे पास शब्दकोशों की एक सूची है और चाहते हैं कि प्रत्येक आइटम को एक विशिष्ट संपत्ति मूल्यों द्वारा क्रमबद्ध किया जाए।
नीचे दिए गए सरणी को ध्यान में रखें,
[{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}]जब क्रमबद्ध nameहो जाए, बन जाना चाहिए
[{'name':'Bart', 'age':10}, {'name':'Homer', 'age':39}]जवाबों:
यह एक cmp के बजाय एक कुंजी का उपयोग करके क्लीनर दिख सकता है:
newlist = sorted(list_to_be_sorted, key=lambda k: k['name']) या JFSebastian और अन्य लोगों ने सुझाव दिया,
from operator import itemgetter
newlist = sorted(list_to_be_sorted, key=itemgetter('name')) पूर्णता के लिए (जैसा कि fitzgeraldsteele द्वारा टिप्पणियों में बताया गया है), reverse=Trueअवरोही क्रम में जोड़ें
newlist = sorted(l, key=itemgetter('name'), reverse=True)itemgetter(i)जहां iपर सॉर्ट करने के लिए टपल तत्व का सूचकांक है।
itemgetterएक से अधिक तर्क स्वीकार करता है: itemgetter(1,2,3)एक ऐसा कार्य है जो एक टपल को वापस लौटाता है obj[1], obj[2], obj[3], इसलिए आप इसका उपयोग जटिल प्रकार से करने के लिए कर सकते हैं।
import operatorकुंजी = 'नाम' द्वारा शब्दकोशों की सूची को क्रमबद्ध करने के लिए:
list_of_dicts.sort(key=operator.itemgetter('name'))कुंजी = 'आयु' द्वारा शब्दकोशों की सूची को क्रमबद्ध करने के लिए:
list_of_dicts.sort(key=operator.itemgetter('age'))key=lambda k: (k['name'], k['age'])। (या key=itemgetter('name', 'age'))। टपल की cmpबारी में प्रत्येक तत्व की तुलना करेंगे। यह शानदार है।
keyतर्क list.sort()का वर्णन नहीं किया गया है। किसी भी विचार है कि कहाँ खोजने के लिए?
list।
my_list = [{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}]
my_list.sort(lambda x,y : cmp(x['name'], y['name']))my_list अब वही होगा जो आप चाहते हैं।
(3 वर्ष बाद) जोड़ने के लिए संपादित:
नया keyतर्क अधिक कुशल और निरर्थक है। एक बेहतर जवाब अब जैसा दिखता है:
my_list = sorted(my_list, key=lambda k: k['name'])... लंबोदर, IMO, समझने में आसान है operator.itemgetter, लेकिन YMMV।
यदि आप कई कुंजियों द्वारा सूची को क्रमबद्ध करना चाहते हैं, तो आप निम्न कार्य कर सकते हैं:
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']))यह बजाय हैकिश है, क्योंकि यह तुलना के लिए एकल स्ट्रिंग प्रतिनिधित्व में मूल्यों को परिवर्तित करने पर निर्भर करता है, लेकिन यह नकारात्मक सहित संख्याओं के लिए अपेक्षित के रूप में काम करता है (हालांकि यदि आप संख्याओं का उपयोग कर रहे हैं तो आपको अपने स्ट्रिंग को शून्य पैडिंग के साथ उचित रूप से प्रारूपित करने की आवश्यकता होगी)
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']) मुझे लगता है कि आप का मतलब है:
[{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}]इसे इस तरह हल किया जाएगा:
sorted(l,cmp=lambda x,y: cmp(x['name'],y['name']))आप एक कस्टम तुलना फ़ंक्शन का उपयोग कर सकते हैं, या आप एक फ़ंक्शन में पास हो सकते हैं जो एक कस्टम सॉर्ट कुंजी की गणना करता है। यह आमतौर पर अधिक कुशल होता है क्योंकि कुंजी केवल एक बार प्रति आइटम की गणना की जाती है, जबकि तुलनात्मक फ़ंक्शन को कई बार कहा जाता है।
आप इसे इस तरह से कर सकते हैं:
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'))पर्ल से श्वार्टज़ियन परिवर्तन का उपयोग करना,
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'}]पर्ल स्क्वार्ट्जियन ट्रांसफॉर्म पर अधिक
कंप्यूटर विज्ञान में, श्वार्ट्ज़ियन ट्रांसफ़ॉर्म एक पर्ल प्रोग्रामिंग मुहावरा है जिसका उपयोग वस्तुओं की सूची को छाँटने की दक्षता में सुधार के लिए किया जाता है। यह मुहावरे तुलना-आधारित छँटाई के लिए उपयुक्त है जब आदेश वास्तव में तत्वों की एक निश्चित संपत्ति (कुंजी) के आदेश पर आधारित होता है, जहाँ उस संपत्ति की गणना एक गहन ऑपरेशन है जिसे कम से कम कई बार किया जाना चाहिए। श्वार्ट्ज़ियन ट्रांसफ़ॉर्म उल्लेखनीय है कि यह अस्थायी सरणियों का उपयोग नहीं करता है।
key=लिए समर्थन किया है .sort, वह वर्ष 2004 है, यह सी में कोडिंग कोड के भीतर श्वार्टज़ियन रूपांतरण करता है; इस प्रकार यह विधि केवल पायथन 2.0-2.3 पर उपयोगी है। जिनमें से सभी 12 साल से अधिक पुराने हैं।
आपको अपने स्वयं के तुलनात्मक फ़ंक्शन को लागू करना होगा जो शब्दकोशों की नाम कुंजियों के मूल्यों से तुलना करेंगे। PythonInfo Wiki से सॉर्टिंग मिनी-कैसे देखें
कभी-कभी हमें 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}]यहां वैकल्पिक सामान्य समाधान है - यह कुंजी और मूल्यों द्वारा तानाशाही के तत्वों को हल करता है। इसका लाभ - चाबियाँ निर्दिष्ट करने की आवश्यकता नहीं है, और यह तब भी काम करेगा जब कुछ कुंजी कुछ शब्दकोशों में गायब हैं।
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)पांडा पैकेज का उपयोग करना एक अन्य विधि है, हालांकि यह बड़े पैमाने पर रनटाइम है, दूसरों द्वारा प्रस्तावित अधिक पारंपरिक तरीकों की तुलना में बहुत धीमा है:
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यदि आपको मूल listकी आवश्यकता नहीं है dictionaries, तो आप इसे 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}]मान लीजिए कि मेरे पास Dनीचे तत्वों के साथ एक शब्दकोश है । नीचे के रूप में कस्टम फ़ंक्शन को पास करने के लिए सॉर्ट किए गए मुख्य तर्क का उपयोग करने के लिए:
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चेक इस बाहर।
मैं फ़िल्टर w / lambda का एक बड़ा प्रशंसक रहा हूं, लेकिन समय की जटिलता पर विचार करें तो यह सबसे अच्छा विकल्प नहीं है
पहला विकल्प
sorted_list = sorted(list_to_sort, key= lambda x: x['name'])
# returns list of valuesदूसरा विकल्प
list_to_sort.sort(key=operator.itemgetter('name'))
#edits the list, does not return a new listनिष्पादन समय की तेज तुलना
# First option
python3.6 -m timeit -s "list_to_sort = [{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}, {'name':'Faaa', 'age':57}, {'name':'Errr', 'age':20}]" -s "sorted_l=[]" "sorted_l = sorted(list_to_sort, key=lambda e: e['name'])"1000000 छोरों, 3 का सबसे अच्छा: 0.736 usec प्रति पाश
# Second option
python3.6 -m timeit -s "list_to_sort = [{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}, {'name':'Faaa', 'age':57}, {'name':'Errr', 'age':20}]" -s "sorted_l=[]" -s "import operator" "list_to_sort.sort(key=operator.itemgetter('name'))"1000000 लूप, 3 का सर्वश्रेष्ठ: 0.438 usec प्रति लूप
यदि प्रदर्शन एक चिंता का विषय है, तो मैं operator.itemgetterइसके बजाय उपयोग करूँगा lambdaजैसे कि अंतर्निहित कार्य हाथ से तैयार किए गए कार्यों की तुलना में तेज़ी से करते हैं। itemgetterसमारोह लगभग 20% से अधिक तेजी से प्रदर्शन करने के लिए लगता है lambdaमेरी परीक्षण पर आधारित।
से https://wiki.python.org/moin/PythonSpeed :
इसी तरह, अंतर्निहित कार्य हाथ से निर्मित समकक्षों की तुलना में तेजी से चलते हैं। उदाहरण के लिए, मानचित्र (संचालक। Vd, v1, v2) मानचित्र (लंबो x, y: x + y, v1, v2) से तेज है।
यहाँ lambdaबनाम का उपयोग कर छँटाई गति की तुलना है itemgetter।
import random
import operator
# create a list of 100 dicts with random 8-letter names and random ages from 0 to 100.
l = [{'name': ''.join(random.choices(string.ascii_lowercase, k=8)), 'age': random.randint(0, 100)} for i in range(100)]
# Test the performance with a lambda function sorting on name
%timeit sorted(l, key=lambda x: x['name'])
13 µs ± 388 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
# Test the performance with itemgetter sorting on name
%timeit sorted(l, key=operator.itemgetter('name'))
10.7 µs ± 38.1 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
# Check that each technique produces same sort order
sorted(l, key=lambda x: x['name']) == sorted(l, key=operator.itemgetter('name'))
Trueदोनों तकनीक समान क्रम में सूची को सॉर्ट करती हैं (कोड ब्लॉक में अंतिम विवरण के निष्पादन द्वारा सत्यापित) लेकिन एक थोड़ा तेज है।
[{'name':'Bart', 'age':10, 'note':3},{'name':'Homer','age':10,'note':2},{'name':'Vasile','age':20,'note':3}]और उपयोग करने के लिए:from operator import itemgetter newlist = sorted(old_list, key=itemgetter(-'note','name')EDIT: परीक्षण किया गया है, और यह काम कर रहा है, लेकिन मैं इसे DES DES और ASC का नाम नोट करना नहीं जानता।