R.I.B.H.U. Academy^®

सूची (list), डिक्शनरी और सेट कॉम्प्रिहेंशन

    आपने PHP और JavaScript जैसी अन्य प्रोग्रामिंग भाषाओं में ?: (टर्नरी ऑपरेटर) के बारे में सुना होगा। हालाँकि, पायथन में टर्नरी ऑपरेटर अन्य सभी ऑपरेशनों के बीच सबसे कम प्राथमिकता वाला है, और इसका एक उदाहरण नीचे दिखाया गया है। लेकिन, पायथन में लिस्ट कॉम्प्रिहेंशन और डिक्शनरी कॉम्प्रिहेंशन का अक्सर उपयोग किया जाता है, और ये बहुत महत्वपूर्ण हैं। टर्नरी ऑपरेटर और लिस्ट/डिक्शनरी/सेट कॉम्प्रिहेंशन एकल-पंक्ति अभिव्यक्ति (expressions) हैं, और उनका उपयोग एक चर (variable) नाम के लिए ऐसी अभिव्यक्ति निर्दिष्ट करने के लिए किया जाता है। इस प्रकार प्रोग्रामर को कम लिखना, और अधिक मिलता (प्राप्त होता) (write less, do more) है।

टर्नरी ऑपरेटर

उदाहरण 1:

x, y = 30, 20
result = x if x < y else y
print( result )   # Outputs 20

    आप देख सकते हैं कि उपरोक्त उदाहरण को जब if else ब्लॉक में लिखा जाता है, तो उपरोक्त कोड की तीन पंक्तियाँ, छह पंक्तियों में लिखी जाती है, वह भी इंडेंटेशन के साथ। प्रोग्रामिंग भाषाओं में, एक अभिव्यक्ति का आउटपुट आम तौर पर एक चर नाम को सौंपा जाता है, ताकि इसे पृष्ठभूमि या बैक-एंड प्रक्रियाओं में आगे उपयोग किया जा सके। print() अंतर्निहित फ़ंक्शन का उपयोग करके या अन्य मॉड्यूल का उपयोग करके परिणाम प्रदर्शित करना दुर्लभ है और पूरे प्रोग्राम का अंतिम परिणाम है।

उदाहरण 2:

x, y = 30, 20
if x < y:
    result = x
else:
    result = y
print( result )   # Outputs 20

कॉम्प्रिहेंशन्स Compre­hens­ions

    आप पहले ही for लूप के विभिन्न उदाहरण देख चुके हैं। यहां आपको ध्यान देना चाहिए कि सभी सूची, डिक्शनरी और सेट कॉम्प्रिहेंशन for लूप के संक्षिप्त रूप हैं, और इसलिए, उन्हें for लूप के ब्लॉक कोड में भी लिखा जा सकता है। लेकिन, एक for लूप ब्लॉक में कई स्टेटमेंट (कोड की पंक्तियाँ) हो सकते हैं, और इसलिए for लूप का एक जटिल (व्यापक) ब्लॉक कोड लिस्ट/डिक्शनरी कॉम्प्रिहेंशन में नहीं लिखा जा सकता है। if else कोड के ब्लॉक और टर्नरी एक्सप्रेशन (ऊपर बताया गया) के बारे में भी यही सादृश्य सत्य है।

    जब आपके डेटा में बड़ी मात्रा में फ़्लोट होते हैं (अर्थात, किसी सूची में आइटम/तत्व फ़्लोट होते हैं), तो उन फ़्लोट को संग्रहीत करने और संसाधित करने में बड़ी मेमोरी (रैम) और गणना शक्ति (सीपीयू) की आवश्यकता हो सकती है। हालाँकि, जब कुछ आइटम हों तो ये अंतराल नगण्य हैं, (जैसा कि निम्नलिखित उदाहरण में दिखाया गया है)। अपने डेटा को वर्ष के प्रत्येक घंटे के लिए तापमान मान सेल्सियस (फ्लोट्स) के रूप में सोचें। तब सूची में आइटम 365 × 24 = 8760 होंगे। कई मौसम पूर्वानुमान संगठन दुनिया के हर शहर के लिए इस तरह के डेटा का मूल्यांकन करते हैं। ऐसे बड़े डेटा (BIG DATA) को संभालना प्रोग्रामर्स के लिए चुनौती हो सकता है!

सूची कॉम्प्रिहेंशन्स

    कॉम्प्रिहेंशन्स परिवर्तनशील अनुक्रम डेटा-प्रकारों के लिए है, अर्थात सूची, डिक्शनरी और सेट। सूची (list) कॉम्प्रिहेंशन का सिंटैक्स इस प्रकार है:

variable_name = [expression for item in iterable]

उदाहरण 3: निम्नलिखित उदाहरण में, temps मूल सूची डेटा-प्रकार (पुनरावर्तनीय) है, और वह भी वर्गाकार कोष्ठकों की एक जोड़ी के अंदर है, ताकि for लूप इससे प्रत्येक आइटम/तत्व ला (fetch) सके। temp सूची डेटा-प्रकार का व्यक्तिगत आइटम/तत्व है, जिसे आगे 10 से विभाजित किया जाता है (या अभिव्यक्ति में अन्य ऑपरेशन किए जा सकते हैं) और उसके बाद, temp / 10 अभिव्यक्ति का आउटपुट, किसी अन्य सूची शाब्दिक (या चर नाम) अर्थात my_temps में संग्रहीत किया जाता है।

temps = [351, 344, 340, 445]   # डेटा-भंडारण को बचाने के लिए दशमलव का उपयोग न (कम) करें
my_temps = [temp / 10 for temp in temps]   # list compre­hens­ion
print(my_temps, type(my_temps))

उदाहरण 4:

temps = [351, 344, 340, 445]
new_temps = []
for temp in temps:
    new_temps.append(temp / 10)
print(new_temps, type(new_temps))   # आउटपुट ऊपर जैसा ही है

    Caution: आपको ध्यान देना चाहिए कि सूची कॉम्प्रिहेंशन सिंटैक्स के अंदर परिभाषित किया गया एक चर नाम (उदाहरण के लिए, [my_var for my_var in my_list] अभिव्यक्ति के अंदर my_var) इसके बाहर से पहुंच योग्य नहीं है। अर्थात्, यह सूची कॉम्प्रिहेंशन के लिए स्थानीय (local) है। हालाँकि, for लूप के अंदर परिभाषित एक चर नाम (उदाहरण के लिए, निम्नलिखित for लूप के ब्लॉक कोड में item) लूप के बाहर (नीचे) उपलब्ध और पहुंच योग्य है।

for item in [1,2,3,4,5]:
    print( item )   # लूप के अंदर
print( item )   # लूप के बाहर, पुनरावर्तनीय (iterable) के अंतिम आइटम को आउटपुट करता है।

    इसलिए, किसी अभिव्यक्ति या कोड के ब्लॉक के अंदर घोषित इस प्रकार के चर का उपयोग करते समय आपको सावधान रहना चाहिए। चर दायरे (variable scope) को बाद के पृष्ठों में समझाया जाएगा। सूची कॉम्प्रिहेंशन (विस्तारित) का सिंटैक्स इस प्रकार है:

variable_name = [expression for item in iterable if item condition literal]

उदाहरण 5:निम्नलिखित उदाहरण में, temps मूल सूची है, इसमें पूर्णांक आइटम हैं। temps सूची का प्रत्येक तत्व, temp पर >=(एक तुलना ऑपरेटर) द्वारा एक शर्त की जाँच की जाती है। जब प्रत्येक तत्व पर शर्त (condition) का मूल्यांकन False किया जाता है, तो मूल सूची का संबंधित आइटम सूची कॉम्प्रिहेंशन्स की अभिव्यक्ति के लिए पारित (pass) नहीं किया जाता है। इसके बाद, सशर्त अभिव्यक्ति को आगे 10 से विभाजित किया गया है। और अंत में temp नए वेरिएबल नाम temp_result में जोड़ा गया है।

temps = [351, 344, -999, 340, 445]   # सूची में कुछ अमान्य डेटा
temp_result = [temp / 10 for temp in temps if temp >= -273.0]
print(temp_result)

    सूची कॉम्प्रिहेंशन में कई भाग होते हैं, इससे पहले कि इसे एक चर नाम को निर्दिष्ट किया जाए या सीधे print() फ़ंक्शन के अंदर मूल्यांकन (evaluate) किया जाए। जब शर्त for लूप से पहले होता है, तो पहले मूल सूची के प्रत्येक आइटम की शर्त (condition) से तुलना की जाएगी। जब शर्त का मूल्यांकन False होता है, तो else ब्लॉक का आउटपुट, सूची कॉम्प्रिहेंशन्स की अभिव्यक्ति (expression) को पारित कर किया जाएगा, अन्यथा सूची का मूल आइटम अभिव्यक्ति को पारित किया जाएगा।

variable_name = [expression if item condition literal else alternate_item for item in iterable]

उदाहरण 6:

temps = [351, 344, -999, 340, 445]   # सूची में कुछ नकारात्मक डेटा
print( [temp/10 if temp > 0 else 0 for temp in temps] )

    उदाहरण 5 में, आप देख सकते हैं कि (तीसरे आइटम का) नकारात्मक मान परिणामी सूची (अंतिम आउटपुट) में नहीं है, जबकि उदाहरण 6 में,0(तीसरे आइटम का मूल्य, elseपारित होने के बाद) मूल सूची के नकारात्मक आइटम को प्रतिस्थापित करता है।

उदाहरण 7: निम्नलिखित उदाहरण में, आप मूल सूची से सम संख्याओं की सूची या विषम संख्याओं की सूची बना सकते हैं यदि आप == (बराबर) ऑपरेटर को != (बराबर नहीं) ऑपरेटर से बदलते हैं। सूची कॉम्प्रिहेंशन की अवधारणा को ऊपर समझाया गया है।

my_numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
my_list = [num for num in my_numbers if num % 2 == 0]
print( my_list )   # आउटपुट [2, 4, 6, 8, 10] है।

उदाहरण 8:

my_numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
my_list = []         # खाली (empty) सूची
for num in my_numbers:
    if num % 2 == 0:
        my_list.append(num)
print( my_list )   # आउटपुट [2, 4, 6, 8, 10] है।

स्ट्रिंग पर सूची कॉम्प्रिहेंशन

उदाहरण 9: यह सरल सूची कॉम्प्रिहेंशन स्वयं-व्याख्यात्मक है। आप निम्नलिखित कोड के पारंपरिक for लूप को स्वयं लिख सकते हैं।

my_str = "Hello World"
items = [letter for letter in my_str]
print(items)

अधिक जटिल सूची कॉम्प्रिहेंशन्स

उदाहरण 10:आप निम्नलिखित उदाहरण में [1, 2, 3, 4, 5, 6] (एक सूची शाब्दिक) के स्थान पर range() बिल्ट-इन फ़ंक्शन का उपयोग कर सकते हैं। नीचे वर्णित तीनों उदाहरणों के आउटपुट में समान है (उदाहरण 12 के नीचे दिखाया गया है)। निम्नलिखित तीन उदाहरणों में, स्ट्रिंग शाब्दिक 'abcdef' में प्रत्येक अक्षर (नेस्टेड टुपल में पहला आइटम) के लिए, दूसरी सूची शाब्दिक में, प्रत्येक नामित संख्या (या आप अन्य डेटा-प्रकार शाब्दिक को रख सकते हैं) नेस्टेड टपल के दूसरे आइटम के रूप में निर्दिष्ट किया गया है।

my_list = [(letter, num) for letter in 'abcdef' for num in [1, 2, 3, 4, 5, 6]]
print( my_list )   # आउटपुट नीचे दिखाया गया है:

उदाहरण 11: range() अंतर्निहित फ़ंक्शन को अगले पृष्ठ में समझाया गया है।

my_list = [(letter, num) for letter in 'abcdef' for num in range(6)]
print( my_list )   # आउटपुट नीचे दिखाया गया है:

उदाहरण 12:

my_list = []
for letter in 'abcdef':
    for num in [1, 2, 3, 4, 5, 6]:
        my_list.append((letter, num))
print( my_list )   # आउटपुट नीचे दिखाया गया है:

डिक्शनरी कॉम्प्रिहेंशन्स

उदाहरण 13:हालांकि निम्नलिखित उदाहरण लंबा है, यहां नीचे दिखाया गया है कि एक डिक्शनरी कॉम्प्रिहेंशन zip()अंतर्निहित फ़ंक्शन के साथ या नेस्टेड टुपल्स की एक सूची/टुपल के साथ (जिसमें प्रत्येक नेस्टेड टुपल का पहला आइटम कुंजी है, और नेस्टेड टपल का दूसरा आइटम, संबंधित कुंजी का मान है), बनाई जा सकती है। आपको याद रखना चाहिए कि एक कुंजी नाम केवल अपरिवर्तनीय डेटा-प्रकार हो सकता है, जिसे hashable भी होना चाहिए। डिक्शनरी कैसे बनाएं यह जानने के लिए आपको पिछले पृष्ठ पर जाना चाहिए।

roman_num = ['i', 'ii', 'iii', 'iv', 'v', 'vi']
english_num = ['one', 'two', 'three', 'four', 'five', 'six']

print( zip( roman_num, english_num ) )   # आउटपुट <zip object at 0x000001959E2427C0> (एक zip ऑब्जेक्ट object)
print( list(zip( roman_num, english_num )) )       # टुपल्स की एक सूची आउटपुट करता है
print( tuple(zip( roman_num, english_num )) )   # टुपल्स का एक टुपल आउटपुट करता है
print( dict(zip( roman_num, english_num )) )      # roman_num और english_num के संबंधित आइटम को कुंजी:मूल्य जोड़ी के रूप में, एक डिक्शनरी आउटपुट करता है।

my_dict = {}   # खाली (empty) डिक्शनरी
for rom_num, eng_num in zip( roman_num, english_num ):
    my_dict[rom_num] = eng_num
print( my_dict )       # rom_num: eng_num कुंजी:मान युग्म के रूप में एक डिक्शनरी आउटपुट करता है। आपको निम्नलिखित डिक्शनरी कॉम्प्रिहेंशन में इन स्थानीय चर का उपयोग नहीं करना चाहिए, अन्यथा आपको त्रुटि या अप्रत्याशित परिणाम मिलेगा!

new_dict = { r_num: e_num for r_num, e_num in zip( roman_num, english_num ) }
print( new_dict )       # r_num: e_num कुंजी:मान युग्म के रूप में एक डिक्शनरी आउटपुट करता है।

उदाहरण 14: निम्नलिखित उदाहरण में, आप डिक्शनरी कॉम्प्रिहेंशन के अंदर सशर्त अभिव्यक्ति का उपयोग कर सकते हैं, जैसा कि सूची कॉम्प्रिहेंशन्स के लिए ऊपर बताया गया है। जिन आइटम्स का मूल्यांकन False किया जाता है, डिक्शनरी कॉम्प्रिहेंशन शाब्दिक के आउटपुट में नहीं जोड़ा जाएगा।

roman_num = ['i', 'ii', 'iii', 'iv', 'v', 'vi']
english_num = ['one', 'two', 'three', 'four', 'five', 'six']

new_dict = {r_num: e_num for r_num, e_num in zip(roman_num, english_num) if r_num != 'iv'}
print(new_dict)

उदाहरण 15: निम्नलिखित उदाहरण में, आप उसी प्रकार का सिंटैक्स देख सकते हैं (जिसे विस्तारित सूची कॉम्प्रिहेंशन्स के लिए ऊपर समझाया गया है)। जब डिक्शनरी शाब्दिक का कोई भी आइटम (कुंजी:मूल्य युग्म) if शर्त को पूरा नहीं करता है, तो else कोड के ब्लॉक को डिक्शनरी कॉम्प्रिहेंशन के एक आइटम के रूप में पारित किया जाएगा। निम्नलिखित उदाहरण के नीचे वर्णित आउटपुट में तीसरा आइटम देखें।

roman_num = ['i', 'ii', 'iii', 'iv', 'v', 'vi']
english_num = ['one', 'two', 'three', 'four', 'five', 'six']

new_dict = {r_num: e_num if r_num != 'iv' else (4,'xyz') for r_num, e_num in zip(roman_num, english_num)}
print(new_dict)

सेट कॉम्प्रिहेंशन्स

उदाहरण 16: आप किसी सूची या टपल डेटा-प्रकार को set() अंतर्निहित फ़ंक्शन का उपयोग करके सेट डेटा-प्रकार शाब्दिक रूप से परिवर्तित कर सकते हैं। उदाहरण के लिए, set( [1, 2, 3, 1, 2, 3, 4, 5, 6, 4, 5, 6] ) (किसी सूची को सेट में टाइप-कास्ट करना) या set( (1, 2, 3, 1, 2, 3, 4, 5, 6, 4, 5, 6) ) (टपल को सेट में टाइप-कास्ट करना) या {1, 2, 3, 1, 2, 3, 4, 5, 6, 4, 5, 6} (एक साधारण सेट), तीनों {1, 2, 3, 4, 5, 6} (सेट में केवल अद्वितीय आइटम होते हैं) आउटपुट या रिटर्न देंगे।

my_set = {1, 2, 3, 1, 2, 3, 4, 5, 6, 4, 5, 6}
print( my_set )   # आउटपुट {1, 2, 3, 4, 5, 6} है।

new_set = set()   # {} घुंघराले ब्रेसिज़ का उपयोग न करें, जो एक डिक्शनरी बनाएगा।
for num in my_set:
    new_set.add( num )
print( new_set )   # आउटपुट {1, 2, 3, 4, 5, 6} है।

उदाहरण 17: उपरोक्त उदाहरणों का उपयोग करते समय for लूप में परिभाषित किया गया num (स्थानीय चर) का उपयोग निरंतरता में नहीं करें। अन्यथा, आपको त्रुटि या अप्रत्याशित परिणाम मिल सकता है। याद रखें, प्रोग्राम में त्रुटि या बग तब होते हैं, जब प्रोग्रामर (इंसान) इन छोटी गलतियों (silly mistakes) पर ध्यान नहीं देता है!! BUG कोई त्रुटि नहीं है, बल्कि एक अप्रत्याशित व्यवहार है जिसे पायथन इन्टरप्रेटर द्वारा प्रदर्शित नहीं किया जा सकता है।

my_set = {1, 2, 3, 1, 2, 3, 4, 5, 6, 4, 5, 6}
new_set = {num for num in my_set}
print( new_set )   # आउटपुट {1, 2, 3, 4, 5, 6} है।