पायथन क्लोजर को बेहतर ढंग से समझने के लिए, आइए पहले समझते हैं कि नेस्टेड फ़ंक्शन और पायथन क्लास क्या है। संक्षेप में, पायथन क्लोजर भी एक ऐसा फंक्शन है जो कोड के साथ डेटा को इनकैप्सुलेट करता है।
पायथन नेस्टेड फ़ंक्शन
किसी अन्य फ़ंक्शन के अंदर परिभाषित फ़ंक्शन को नेस्टेड फ़ंक्शन कहा जाता है। एक नेस्टेड फ़ंक्शन संलग्न दायरे के चरों तक पहुंच सकता है।
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 की सभी कार्यक्षमताओं को प्राप्त करना चाहते हैं, तो इसके लिए हमें उपरोक्त प्रोग्राम में “वापसी 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
क्लोजर 1 (3) के साथ वैरिएबल क्लोजर 1 (जो फ़ंक्शन प्रकार का है) को कॉल करना 12 वापस आ जाएगा, जबकि क्लोजर 2 (3) 93 वापस आ जाएगा। जबकि क्लोजर 1 और क्लोजर 2 दोनों एक ही फ़ंक्शन वृद्धि को संदर्भित कर रहे हैं, हमारे पास दो अलग-अलग चर हैं क्लोजर 1 और क्लोजर 2 जो पहचानकर्ता closureFunc द्वारा एक साथ बंधे होते हैं, जिससे विभिन्न परिणाम प्राप्त होते हैं।
__closure__ attribute and cell objects
अधिक जानकारी प्राप्त करने के लिए हम __क्लोजर__ विशेषता और सेल ऑब्जेक्ट का उपयोग कर सकते हैं:
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) = <class 'function'> a.__closure__ = <cell at 0x057F8490: int object at 0x68A65770> type(a.__closure__[0]) = <class 'cell'> a.__closure__[0].cell_contents = 9 type(b)=<class 'function'> b.__closure__ = <cell at 0x0580BD50: int object at 0x68A65C80> type(b.__closure__[0]) = <class 'cell'> b.__closure__[0].cell_contents=90
उपरोक्त आउटपुट से, हम देख सकते हैं कि वस्तुओं की प्रत्येक कोशिका इसके निर्माण के समय मूल्य को बरकरार रखती है।