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

नेस्टेड सूचियाँ, नेस्टेड टुपल्स और नेस्टेड डिक्शनरी

my_string = "[ 'Hello', 'World' ]"
print( my_string )
print( my_string[0] )
print( len( my_string ), len( my_string[0] ) )
print( type( my_string ), type( my_string[0] ) )

    उपरोक्त कोड एक स्ट्रिंग शाब्दिक का उदाहरण है, न कि सूची (list) का, क्योंकि प्रत्येक वर्ण (character) दोहरे उद्धरण चिह्नों की एक जोड़ी के भीतर संलग्न है। पिछले पृष्ठ में, आपने देखा है कि एक खाली स्ट्रिंग की लंबाई 0 (शून्य) है, और इसलिए, [0] के साथ एकल (single) वर्ण (character) निकालना (extract), आउटपुट IndexError: string index out of range (स्ट्रिंग इंडेक्स सीमा से बाहर) देता है। हालाँकि, एक स्ट्रिंग शाब्दिक (यहां तक ​​कि एकल/दोहरे उद्धरणों की एक जोड़ी के भीतर संलग्न एक रिक्त स्थान), हमेशा एक वर्ण (character) लौटाता है, जब [0] के साथ एक एकल वर्ण निकाला (extract) जाता है। यहाँ, 0 (शून्य) एक स्ट्रिंग शाब्दिक में पहले अक्षर की सूचकांक संख्या है। इस प्रकार, सबसे मजेदार बात यह है कि आप स्ट्रिंग शाब्दिक या एक वैरिएबल नाम, जो उस स्ट्रिंग शाब्दिक (खाली स्ट्रिंग को छोड़कर) के साथ निर्दिष्ट किया गया है, के बाद में कई [0] जोड़ सकते हैं।

print( my_string[0][0][0][0] )   # हमेशा [ आउटपुट देता है चाहे कितना भी [0] जोड़ा जाए

print( ' '[0][0][0][0] )   # हमेशा   (रिक्त स्थान) आउटपुट देता है, कंसोल या VSCode संपादक टर्मिनल में दिखाई नहीं देता है। जब कोड निष्पादित करते समय कोई त्रुटि नहीं दिखाई देती है, तो यह (स्पष्ट) समझा जाना चाहिए कि कोड सफलतापूर्वक निष्पादित हो गया है!

print( 'Hello World'[1][0][0][0] )   # हमेशा e आउटपुट देता है (स्ट्रिंग शाब्दिक में दूसरा अक्षर) चाहे कितना भी [0] जोड़ा जाए।

    जैसा कि ऊपर दिखाया गया है, स्ट्रिंग शाब्दिक में अनुक्रम का केवल एक स्तर होता है, इसलिए, वर्गाकार कोष्ठकों की केवल एक जोड़ी की आवश्यकता होती है। यह जानने के लिए कि पायथन में निष्कर्षण (extraction) और स्लाइसिंग कैसे की जाती है, पिछले पृष्ठ पर जाएँ।

    Caution: आप वर्गाकार कोष्ठकों के अधिक से अधिक जोड़े (pairs) जोड़ (add) सकते हैं (जैसा कि ऊपर दिखाया गया है), लेकिन आपको सावधान रहना चाहिए और आपको वर्गाकार कोष्ठकों के केवल उतने ही जोड़े (pairs) जोड़ने चाहिए, जितने अनुक्रम डेटा-प्रकार (अर्थात्, स्ट्रिंग्स, सूचियाँ lists, टुपल्स और डिक्शनरी) में अनुक्रमों (sequences) के स्तर (NESTING) होते हैं। निम्नलिखित उदाहरण में, आप देख सकते हैं कि एक स्ट्रिंग शाब्दिक अनुक्रम का केवल एक स्तर है, और इसलिए, आप एक ही वर्ण से दूसरा सूचकांक नहीं निकाल सकते हैं।

print( 'Hello World'[1][1] )   # आउटपुट IndexError: string index out of range है। ('Hello World'[1] से केवल एक ही अक्षर निकाला गया है, जिसे बाद में केवल [0] जोड़ कर ही एक्सेस किया जा सकता है)

    पिछले पृष्ठ में, आपने सूची (list) और टपल डेटा-प्रकार के कई शाब्दिक (literals) देखे हैं, जिनमें प्रत्येक आइटम/तत्व में केवल एक वर्ण है। वहां उन शाब्दिकों का वर्णन आपको यह समझाने के लिए किया गया है, कि slice() (और वर्गाकार कोष्ठकों की एक जोड़ी के भीतर कोलन प्रतीकों का उपयोग करके स्लाइस करना) हमेशा संबंधित डेटा-प्रकार में एक या अधिक व्यक्तिगत (individual) आइटम/तत्व लौटाता है। स्लाइसिंग शाब्दिक के मान (value) से अलग-अलग वर्ण/आइटम नहीं निकाल (extract) सकता है, लेकिन संपूर्ण (whole) आइटम/तत्व लौटाता है, जैसा कि नीचे बताया गया है:

my_list = ['Hello', 'World']

print( my_list[0] )     # आउटपुट Hello (पहला आइटम) है।
print( my_list[1] )     # आउटपुट World (दूसरा आइटम) है।
print( my_list[-1] )    # आउटपुट World (अंतिम आइटम) है।
print( my_list[-2] )    # आउटपुट Hello (दूसरा अंतिम आइटम) है।

print( my_list[:] )     # पहली वस्तु से अंतिम वस्तु तक काटना (स्लाइस करना)
print( my_list[::] )    # पहले आइटम से अंतिम आइटम तक स्लाइस करना, बिना कोई चरण (step) छोड़े

    उपरोक्त उदाहरणों का वर्णन यहां आपको यह समझाने के लिए किया गया है कि संख्याओं (पूर्णांक और फ्लोट्स), बूलियन (True / False), None (अन्य प्रोग्रामिंग भाषाओं में null) की तरह, स्ट्रिंग अक्षर भी स्केलर डेटा-प्रकार हैं, इससे कोई फर्क नहीं पड़ता कि यह वर्णों का अनुक्रम है। हालाँकि, अन्य डेटा-प्रकार, जैसे सूचियाँ, टुपल्स, डिक्शनरी जटिल डेटा-प्रकार हैं, और उनमें अन्य डेटा-प्रकार आइटम/तत्व शामिल हो सकते हैं।

Nesting नेस्टिंग

    किसी सूची (list), टपल या डिक्शनरी में प्रत्येक आइटम/तत्व के मान की अपनी पहचान (identity) होती है (आप उन्हें id() फ़ंक्शन के साथ जांच सकते हैं)। इस प्रकार, जब सूचियों, टुपल्स और डिक्शनरियों में संख्याओं, बूलियन और None के अलावा अन्य मानों के आइटम/तत्व होते हैं, तो फिर से व्यक्तिगत आइटम या वर्ण (संबंधित सूची, टुपल्स या डिक्शनरी के उस आइटम से) को सूचकांक संख्याओं को वर्गाकार कोष्ठकों की एक जोड़ी के भीतर जोड़कर एक्सेस किया जा सकता है। इसे नेस्टिंग कहा जाता है, जहां किसी सूची, टपल या डिक्शनरी में एक आइटम में अन्य जटिल डेटा-प्रकार हो सकते हैं।

    उपरोक्त और निम्नलिखित उदाहरणों में, सूची (list) शाब्दिक ['Hello', 'World'] में केवल दो आइटम/तत्व हैं, अर्थात् 'Hello' (सूचकांक संख्या 0 या -2 के साथ) और 'World' (सूचकांक संख्या 1 या -1 के साथ)। प्रत्येक सूची में दोनों आइटम स्ट्रिंग डेटा-प्रकार के हैं। आप len() फ़ंक्शन की सहायता से पहले और अंतिम आइटम की सूचकांक संख्या भी प्राप्त कर सकते हैं (पिछला पृष्ठ देखें)।

    अब, आप वर्गाकार कोष्ठकों के एक या अधिक जोड़े के भीतर, सूचकांक संख्या (या डिक्शनरियों के मामले में सटीक कुंजी) जोड़कर सूचियों और अन्य अनुक्रम डेटा-प्रकार शाब्दिक या चर नामों में एक या अधिक स्तर आगे जा सकते हैं, जिनमें स्ट्रिंग्स, सूचियां, टुपल्स, डिक्शनरी शामिल हैं।

my_list = ['Hello', 'World']

print( my_list[0][0] )     # आउटपुट H (पहले आइटम से पहला अक्षर) है।
print( my_list[0][1] )      # आउटपुट e (पहले आइटम से दूसरा अक्षर) है।

print( my_list[1][0] )      # आउटपुट W (दूसरे आइटम से पहला अक्षर) है।
print( my_list[1][1] )       # आउटपुट o (दूसरे आइटम से दूसरा अक्षर) है।

print( my_list[0][-1] )     # आउटपुट o (पहले आइटम से अंतिम अक्षर) है।
print( my_list[1][-1] )      # आउटपुट d (दूसरे आइटम से अंतिम अक्षर) है।

    यदि किसी सूची, टपल या डिक्शनरी में कोई आइटम/तत्व स्ट्रिंग डेटा-प्रकार के अलावा है, तो आप फिर से आगे बढ़ सकते हैं, और अलग-अलग आइटम/तत्वों तक पहुंचने (access) या निकालने (extract) के लिए वर्गाकार कोष्ठकों के और जोड़े (pairs) जोड़ (add) सकते हैं, (और इसी तरह ...) जैसा कि नीचे दिखाया गया है। यदि कोई नेस्टेड आइटम डिक्शनरी डेटा-प्रकार का है, तो आपको उस आइटम की सूचकांक संख्या के बजाय सटीक कुंजी नाम (exact key name) रखना होगा।

complex_list = [
  (11, 22, 33),     # नेस्टेड टुपल
  {
    "fword": "hello",
    'lword': 'world',
    "length": 3
  },               # नेस्टेड डिक्शनरी
  (
    ['a', 'b', 'c'],
    ['d', 'e', 'f']
  )                 # नेस्टेड टुपल में नेस्टेड सूचियां (lists)
]

print( complex_list )
print( complex_list[0], type( complex_list[0] ) )
print( complex_list[1], type( complex_list[1] ) )
print( complex_list[2], type( complex_list[2] ) )

print( complex_list[0][1], type( complex_list[0][1] ) )
print( complex_list[1]["fword"], type( complex_list[1]["fword"] ) )
print( complex_list[2][1], type( complex_list[2][1] ) )

    उपरोक्त उदाहरण विभिन्न डेटा-प्रकारों को एक दूसरे में नेस्ट करने का एक विशिष्ट उदाहरण है, और आउटपुट नीचे दिखाया गया है। उपरोक्त उदाहरण में, वेरिएबल नाम complex_list (जो टुपल डेटा-प्रकार का हो सकता है, यदि आप वर्गाकार कोष्ठक के बजाय () कोष्ठक लिखते हैं,) इसमें केवल तीन आइटम हैं। पहला और तीसरा आइटम टपल शाब्दिक हैं, और दूसरा आइटम एक डिक्शनरी शाब्दिक है। तीसरे आइटम में दो सूची आइटम भी शामिल हैं।

    उपरोक्त आउटपुट में आप देख सकते हैं कि पहली पंक्ति संपूर्ण (whole) complex_list दिखाती है। दूसरी, तीसरी और चौथी पंक्तियाँ प्रत्येक आइटम/तत्व को वेरिएबल नाम complex_list में दिखाती हैं . पाँचवीं, छठी और सातवीं पंक्तियाँ संबंधित नेस्टेड आइटम/तत्व को दर्शाती हैं, जिसे वर्गाकार कोष्ठकों की एक और जोड़ी (pair) जोड़कर निकाला जाता है। आप यह भी देख सकते हैं कि जब कोई डिक्शनरी डेटा-प्रकार होता है, सटीक कुंजी नाम का उपयोग वर्गाकार कोष्ठकों की जोड़ी के अंदर किया जाता है।

    जब निकाला गया (extracted) ​​आइटम/तत्व (नेस्टेड) बूलियन, पूर्णांक, फ्लोट या None डेटा-प्रकार का होता है, तो आप आगे नेस्टेड आइटम या वर्णों को (जैसा मामला हो) निकालने के लिए आगे नहीं जा सकते। जब निकाला गया (नेस्टेड) ​​आइटम स्ट्रिंग डेटा-प्रकार का है, तो आप इस पृष्ठ के शीर्ष पर बताए अनुसार खेल (play) सकते हैं, लेकिन आप केवल एक और आगे के स्तर पर जा सकते हैं, जैसा कि नीचे दिखाया गया है:

उपरोक्त उदाहरण से जारी

print( complex_list[1]["fword"][0], type( complex_list[1]["fword"][0] ) )   # आउटपुट h <class 'str'> ('hello' का पहला अक्षर) है।

    जब आप उपरोक्त कोड में 5 (गलत सूचकांक संख्या) या "fword" के बजाय 0 (गलत कुंजी नाम) लिखते हैं, आपको IndexError: string index out of range (स्ट्रिंग इंडेक्स सीमा से बाहर) या KeyError: 0 (जैसा मामला हो) मिलेगा। किसी भी जटिल सूची, टपल या डिक्शनरी शाब्दिक को निकालते (extracting) या काटते (slicing) समय आपको बहुत सावधान रहना चाहिए, जैसा कि ऊपर दर्शाया गया है।

उपरोक्त उदाहरण से जारी

print( complex_list[2][0][1], type( complex_list[2][0][1] ) )   # आउटपुट b <class 'str'> है। ['a', 'b', 'c'] का दूसरा आइटम/तत्व

    साथ ही, विभिन्न डेटा-प्रकारों के लिए अलग-अलग विधियाँ होती हैं। इसलिए, जब किसी जटिल शाब्दिक में स्ट्रिंग या टपल डेटा-प्रकार शाब्दिक (या चर variable नाम) मौजूद हैं, तो वे अपरिवर्तनीय (immutable) होंगे। जब सूची (list) या डिक्शनरी डेटा-प्रकार शाब्दिक मौजूद हो, तो उनमें अलग-अलग आइटम/तत्वों को संबंधित सूचकांक संख्या या संबंधित कुंजी नाम के साथ बदला जा सकता है।

उपरोक्त उदाहरण से जारी

complex_list[1]["lword"] = "public"
complex_list[2][0][1] = "x"
print( complex_list )   # आउटपुट [(11, 22, 33), {'fword': 'hello', 'lword': 'public', 'length': 3}, (['a', 'x', 'c'], ['d', 'e', 'f'])] है।

complex_list[0][1] = 55   # त्रुटि से बचने के लिए इस पंक्ति पर टिप्पणी करें
print( complex_list )   # आउटपुट TypeError: 'tuple' object does not support item assignment है।

complex_list[1][1] = 55
print( complex_list )   # आउटपुट [(11, 22, 33), {'fword': 'hello', 'lword': 'public', 'length': 3, 1: 55}, (['a', 'x', 'c'], ['d', 'e', 'f'])] है, (नेस्टेड डिक्शनरी में एक नई कुंजी जोड़ी जाएगी)।

complex_list[2][1] = 55   # त्रुटि से बचने के लिए इस पंक्ति पर टिप्पणी करें।
print( complex_list )   # आउटपुट TypeError: 'tuple' object does not support item assignment है।

complex_list[2][1][1] = 55
print( complex_list )   # आउटपुट [(11, 22, 33), {'fword': 'hello', 'lword': 'public', 'length': 3, 1: 55}, (['a', 'x', 'c'], ['d', 55, 'f'])] है।

    उपरोक्त पांच उदाहरणों से, आप देख सकते हैं कि जहां कोई भी आइटम/तत्व (चाहे वह अंदर कितनी भी गहराई में निहित हो) परिवर्तनशील है, तो नेस्टेड मानों को तदनुसार बदला जा सकता है। हालाँकि, जब कोई आइटम/तत्व अपरिवर्तनीय (immutable) है, तो आपको ऊपर दिखाए अनुसार त्रुटि मिलेगी।

len(), index(), count()

    पिछले पृष्ठ में, आप पहले से ही len() अंतर्निहित फ़ंक्शन, index() और count() विधियों के बारे में जान चुके हैं, जिन्हें स्ट्रिंग्स, सूचियों (lists) और टुपल्स (bytearray और bytes डेटा-प्रकारों पर भी) पर लागू किया जा सकता है। ये दोनों विधियाँ डिक्शनरी डेटा-प्रकार के लिए उपलब्ध नहीं हैं, इसलिए किसी भी (नेस्टेड) डिक्शनरी पर लागू होने पर, आप इन दो तरीकों से वांछित परिणाम प्राप्त नहीं कर सकते हैं और आपको त्रुटि मिलेगी।

उपरोक्त उदाहरण से जारी

print( len( complex_list[1] ) )   # आउटपुट 4 (उपरोक्त संशोधन के बाद, नेस्टेड डिक्शनरी में एक आइटम/तत्व जोड़ा गया है, और len()फ़ंक्शन से लौटाया गया मान बदल दिया जाएगा।)

print( len( complex_list ) )   # आउटपुट 3 (मूल सूची की लंबाई) है।

print( len( complex_list[0] ) )   # आउटपुट 3 (पहले नेस्टेड टुपल की लंबाई) है।

print( len( complex_list[2] ) )   # आउटपुट 2 (दूसरे नेस्टेड टुपल की लंबाई) है।

print( len( complex_list[2][0] ) )   # आउटपुट 3 (दूसरे नेस्टेड टपल के अंदर पहली नेस्टेड सूची की लंबाई) है।

print( len( complex_list[2][1] ) )   # आउटपुट 3 (दूसरे नेस्टेड टपल के अंदर दूसरी नेस्टेड सूची की लंबाई) है।

    इसी प्रकार, आप किसी भी नेस्टेड सूची (list) या नेस्टेड टपल में index() और count() विधियों की सहायता से विशिष्ट आइटम/तत्व या वर्ण और उसकी घटनाओं (occurr­ences) की खोज कर सकते हैं, लेकिन किसी नेस्टेड डिक्शनरी में नहीं। किसी भी WEB-APP (पायथन या किसी अन्य प्रोग्रामिंग भाषा वाली वेबसाइट), या अन्य एप्लिकेशन, जैसे CLI (कमांड-लाइन इंटरफ़ेस) या GUI (ग्राफ़िक-यूज़र इंटरफ़ेस) को विकसित करते समय, आपको (सभी प्रोग्रामरों द्वारा भी) कोड को सावधानी से जांच और स्क्रिप्ट करना (लिखना) होगा!

    बाद में, आप यह भी सीखेंगे कि नेस्टेड LISTS और openCV मॉड्यूल की मदद से PNG (पोर्टेबल नेटवर्क ग्राफ़िक) इमेज कैसे बनाएं।