පයිතන් හි ක්ලෝසර්
ක්ලෝසර් (closure) යනු එයට ප්රවේශ විය හැකි සියලුම බාහිර විචල්යයන් සමඟ සම්බන්ධ කරන ලද ශ්රිතයකි.
පයිතන් වල, "ශ්රිතයක ක්ලෝසර්" යැයි කියන විට, බොහෝ විට එම ශ්රිතයම නොව, එහි බාහිර විචල්යයන් ගැනයි අදහස් වන්නේ.
අපට outer යනුවෙන් ශ්රිතයක් ඇතැයි සිතමු, එහි i විචල්යයක් සහ inner යන අභ්යන්තර ශ්රිතයක් අර්ථ දක්වා ඇත. එහි i වෙත එකක් එකතු කරනු ලැබේ. i විචල්යය නිවැරදිව ක්රියා කිරීම සඳහා, අපි එයට nonlocal උපදෙස් එකතු කරමු:
def outer():
i = 0
def inner():
nonlocal i
i += 1
print(i)
return inner
දැන් අපි බාහිර ශ්රිතය res විචල්යයට ඇතුළත් කර වරහන් සමඟ එය කැඳවමු:
res = outer()
res() # 1 ප්රතිදානය කරයි
අපි res කිහිප වරක් කැඳවමු. කේතය ක්රියාත්මක කිරීමෙන් පසු, සෑම අවස්ථාවකම i ගණකය එකකින් වැඩි වේ:
res() # 2 ප්රතිදානය කරයි
res() # 3 ප්රතිදානය කරයි
res() # 4 ප්රතිදානය කරයි
කෙසේ වෙතත්, මෙහි වැදගත් සූක්ෂ්ම කරුණක් ඇත - සෑම අවස්ථාවකම outer ශ්රිතය කැඳවීමෙන් එහි ගණකය වැඩි වේ. පළමු outer කැඳවීම res1 විචල්යයට ලියා දෙවැන්න res2 විචල්යයට ලියමු. ඉන්පසු අපි ඒවා අනුක්රමිකව කොන්සෝලයට ප්රතිදානය කරමු:
res1 = outer()
res1() # 1 ප්රතිදානය කරයි
res1() # 2 ප්රතිදානය කරයි
res1() # 3 ප්රතිදානය කරයි
res2 = outer()
res2() # 1 ප්රතිදානය කරයි
res2() # 2 ප්රතිදානය කරයි
res2() # 3 ප්රතිදානය කරයි
පහත කේතය ලබා දී ඇත:
def outer():
i = 10
def inner():
nonlocal i
i -= 2
print(i)
return inner
res1 = outer()
res1()
res1()
res2 = outer()
res2()
res2()
res2()
කොන්සෝලයේ යම් දෙයක් ප්රතිදානය වන බව කියන්න.
ශ්රිතයක් සාදන්න, එහි සෑම කැඳවීමක්ම ඊළඟ ෆිබොනාච්චි අංකය ලබා දෙනු ඇත.
පරාසයක අහඹු පූර්ණ සංඛ්යාවක් ලබා දෙන ශ්රිතයක් සාදන්න, නමුත් එකම අංකය අඛණ්ඩව දෙවරක් ලැබෙන ආකාරයට නොවේ.
