Why aren t python nested functions called closures

Question

I have seen and used nested functions in Python  and they match the definition of a closure   So why are they called nested functions instead of closures   Are nested functions not closures because they are not used by the external world   UPDATE  I was reading about closures and it got me thinking about this concept with respect to Python  I searched and found the article mentioned by someone in a comment below  but I couldn t completely understand the explanation in that article  so that is why I am asking this question

User · Answer

I had a situation where I needed a separate but persistent name space  I used classes  I don t otherwise  Segregated but persistent names are closures    gt  gt  gt  class f2          def   init   self               self a   0         def   call   self  arg               self a    arg             return self a       gt  gt  gt  f f2    gt  gt  gt  f 2  2  gt  gt  gt  f 2  4  gt  gt  gt  f 4  8  gt  gt  gt  f 8  16      OR    gt  gt  gt  f f2       re-initialize    gt  gt  gt  f f f f 2         nested   16    handy in list comprehensions to accumulate values  gt  gt  gt   f i  for f in  f2    for i in  2 2 4 8   -1   16

User · Answer

Python has a weak support for closure  To see what I mean take the following example of a counter using closure with JavaScript   function initCounter        var x   0      function counter               x    1          console log x              return counter     count   initCounter     count      Prints 1 count      Prints 2 count      Prints 3   Closure is quite elegant since it gives functions written like this the ability to have  internal memory   As of Python 2 7 this is not possible  If you try  def initCounter        x   0      def counter             x    1   Error  x not defined         print x     return counter  count   initCounter     count      Error count    count      You ll get an error saying that x is not defined  But how can that be if it has been shown by others that you can print it  This is because of how Python it manages the functions variable scope  While the inner function can read the outer function s variables  it cannot write them   This is a shame really  But with just read-only closure you can at least implement the function decorator pattern for which Python offers syntactic sugar   Update  As its been pointed out  there are ways to deal with python s scope limitations and I ll expose some   1  Use the global keyword  in general not recommended    2  In Python 3 x  use the nonlocal keyword  suggested by  unutbu and  leewz   3  Define a simple modifiable class Object  class Object object       pass   and create an  Object scope within initCounter to store the variables  def initCounter         scope   Object       scope x   0     def counter            scope x    1         print scope x      return counter   Since scope is really just a reference  actions taken with its fields do not really modify scope itself  so no error arises    4  An alternative way  as  unutbu pointed out  would be to define each variable as an array  x    0   and modify it s first element  x 0     1   Again no error arises because x itself is not modified   5  As suggested by  raxacoricofallapatorius  you could make x a property of counter  def initCounter          def counter            counter x    1         print counter x      counter x   0     return counter

User · Answer

The question has already been answered by aaronasterling  However  someone might be interested in how the variables are stored under the hood    Before coming to the snippet    Closures are functions that inherit variables from their enclosing environment  When you pass a function callback as an argument to another function that will do I O  this callback function will be invoked later  and this function will     almost magically     remember the context in which it was declared  along with all the variables available in that context     If a function does not use free variables it doesn t form a closure   If there is another inner level which uses free variables -- all previous levels save the lexical environment   example at the end   function attributes func closure in python  lt  3 X or   closure   in python   3 X save the free variables  Every function in python has this closure attributes  but it doesn t save any content if there is no free variables    example  of closure attributes but no content inside as there is no free variable    gt  gt  gt  def foo            def fii                pass         return fii      gt  gt  gt  f   foo    gt  gt  gt  f func closure  gt  gt  gt   func closure  in dir f  True  gt  gt  gt    NB  FREE VARIABLE IS MUST TO CREATE A CLOSURE   I will explain using the same snippet as above    gt  gt  gt  def make printer msg           def printer                print msg         return printer      gt  gt  gt  printer   make printer  Foo     gt  gt  gt  printer     Output  Foo    And all Python functions have a closure attribute so let s examine the enclosing variables associated with a closure function   Here is the attribute func closure for the function printer   gt  gt  gt   func closure  in dir printer  True  gt  gt  gt  printer func closure   lt cell at 0x108154c90  str object at 0x108151de0 gt     gt  gt  gt    The closure attribute returns a tuple of cell objects which contain details of the variables defined in the enclosing scope   The first element in the func closure which could be None or a tuple of cells that contain bindings for the function   s free variables and it is read-only    gt  gt  gt  dir printer func closure 0       class        cmp        delattr        doc        format        getattribute         hash        init        new        reduce        reduce ex        repr          setattr         sizeof        str        subclasshook      cell contents    gt  gt  gt    Here in the above output you can see cell contents  let s see what it stores    gt  gt  gt  printer func closure 0  cell contents  Foo        gt  gt  gt  type printer func closure 0  cell contents   lt type  str  gt   gt  gt  gt    So  when we called the function printer    it accesses the value stored inside the cell contents  This is how we got the output as  Foo    Again I will explain using the above snippet with some changes     gt  gt  gt  def make printer msg            def printer                 pass          return printer        gt  gt  gt  printer   make printer  Foo      gt  gt  gt  printer func closure   gt  gt  gt    In the above snippet  I din t print msg inside the printer function  so it doesn t create any free variable  As there is no free variable  there will be no content inside the closure  Thats exactly what we see above   Now I will explain another different snippet to clear out everything Free Variable with Closure    gt  gt  gt  def outer x           def intermediate y               free    free              def inner z                   return   s  s  s  s      x  y  free  z              return inner         return intermediate      gt  gt  gt  outer  I    am    variable    I am free variable   gt  gt  gt   gt  gt  gt  inter   outer  I    gt  gt  gt  inter func closure   lt cell at 0x10c989130  str object at 0x10c831b98 gt     gt  gt  gt  inter func closure 0  cell contents  I   gt  gt  gt  inn   inter  am     So  we see that a func closure property is a tuple of closure cells  we can refer them and their contents explicitly -- a cell has property  cell contents    gt  gt  gt  inn func closure   lt cell at 0x10c9807c0  str object at 0x10c9b0990 gt      lt cell at 0x10c980f68  str object at   0x10c9eaf30 gt      lt cell at 0x10c989130  str object at 0x10c831b98 gt    gt  gt  gt  for i in inn func closure          print i cell contents     free am  I  gt  gt  gt    Here when we called inn  it will refer all the save free variables so we get I am free variable   gt  gt  gt  inn  variable    I am free variable   gt  gt  gt

User · Answer

I d like to offer another simple comparison between python and JS example  if this helps make things clearer     JS   function make        var cl   1    function gett          console log cl         function sett  val        cl   val        return  gett  sett      and executing     a   make    g   a 0   s   a 1   s 2   g       2 s 3   g       3   Python   def make        cl   1   def gett         print cl     def sett  val       cl   val   return gett  sett   and executing   g  s   make   g    1 s 2   g    1 s 3   g    1   Reason  As many others said above  in python  if there is an assignment in the inner scope to a variable with the same name  a new reference in the inner scope is created  Not so with JS  unless you explicitly declare one with the var keyword

User · Answer

def nested1 num1        print  nested1 has  num1     def nested2 num2           print  nested2 has  num2  and it can reach to  num1         return num1 num2     num1 referenced for reading here     return nested2   Gives   In  17   my func nested1 8  nested1 has 8  In  21   my func 5  nested2 has 5 and it can reach to 8 Out 21   13   This is an example of what a closure is and how it can be used

User · Answer

People are confusing about what closure is  Closure is not the inner function  the meaning of closure is act of closing  So inner function is closing over a nonlocal variable which is called free variable  def counter in initial value 0         initial value is the free variable     def inc increment 1           nonlocal initial value         initial value    increment         return print initial value      return inc  when you call counter in   this will return inc function which has a free variable initial value  So we created a CLOSURE  people call inc as closure function and I think this is confusing people  people think  quot ok inner functions are closures quot   in reality inc is not a closure  since it is part of the closure  to make life easy  they call it closure function    myClosingOverFunc counter in 2   this returns inc function which is closing over the free variable initial value  when you invoke myClosingOverFunc  myClosingOverFunc     it will print 2  when python sees that a closure sytem exists  it creates a new obj called CELL  this will store only the name of the free variable which is initial value in this case  This Cell obj will point to another object which stores the value of the initial value  in our example  initial value in outer function and inner function will point to this cell object  and this cell object will be point to the value of the initial value    variable initial value       gt  gt  CELL            gt  gt  value of initial value  So when you call counter in its scope is gone  but it does not matter  because variable initial value is directly referencing the CELL Obj  and it indirectly references the value of initial value  That is why even though scope of outer function is gone  inner function will still have access to the free variable let s say I want to write a function  which takes in a function as an arg and returns how many times this function is called  def counter fn         since cnt is a free var  python will create a cell and this cell will point to the value of cnt       every time cnt changes  cell will be pointing to the new value     cnt   0      def inner  args    kwargs             we cannot modidy cnt with out nonlocal         nonlocal cnt         cnt    1         print f  fn   name    has been called  cnt  times             we are calling fn indirectly via the closue inner         return fn  args    kwargs      return inner         in this example cnt is our free variable and inner   cnt create CLOSURE  when python sees this it will create a CELL Obj and cnt will always directly reference this cell obj and CELL will reference the another obj in the memory which stores the value of cnt  initially cnt 0   cnt          gt  gt  gt  gt   CELL                gt   0  when you invoke the inner function wih passing a parameter counter myFunc    this will increase the cnt by 1  so our referencing schema will change as follow   cnt          gt  gt  gt  gt   CELL                gt   1   first counter myFunc     cnt          gt  gt  gt  gt   CELL                gt   2   second counter myFunc     cnt          gt  gt  gt  gt   CELL                gt   3   third counter myFunc     this is only one instance of closure  You can create multiple instances of closure with passing another function counter differentFunc     this will create a different CELL obj from the above  We just have created another closure instance   cnt         gt  gt   difCELL           gt   1   first counter differentFunc     cnt         gt  gt   difCELL           gt   2   secon counter differentFunc     cnt         gt  gt   difCELL           gt   3   third counter differentFunc

User · Answer

A closure occurs when a function has access to a local variable from an enclosing scope that has finished its execution   def make printer msg       def printer            print msg     return printer  printer   make printer  Foo    printer     When make printer is called  a new frame is put on the stack with the compiled code for the printer function as a constant and the value of msg as a local  It then creates and returns the function  Because the function printer references the msg variable  it is kept alive after the make printer function has returned    So  if your nested functions don t    access variables that are local to enclosing scopes   do so when they are executed outside of that scope    then they are not closures   Here s an example of a nested function which is not a closure   def make printer msg       def printer msg msg           print msg     return printer  printer   make printer  Foo    printer     Output  Foo    Here  we are binding the value to the default value of a parameter  This occurs when the function printer is created and so no reference to the value of msg external to printer  needs to be maintained after make printer returns  msg is just a normal local variable of the function printer in this context

User · Answer

Python 2 didn t have closures - it had workarounds that resembled closures   There are plenty of examples in answers already given - copying in variables to the inner function  modifying an object on the inner function  etc   In Python 3  support is more explicit - and succinct   def closure        count   0     def inner            nonlocal count         count    1         print count      return inner   Usage   start   closure   start     prints 1 start     prints 2 start     prints 3   The nonlocal keyword binds the inner function to the outer variable explicitly mentioned  in effect enclosing it  Hence more explicitly a  closure

[python] Why aren't python nested functions called closures?

Examples related to python

Examples related to closures

Examples related to nested-function