पायथन क्लोजर्स को बेहतर ढंग से समझने के लिए, आइए पहले समझें कि नेस्टेड फंक्शन और पायथन क्लास क्या है। संक्षेप में, पायथन क्लोजर भी एक फंक्शन है जो डेटा को कोड के साथ एनकैप्सुलेट करता है।
पायथन नेस्टेड फंक्शन
एक फंक्शन जो किसी अन्य फंक्शन के अंदर परिभाषित किया गया है, उसे नेस्टेड फंक्शन कहा जाता है। एक नेस्टेड फंक्शन एनक्लोजिंग स्कोप के वेरिएबल्स को एक्सेस कर सकता है।
def funcOut():
print("This is outer function.")
def funcIn():
print("This function is defined inside funcOut. \nThis function(funcIn) is called nested function.")
print("We can call nested function here.")
funcIn()
print("We are in outer function.\nCalling funcOut.")
funcOut()
आउटपुट
We are in outer function. Calling funcOut. This is outer function. We can call nested function here. This function is defined inside funcOut. This function(funcIn) is called nested function.
तो, funcIn वह नेस्टेड फंक्शन है जिसे funcOut के अंदर परिभाषित किया गया है। उपरोक्त आउटपुट देखकर, हम फंक्शंस के कॉलिंग सीक्वेंस को समझ सकते हैं।
यदि हम funcOut से funcIn की सभी कार्यक्षमताएं चाहते हैं, तो इसके लिए हमें उपरोक्त प्रोग्राम में "return funcIn" करना पड़ सकता है, इसे पायथन में क्लोजर कहा जाता है।
संक्षेप में, एक क्लोजर एक फंक्शन (ऑब्जेक्ट) है जो अपने निर्माण वातावरण (एनक्लोजिंग स्कोप) को याद रखता है।
def closureFunc(start):
def incrementBy(inc):
return start + inc
return incrementBy
closure1 = closureFunc(9)
closure2 = closureFunc(90)
print('clsure1(3) = %s' % (closure1(3)))
print('closure2(3) = %s' % (closure2(3)))
आउटपुट
clsure1(3) = 12 closure2(3) = 93
वेरिएबल closure1 (जो फंक्शन टाइप का है) को closure1(3) के साथ कॉल करने पर 12 लौटाएगा, जबकि closure2(3) 93 लौटाएगा। जबकि closure1 और closure2 दोनों उसी फंक्शन incrementBy को रेफरेंस कर रहे हैं, हमारे पास दो अलग-अलग वेरिएबल्स closure1 और closure2 हैं जो आइडेंटिफायर closureFunc द्वारा एक साथ बंधे हुए हैं, जिससे अलग-अलग परिणाम मिलते हैं।
__closure__ एट्रिब्यूट और सेल ऑब्जेक्ट्स
अधिक जानकारी प्राप्त करने के लिए हम __closure__ एट्रिब्यूट और सेल ऑब्जेक्ट्स का उपयोग कर सकते हैं:
def closureFunc(start):
def incrementBy(inc):
return start + inc
return incrementBy
a = closureFunc(9)
b = closureFunc(90)
print('type(a)=%s' % (type(a)))
print('a.__closure__=%s' % (a.__closure__))
print('type(a.__closure__[0])=%s' % (type(a.__closure__[0])))
print('a.__closure__[0].cell_contents=%s' % (a.__closure__[0].cell_contents))
print('type(b)=%s' % (type(b)))
print('b.__closure__=%s' % (b.__closure__))
print('type(b.__closure__[0])=%s' % (type(b.__closure__[0])))
print('b.__closure__[0].cell_contents=%s' % (b.__closure__[0].cell_contents))
आउटपुट
type(a) =a.__closure__ = type(a.__closure__[0]) = | a.__closure__[0].cell_contents = 9 type(b) = b.__closure__ = type(b.__closure__[0]) = | b.__closure__[0].cell_contents = 90
उपरोक्त आउटपुट से, हम देख सकते हैं कि ऑब्जेक्ट्स का प्रत्येक सेल उसके निर्माण के समय मान को बरकरार रखता है।
