පයිතන් හි ක්ලෝසර්

ක්ලෝසර් (closure) යනු එයට ප්‍රවේශ විය හැකි සියලුම බාහිර විචල්යයන් සමඟ සම්බන්ධ කරන ලද ශ්‍රිතයකි.

පයිතන් වල, "ශ්‍රිතයක ක්ලෝසර්" යැයි කියන විට, බොහෝ විට එම ශ්‍රිතයම නොව, එහි බාහිර විචල්යයන් ගැනයි අදහස් වන්නේ.

අපට outer යනුවෙන් ශ්‍රිතයක් ඇතැයි සිතමු, එහි i විචල්යයක් සහ inner යන අභ්‍යන්තර ශ්‍රිතයක් අර්ථ දක්වා ඇත. එහි i වෙත එකක් එකතු කරනු ලැබේ. i විචල්යය නිවැරදිව ක්‍රියා කිරීම සඳහා, අපි එයට nonlocal උපදෙස් එකතු කරමු:

pythondef outer():
  i = 0
  def inner():
    nonlocal i
    i += 1
    print(i)
  
  return inner

දැන් අපි බාහිර ශ්‍රිතය res විචල්යයට ඇතුළත් කර වරහන් සමඟ එය කැඳවමු:

pythonres = outer()
res() # 1 ප්‍රතිදානය කරයි

අපි res කිහිප වරක් කැඳවමු. කේතය ක්‍රියාත්මක කිරීමෙන් පසු, සෑම අවස්ථාවකම i ගණකය එකකින් වැඩි වේ:

pythonres() # 2 ප්‍රතිදානය කරයි
res() # 3 ප්‍රතිදානය කරයි
res() # 4 ප්‍රතිදානය කරයි

කෙසේ වෙතත්, මෙහි වැදගත් සූක්ෂ්ම කරුණක් ඇත - සෑම අවස්ථාවකම outer ශ්‍රිතය කැඳවීමෙන් එහි ගණකය වැඩි වේ. පළමු outer කැඳවීම res1 විචල්යයට ලියා දෙවැන්න res2 විචල්යයට ලියමු. ඉන්පසු අපි ඒවා අනුක්රමිකව කොන්සෝලයට ප්‍රතිදානය කරමු:

pythonres1 = outer()
res1() # 1 ප්‍රතිදානය කරයි
res1() # 2 ප්‍රතිදානය කරයි
res1() # 3 ප්‍රතිදානය කරයි

res2 = outer()
res2() # 1 ප්‍රතිදානය කරයි
res2() # 2 ප්‍රතිදානය කරයි
res2() # 3 ප්‍රතිදානය කරයි

pythondef outer():
  i = 10

  def inner():
    nonlocal i
    i -= 2
    print(i)
  return inner
  
res1 = outer()
res1()
res1()

res2 = outer()
res2()
res2()
res2()