किसी दिए गए सूचकांक में तत्व द्वारा सूची / टपल की सूची को कैसे छाँटा जाए?

Question

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

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

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

Comments

"क्या मुझे अपनी सूची में ट्यूल या सूची संग्रहीत करनी चाहिए?" के संबंध में, अंगूठे का एक नियम है कि चीजों को यथासंभव अपरिवर्तनीय बनाया जाए। अगर आपको जगह-जगह पर मौजूद सब्लिस्ट्स को संशोधित करने की जरूरत नहीं है, तो उन्हें ट्यूपल्स बना लें।

— मैथ्यू फ्लेशेन

Answer 1

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

या:

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

Comments

किसी भी विचार यह कैसे छोटे से बड़ा सॉर्ट करने के लिए?

— बिल्व्ड डिक

@ चिल्ड्रिल: हेल्प (सॉर्ट किया गया)। रिवर्स = सच।

— स्टीफन

@ आइटम का उपयोग करने वाला स्टीफन तेज़ और सरल है: key=itemgetter(1)और फ़ाइल की शुरुआत में:from operator import itemgetter

— जोशुआ

@ दूसरा उदाहरण के रूप में, sortयहाँ Listपायथन की वस्तु का एक तरीका है , जो एक लैम्बडा फ़ंक्शन को इसके keyपैरामीटर के रूप में प्राप्त करता है । आप इसे नाम के रूप tupमें या t, या जो कुछ भी आप पसंद करते हैं और यह अभी भी काम करेंगे। tupयहां सूची के टपल का सूचकांक निर्दिष्ट किया गया है, इसलिए 1इसका अर्थ है कि मूल सूची ( 2, 5, 8) से टुपल्स के दूसरे मूल्यों द्वारा छंटनी की जाएगी ।

— न्यूरोट्रांसमीटर

मैं बिना सोचे समझे किए गए दावे पर हल्के से संदेह कर रहा था कि "आइटम का उपयोग करना तेज़ और सरल है"। मैं सहज संबंध आत्मगत जबकि lambdaदृष्टिकोण unintuitive से सरल होने के लिए itemgetterवर्ग, itemgetter करता है वास्तव में तेजी से होना दिखाई । मैं उत्सुक हूं कि ऐसा क्यों है। मेरा क्रूड संदेह यह है कि lambdaसभी स्थानीय चर को बंद करने के संदर्भ में छिपी हुई लागत को पूरा itemgetterकरता है , जबकि एक उदाहरण नहीं है। tl; dr: हमेशा उपयोग करें itemgetter, क्योंकि गति जीत जाती है।

— सेसिल करी

Answer 2

from operator import itemgetter
data.sort(key=itemgetter(1))

Comments

यह स्वीकृत उत्तर होना चाहिए। यह भी देखें कि चार्ली की पोस्टिंग टाइमिंग है , यह दर्शाता है कि itemgetterक्लास को औसतन फंक्शन के मुकाबले औसतन 126% तेजी से छाँटना lambdaहै।

— सेसिल करी

आप कई सूचकांकों को श्रेणीबद्ध रूप से भी क्रमबद्ध कर सकते हैं, जैसेdata.sort(key=itemgetter(3,1))

— माइकल ओह्लोगेगे

Answer 3

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

reverse = True

और परिणाम इस प्रकार होगा:

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

Answer 4

कई मानदंडों द्वारा छाँटने के लिए, उदाहरण के लिए दूसरे और तीसरे तत्वों द्वारा एक टपल में, चलो

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

Answer 5

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

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 के बाद से अनावश्यक हो गया है, जब प्रमुख कार्य उपलब्ध हो गए।

Comments

तो यह जवाब पाइथन 2.3- के लिए उपयोगी है? क्या अधिक-मौजूदा पायथन संस्करणों में कोई मान्य उपयोग हैं जिनके आसपास आप थोड़ा विस्तार कर सकते हैं? यदि नहीं, तो कोई परेशान नहीं ... बस गुजर रहा था, यह देखा और बूढ़े नोगिन को सिर्फ एक मूतने के लिए मंथन करना पड़ा। वैसे भी, चीयर्स और इस धन्यवाद के लिए पाइथन के पहले दिनों में वापस चले गए।

— मैकेनिकल_मीट

Answer 6

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

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

Comments

क्या होगा अगर ट्यूप [1] एक स्ट्रिंग है?

— एरिक

Answer 7

लंबोदर के बिना:

def sec_elem(s):
    return s[1]

sorted(data, key=sec_elem)

Answer 8

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

Comments

कृपया यहां कई कॉलमों के लिए अलग-अलग तर्कों के लिए आइटम सॉर्टिंग सॉर्टिंग समाधान देखें, फिर आपको एक पंक्ति में कई चरणों में अपनी छंटनी की व्यवस्था करने की आवश्यकता है: stackoverflow.com/questions/14466068/…

— लोरेन्ज

Answer 9

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

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

>>> 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एक फ़ंक्शन है जिसे संग्रह की वस्तुओं को तुलना के लिए बदलने के लिए कहा जाएगा .. जैसे compareToजावा में विधि।

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

उदाहरण के लिए, हम एक ऐसी सूची की छँटाई कर रहे हैं जो निश्चित घटना और अभिनेता के नाम की जानकारी रखती है।

हम इस घटना को घटना घटने के समय के अनुसार हल कर रहे हैं - जो कि एक गुच्छे का 0 वां तत्व है।

नोट - s.sort([cmp[, key[, reverse]]]) जगह में एस के आइटम सॉर्ट करते हैं

Answer 10

एक नल को क्रमबद्ध करना काफी सरल है:

tuple(sorted(t))