python - सूचियों/tuples के क्रमबद्ध(सूची/tuple) कैसे क्रमबद्ध करें?




list sorting (7)

@ स्टीफन का जवाब बिंदु पर है! बेहतर दृश्यता के लिए यहां एक उदाहरण दिया गया है,

रेडी प्लेयर वन प्रशंसकों के लिए चिल्लाओ! =)

>>> gunters = [('2044-04-05', 'parzival'), ('2044-04-07', 'aech'), ('2044-04-06', 'art3mis')]
>>> gunters.sort(key=lambda tup: tup[0])
>>> print gunters
[('2044-04-05', 'parzival'), ('2044-04-06', 'art3mis'), ('2044-04-07', 'aech')]

key एक ऐसा फ़ंक्शन है जिसे संग्रह के आइटम्स को तुलना के लिए बदलने के लिए कहा जाएगा .. जैसे जावा में विधि की तुलना करें।

कुंजी पर पारित पैरामीटर कुछ ऐसा होना चाहिए जो कॉल करने योग्य है। यहां, lambda का उपयोग एक अज्ञात फ़ंक्शन बनाता है (जो एक कॉल करने योग्य है)।
लैम्ब्डा का सिंटैक्स शब्द लैम्ब्डा है जिसके बाद एक पुनरावर्तक नाम होता है, फिर कोड का एक ब्लॉक होता है।

उदाहरण के नीचे, हम टुपल की एक सूची को क्रमबद्ध कर रहे हैं जिसमें कुछ घटना और अभिनेता के नाम की जानकारी है।

हम घटना सूची के समय तक इस सूची को क्रमबद्ध कर रहे हैं - जो एक ट्यूपल का 0 वां तत्व है।

नोट - s.sort([cmp[, key[, reverse]]]) जगहों की जगहों को s.sort([cmp[, key[, reverse]]]) है

मेरे पास कुछ डेटा है या तो सूची में सूचियां हैं, या सूची में टुपल्स हैं।

data = [[1,2,3], [4,5,6], [7,8,9]]
data = [(1,2,3), (4,5,6), (7,8,9)]

और मैं सबसेट में दूसरे तत्व द्वारा सॉर्ट करना चाहता हूं। मतलब, 2,5,8 से सॉर्टिंग जहां 2 (1,2,3) से है, 5 (4,5,6) से है। ऐसा करने का आम तरीका क्या है? क्या मुझे अपनी सूची में टुपल्स या सूचियों को स्टोर करना चाहिए? चूंकि टुपल्स अधिक लचीले होते हैं।


अवरुद्ध क्रम में count लिए और वर्णमाला क्रम में word के लिए tuples (<word>, <count>) सूची क्रमबद्ध करने के लिए:

data = [
('betty', 1),
('bought', 1),
('a', 1),
('bit', 1),
('of', 1),
('butter', 2),
('but', 1),
('the', 1),
('was', 1),
('bitter', 1)]

मैं इस विधि का उपयोग करता हूं:

sorted(data, key=lambda tup:(-tup[1], tup[0]))

और यह मुझे परिणाम देता है:

[('butter', 2),
('a', 1),
('betty', 1),
('bit', 1),
('bitter', 1),
('bought', 1),
('but', 1),
('of', 1),
('the', 1),
('was', 1)]

एकाधिक मानदंडों द्वारा क्रमबद्ध करने के लिए, अर्थात् उदाहरण के लिए टुपल में दूसरे और तीसरे तत्वों द्वारा, चलो

data = [(1,2,3),(1,2,1),(1,1,4)]

और इसलिए एक लैम्ब्डा को परिभाषित करें जो उदाहरण के लिए प्राथमिकता का वर्णन करने वाले टुपल को लौटाता है

sorted(data, key=lambda tup: (tup[1],tup[2]) )
[(1, 1, 4), (1, 2, 1), (1, 2, 3)]

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

reverse = True

और परिणाम निम्नानुसार होंगे:

data.sort(key=lambda tup: tup[1], reverse=True)

स्टीफन का जवाब वह है जिसका मैं उपयोग करूंगा। पूर्णता के लिए, यहां सूची समझ के साथ डीएसयू (सजाने-क्रमबद्ध-निर्विवाद) पैटर्न है:

decorated = [(tup[1], tup) for tup in data]
decorated.sort()
undecorated = [tup for second, tup in decorated]

या, अधिक तेज़:

[b for a,b in sorted((tup[1], tup) for tup in data)]

जैसा कि पाइथन सॉर्टिंग हाउटो में उल्लेख किया गया है, यह महत्वपूर्ण कार्य उपलब्ध होने पर पाइथन 2.4 के बाद से अनावश्यक रहा है।


itemgetter() lambda tup: tup[1] itemgetter() से कुछ हद तक तेज है lambda tup: tup[1] , लेकिन वृद्धि अपेक्षाकृत मामूली है (लगभग 10 से 25 प्रतिशत)।

(आईपीथन सत्र)

>>> from operator import itemgetter
>>> from numpy.random import randint
>>> values = randint(0, 9, 30000).reshape((10000,3))
>>> tpls = [tuple(values[i,:]) for i in range(len(values))]

>>> tpls[:5]    # display sample from list
[(1, 0, 0), 
 (8, 5, 5), 
 (5, 4, 0), 
 (5, 7, 7), 
 (4, 2, 1)]

>>> sorted(tpls[:5], key=itemgetter(1))    # example sort
[(1, 0, 0), 
 (4, 2, 1), 
 (5, 4, 0), 
 (8, 5, 5), 
 (5, 7, 7)]

>>> %timeit sorted(tpls, key=itemgetter(1))
100 loops, best of 3: 4.89 ms per loop

>>> %timeit sorted(tpls, key=lambda tup: tup[1])
100 loops, best of 3: 6.39 ms per loop

>>> %timeit sorted(tpls, key=(itemgetter(1,0)))
100 loops, best of 3: 16.1 ms per loop

>>> %timeit sorted(tpls, key=lambda tup: (tup[1], tup[0]))
100 loops, best of 3: 17.1 ms per loop

sorted_by_second = sorted(data, key=lambda tup: tup[1])

या:

data.sort(key=lambda tup: tup[1])  # sorts in place






tuples