क्रम से लगाने का सबसे आसान तरीका क्रम से लगाया गया(सूची) फ़ंक्शन है. यह एक सूची लेता है और इन एलिमेंट को क्रम से लगाने के लिए एक नई सूची दिखाता है. मूल सूची में कोई बदलाव नहीं हुआ है.
a = [5, 1, 4, 3] print(sorted(a)) ## [1, 3, 4, 5] print(a) ## [5, 1, 4, 3]
आम तौर पर, किसी सूची को क्रम से लगाए गए() फ़ंक्शन में भेजा जाता है. हालांकि, यह बार-बार इस्तेमाल किए जा सकने वाले किसी भी कलेक्शन को इनपुट के तौर पर इस्तेमाल कर सकता है. पुरानी list.sort() तरीका नीचे दिया गया एक विकल्प है. क्रम से लगाने() की तुलना में,sorted() फ़ंक्शन का इस्तेमाल करना आसान है. इसलिए, मेरा सुझाव है कि क्रम से लगाया गया() इस्तेमाल करें.
क्रम से लगाए गए() फ़ंक्शन को वैकल्पिक तर्कों के ज़रिए पसंद के मुताबिक बनाया जा सकता है. क्रम से लगाया गया() वैकल्पिक आर्ग्युमेंट रिवर्स=सही, जैसे क्रम से लगाया गया(सूची, रिवर्स=सही), इसे पीछे की तरफ़ क्रम से लगाता है.
strs = ['aa', 'BB', 'zz', 'CC'] print(sorted(strs)) ## ['BB', 'CC', 'aa', 'zz'] (case sensitive) print(sorted(strs, reverse=True)) ## ['zz', 'aa', 'CC', 'BB']
कुंजी के साथ कस्टम सॉर्टिंग=
पसंद के मुताबिक क्रम से लगाने का तरीका ज़्यादा मुश्किल बनाने के लिए,sorted() फ़ंक्शन एक वैकल्पिक "key=" की मदद से, "key" फ़ंक्शन तय करता है. यह फ़ंक्शन, तुलना से पहले हर एलिमेंट को बदल देता है. कुंजी फ़ंक्शन एक वैल्यू लेता है और एक वैल्यू दिखाता है. वहीं, "प्रॉक्सी" वैल्यू का इस्तेमाल, क्रम में तुलना करने के लिए किया जाता है.
उदाहरण के लिए, स्ट्रिंग की सूची के साथ, key=len (जिसमें बिल्ट-इन len() फ़ंक्शन मौजूद होता है) तय करके, स्ट्रिंग को सबसे छोटे से लेकर सबसे लंबे क्रम के हिसाब से क्रम में लगाया जाता है. क्रम से लगाने पर हर स्ट्रिंग के लिए, len() को कॉल किया जाता है, ताकि प्रॉक्सी की लंबाई की वैल्यू की सूची मिल सके और इसके बाद प्रॉक्सी की वैल्यू के हिसाब से क्रम में लगाया जा सकता है.
strs = ['ccc', 'aaaa', 'd', 'bb'] print(sorted(strs, key=len)) ## ['d', 'bb', 'ccc', 'aaaa']
दूसरे उदाहरण के तौर पर, "str.lower" को कुंजी फ़ंक्शन के तौर पर इस्तेमाल करके, क्रम में लगाने की प्रोसेस को अपरकेस और लोअरकेस में एक जैसा बनाया जा सकता है:
## "key" argument specifying str.lower function to use for sorting print(sorted(strs, key=str.lower)) ## ['aa', 'BB', 'CC', 'zz']
इस तरह से, अपने MyFn को भी मुख्य फ़ंक्शन के तौर पर पास किया जा सकता है:
## Say we have a list of strings we want to sort by the last letter of the string.
strs = ['xc', 'zb', 'yd' ,'wa']
## Write a little function that takes a string, and returns its last letter.
## This will be the key function (takes in 1 value, returns 1 value).
def MyFn(s):
return s[-1]
## Now pass key=MyFn to sorted() to sort by the last letter:
print(sorted(strs, key=MyFn)) ## ['wa', 'zb', 'xc', 'yd']
अगर आपको ज़्यादा मुश्किल कॉन्टेंट को क्रम से लगाने के लिए, उपनाम और फिर नाम के हिसाब से क्रम में लगाना है, तो itemgetter या attrgetter के फ़ंक्शन का इस्तेमाल किया जा सकता है. जैसे:
from operator import itemgetter
# (first name, last name, score) tuples
grade = [('Freddy', 'Frank', 3), ('Anil', 'Frank', 100), ('Anil', 'Wang', 24)]
sorted(grade, key=itemgetter(1,0))
# [('Anil', 'Frank', 100), ('Freddy', 'Frank', 3), ('Anil', 'Wang', 24)]
sorted(grade, key=itemgetter(0,-1))
#[('Anil', 'Wang', 24), ('Anil', 'Frank', 100), ('Freddy', 'Frank', 3)]
क्रम से लगाने का() तरीका
segment() के विकल्प के तौर पर, किसी सूची पर रणनीति() वाला तरीका, उस सूची को बढ़ते क्रम में लगा देता है.उदाहरण के लिए, list. sort(). इस तरीके का इस्तेमाल करने से, दी गई सूची में बदलाव हो जाता है और कोई वैल्यू नहीं मिलती. इसलिए, इसका इस्तेमाल इस तरह करें:
alist.sort() ## correct alist = blist.sort() ## Incorrect. sort() returns None
ऊपर दी गई गलतफ़हमी को segment() के साथ आम तौर पर समझ लिया गया है -- इससे, क्रम से लगाई गई सूची *नहीं* दिखाई जाती.* shortcuts() वाला तरीका किसी सूची में ही कॉल किया जाना चाहिए. यह किसी भी गिनती लायक कलेक्शन पर काम नहीं करता (हालांकि, ऊपर दिया गयाक्रम() फ़ंक्शन किसी भी चीज़ पर काम करता है). क्रम() वाला तरीका,sorted() फ़ंक्शन से पहले का है. इसलिए, हो सकता है कि यह आपको पुराने कोड में दिखे. क्रम() तरीके को नई सूची बनाने की ज़रूरत नहीं होती. इसलिए, अगर क्रम से लगाए जाने वाले एलिमेंट पहले से ही सूची में हैं, तो यह थोड़ा तेज़ हो सकता है.
टपल
टपल, एलिमेंट के तय साइज़ वाले ग्रुप होते हैं, जैसे कि (x, y) को-ऑर्डिनेट. टपल, सूचियों की तरह होते हैं. हालांकि, इन्हें बदला नहीं जा सकता और इनका साइज़ नहीं बदला जा सकता. इन टपल को बदला नहीं जा सकता. ऐसा इसलिए, क्योंकि इनमें शामिल एलिमेंट में से कोई एक बदला जा सकता है. Python में टपल एक तरह की "स्ट्रक्चर" की भूमिका निभाते हैं -- यह वैल्यू के तय लॉजिकल और तय साइज़ वाले बंडल का इस्तेमाल करने का एक आसान तरीका है. जिस फ़ंक्शन को कई वैल्यू दिखाने की ज़रूरत होती है वह सिर्फ़ वैल्यू का एक टपल दिखा सकता है. उदाहरण के लिए, अगर मुझे 3-d निर्देशांकों की सूची चाहिए, तो Python का नैचुरल प्रज़ेंटेशन, ट्यूपल की सूची होगी. इसमें हर टपल का साइज़ 3 होगा, जिसमें एक (x, y, z) ग्रुप होगा.
टपल बनाने के लिए, सिर्फ़ ब्रैकेट में वैल्यू को कॉमा से अलग करके लिस्ट करें. "खाली" टपल सिर्फ़ ब्रैकेट का खाली जोड़ा होता है. टपल में एलिमेंट को ऐक्सेस करना एक सूची की तरह होता है -- len(), [ ], for, in, वगैरह. ये सब एक ही तरह से काम करते हैं.
tuple = (1, 2, 'hi') print(len(tuple)) ## 3 print(tuple[2]) ## hi tuple[2] = 'bye' ## NO, tuples cannot be changed tuple = (1, 2, 'bye') ## this works
साइज़-1 का टपल बनाने के लिए, लोन एलिमेंट के बाद कॉमा होना चाहिए.
tuple = ('hi',) ## size-1 tuple
सिंटैक्स में यह एक मज़ेदार केस है, लेकिन ब्रैकेट में एक्सप्रेशन रखने के सामान्य केस से टपल को अलग करने के लिए कॉमा ज़रूरी है. कुछ मामलों में, ब्रैकेट को छोड़ा जा सकता है. Python, उन कॉमा को देख लेगा जिन्हें आपको टपल बनाना है.
वैरिएबल नामों के एक जैसे साइज़ वाले टपल को असाइन करने से, उससे जुड़ी सभी वैल्यू असाइन हो जाती हैं. अगर ट्यूपल एक साइज़ के नहीं हैं, तो गड़बड़ी का मैसेज दिखता है. यह सुविधा सूचियों के लिए भी काम करती है.
(x, y, z) = (42, 13, "hike") print(z) ## hike (err_string, err_code) = Foo() ## Foo() returns a length-2 tuple
पूरी जानकारी की सूची बनाएं (ज़रूरी नहीं)
लिस्ट कॉम्प्रिहेन्शंस एक बेहतर सुविधा है, जो कुछ मामलों में अच्छी है, लेकिन कसरतों के लिए इसकी ज़रूरत नहीं है.साथ ही, यह ऐसी चीज़ नहीं है जिसे पहले सीखने की ज़रूरत है. उदाहरण के लिए, इस सेक्शन को स्किप किया जा सकता है. लिस्ट कॉम्प्रिहेंसन, एक्सप्रेशन लिखने का एक छोटा तरीका है, जो पूरी सूची तक फैलता है. मान लीजिए कि हमारे पास सूची नंबर [1, 2, 3, 4] हैं. यहां उनके स्क्वेयर की सूची को कंप्यूट करने के लिए लिस्ट कॉम्प्रिहेंसन दी गई है [1, 4, 9, 16]:
nums = [1, 2, 3, 4] squares = [ n * n for n in nums ] ## [1, 4, 9, 16]
सिंटैक्स [ expr for var in list ] है -- for var in list, सामान्य फ़ॉर-लूप जैसा दिखता है, लेकिन इसमें कोलन (:) नहीं होता. नई सूची को वैल्यू देने के लिए, हर एलिमेंट के लिए इसकी बाईं ओर मौजूद expr का एक बार आकलन किया जाता है. यहां स्ट्रिंग के साथ एक उदाहरण दिया गया है, जिसमें हर स्ट्रिंग को अपर केस में बदला गया है. इसमें '!!!' जुड़ा हुआ है:
strs = ['hello', 'and', 'goodbye'] shouting = [ s.upper() + '!!!' for s in strs ] ## ['HELLO!!!', 'AND!!!', 'GOODBYE!!!']
सटीक नतीजा पाने के लिए, 'लूप' के दाईं ओर if टेस्ट जोड़ा जा सकता है. if टेस्ट का आकलन हर एलिमेंट के लिए किया जाता है. इसमें सिर्फ़ वे एलिमेंट भी शामिल होते हैं जहां टेस्ट सही पाया गया हो.
## Select values <= 2 nums = [2, 8, 1, 6] small = [ n for n in nums if n <= 2 ] ## [2, 1] ## Select fruits containing 'a', change to upper case fruits = ['apple', 'cherry', 'banana', 'lemon'] afruits = [ s.upper() for s in fruits if 'a' in s ] ## ['APPLE', 'BANANA']
व्यायाम: list1.py
इस सेक्शन में दिए गए कॉन्टेंट का अभ्यास करने के लिए, बाद में दिए गए सवालों को list1.py पर जाकर देखें, जिनमें क्रम से लगाने और टूपल (बुनियादी कसरत में) का इस्तेमाल किया गया है.