पायथन में रिकर्सन
प्रोग्रामिंग में एक ऐसी अवधारणा है, जिसे रिकर्सन कहा जाता है - जब कोई फ़ंक्शन स्वयं को कॉल करता है।
उदाहरण . काउंटर के साथ सरल रिकर्सन
आइए रिकर्सन का उपयोग करके 1 से
10 तक की संख्याएँ प्रिंट करें:
i = 1
def func():
global i
print(i)
i += 1
if i <= 10:
func() # यहाँ फ़ंक्शन स्वयं को कॉल करता है
func()
आइए चर्चा करें कि यह कोड कैसे काम करता है।
हमारे पास एक ग्लोबल वेरिएबल i
और एक फ़ंक्शन func है, जिसके अंदर
वेरिएबल i की वैल्यू को कंसोल में
प्रिंट किया जाता है, और फिर उसमें एक
जोड़ दिया जाता है।
यदि हमारा वेरिएबल i, 10 से
कम या बराबर है, तो फ़ंक्शन को दोबारा कॉल
किया जाता है। चूंकि वेरिएबल i -
ग्लोबल है, तो फ़ंक्शन के हर नए कॉल पर
इसमें पिछले कॉल में सेट की गई i
वेरिएबल की वैल्यू होगी।
ऐसा होगा कि फ़ंक्शन तब तक स्वयं को कॉल
करता रहेगा, जब तक कि i, 10
से अधिक नहीं हो जाता।
ध्यान रखें, हमारे मामले में if के
बिना फ़ंक्शन को नहीं चलाया जा सकता - यदि
ऐसा किया जाता है, तो फ़ंक्शन का अनंत कॉल
होगा।
उदाहरण . नेस्टेड लिस्ट के एलिमेंट्स प्रिंट करने के लिए रिकर्सन
रिकर्सन का सबसे अधिक उपयोग विभिन्न स्तरों की नेस्टेड लिस्ट को इटरेट करने के लिए किया जाता है। मान लीजिए हमारे पास निम्नलिखित लिस्ट है:
lst = [1, [2, 3], [[4, 5], [6, 7, 8, [9]]]]
आइए एक ऐसा फ़ंक्शन बनाएं जो इसे इटरेट
करे। इसमें पहले एक कंडीशन सेट करनी होगी,
ताकि प्रिमिटिव एलिमेंट, यानी लिस्ट से
निकाला गया साधारण नंबर, कंसोल में प्रिंट
हो जाए। और यदि एलिमेंट एक ऑब्जेक्ट है,
उदाहरण के लिए एक नेस्टेड लिस्ट, तो इस
केस में फ़ंक्शन स्वयं को कॉल करे, यानी
रिकर्सन हो। एलिमेंट के टाइप की जांच के
लिए हम isinstance फ़ंक्शन का उपयोग
करेंगे। केवल हमारे उदाहरण के लिए isinstance
के पहले पैरामीटर में हम el लिखेंगे,
और दूसरे में टाइप list:
def func(lst):
for el in lst:
if isinstance(el, list):
func(el)
else:
print(el)
फ़ंक्शन को कॉल करने पर नेस्टेड लिस्ट के सभी नंबरों की श्रृंखला प्रिंट होगी:
func(lst) # 1, 2, ... 8, 9 प्रिंट करेगा
उदाहरण . नेस्टेड लिस्ट के एलिमेंट्स के साथ ऑपरेशन के लिए रिकर्सन
रिकर्सन का उपयोग नेस्टेड लिस्ट के एलिमेंट्स के साथ विभिन्न ऑपरेशन के लिए भी किया जा सकता है। मान लीजिए हमारे पास निम्नलिखित लिस्ट है:
lst = [1, [2, 3], [[4, 5], [6, 7, 8, [9]]]]
आइए इसके सभी एलिमेंट्स का योग प्राप्त
करें। इसके लिए फ़ंक्शन के अंदर एक वेरिएबल
res डिक्लेयर करेंगे, जिसमें नंबरों
का योग जमा होगा। कंडीशन में लिखेंगे कि
यदि एलिमेंट एक कॉम्प्लेक्स ऑब्जेक्ट है,
तो वह func फ़ंक्शन के पैरामीटर में
आएगा और योग में जुड़ जाएगा। इसका मतलब है
कि एलिमेंट रिकर्सन में तब तक रहेगा जब तक
वह प्रिमिटिव नहीं बन जाता। और इस केस में
वह सीधे res में लिखे योग में जुड़
जाएगा:
def func(lst):
res = 0
for el in lst:
if isinstance(el, list):
res += func(el)
else:
res += el
return res
आइए फ़ंक्शन को कॉल करें और इसके रिजल्ट को कंसोल में प्रिंट करें:
print(func(lst)) # 45 प्रिंट करेगा
उदाहरण . लिस्ट में जमा करने के लिए रिकर्सन
रिकर्सन की मदद से नेस्टेड लिस्ट को एक वन-डायमेंशनल लिस्ट में बदला जा सकता है। मान लीजिए हमारे पास निम्नलिखित लिस्ट है:
lst = [1, [2, 3], [[4, 5], [6, 7, 8, [9]]]]
आइए फ़ंक्शन में एक खाली लिस्ट res
लिखें, जिसमें सोर्स लिस्ट के एलिमेंट्स
जमा होंगे। इसके बाद एक लूप चलाएंगे और
एक कंडीशन सेट करेंगे - यदि एलिमेंट एक
लिस्ट है, तो वह extend मेथड में
जाएगा। यह मेथड एक लिस्ट के एलिमेंट्स को
दूसरी लिस्ट के अंत में जोड़ता है, यानी
नेस्टेड लिस्ट के एलिमेंट res लिस्ट
के अंत में चले जाएंगे:
def func(lst):
res = []
for el in lst:
if isinstance(el, list):
res.extend(func(el))
else:
res.append(el)
return res
print(func(lst))
निष्पादित कोड का परिणाम:
[1, 2, 3, 4, 5, 6, 7, 8, 9]
प्रैक्टिकल टास्क
एक मनमाना लेवल की नेस्टिंग वाले डिक्शनरी के सभी न्यूमेरिक एलिमेंट्स प्रिंट करें:
{
'a': {
'b': 1,
'c': 2,
'd': {
'e': 3,
'f': 4
}
},
'j': {
'h': 5,
'k': 6,
},
'l': 7
}
पिछली टास्क के डिक्शनरी के एलिमेंट्स का योग ज्ञात करें।
पिछली टास्क के डिक्शनरी के प्रिमिटिव एलिमेंट्स की लिस्ट प्राप्त करें।
