python executing nested functions

Question

I have this piece of code, and i am confused about it's execution:

 def makeInc(x):
     def inc(y):
         return y + x
     return inc

 inc5 = makeInc(5)
 # print inc5 --->  <function inc at 0xb721bdbc>
 inc5(12)
 # print inc5(12) gives 17

So, I am wondering why it makes the sum, x+y, only on the second call of the function inc5(). I know what a closure in python really means, but I am still confused.

I have found that piece of code in this web page: http://ynniv.com/blog/2007/08/closures-in-python.html

Running the code gives me expected result of inc5(12) being 17. — Jan Vlcinsky
– Jan Vlcinsky, Commented Jul 16, 2014 at 23:38
You only call inc5 once in your code. The "first call" is to a completely separate function makeInc. — Peter Gibson
– Peter Gibson, Commented Jul 16, 2014 at 23:52
The way I see Closures are to fix faulty functions or to increment functions that need more functionality. — f.rodrigues
– f.rodrigues, Commented Jul 16, 2014 at 23:54

Jan Vlcinsky · Accepted Answer · 2014-07-17 00:15:31Z

3

Here are comments to what is happening.

makeInc is a function, which returns another function. Using closures, the returned function knows about x being set to value as it was true at the moment it was created and returned.

Calling inc2 = makeInc(5) first makes x inside makeInc set to 5, and then creates a function y. This inc function knows that x equals to 5 and will remember it as long as it lives - this is concept of closures (get in your backpack all needed variables in the environment at the moment of birth).

Calling inc5(12) executes inc(12). Inside if this call to inc it adds argument y being 12 to the value of x, which the inc5 remembers is 5, so the sum makes 17.

N.B.: Closures are used naturaly in languages like JavaScript. In Python, closures are available too, but not used so often and some developers are considering them even evil - your question shows very clearly, it is not trivial to understand, what is happening in the code - this goes against "readibility counts" from Zen of Python. Also you can find some surprises related to scope and visibility of variables. In case you do not get exactly what has happened in the code above, do not worry, Python offers many other nice challenging structures, which you will use much more often (list comprehension being one example).

edited Jul 17, 2014 at 0:15

answered Jul 16, 2014 at 23:50

Jan Vlcinsky

44.4k12 gold badges106 silver badges103 bronze badges

Sign up to request clarification or add additional context in comments.

4 Comments

redenigma Over a year ago

according to your comments, i understand that in the first call of the function makeInc() we just create the the function inc(), and this last is aware about the existance of the variable x. and in the second call inc5(12) we really call the second function inc(). but how this last one take the parameter and consider it as y

Jan Vlcinsky Over a year ago

@redenigma inc5 is almost identical to inc, so it knows about signature having as first argument y. The only difference between inc and inc5 is, that inc5 remembers (in the "backpack") the environment from the time it was returned (this affects x value, but y is just an argument to be set later on at the time of call to inc5)

redenigma Over a year ago

i have got the idea, i really appreciate your help

Jan Vlcinsky Over a year ago

@redenigma You are welcome. I have added "N.B" comment about closures not being used in Python so often. Good luck with your brave exploration.

Peter Gibson · Accepted Answer · 2014-07-17 00:06:37Z

2

The other answers explain it well, but here's a line by line breakdown of what happens in your code

 def makeInc(x): # define a function makeInc that takes a variable x

     # when makeInc is executed, define a function "inc" that takes a variable y
     def inc(y):
         # when inc is executed, return the sum (where x is closed in the outer function)
         # note this is not executed when makeInc is called
         return y + x

     # don't call inc yet, just return a reference to the function itself - note there
     # are no parenthesis after inc
     return inc

 inc5 = makeInc(5) # now execute makeInc which returns a reference to the inc function 
                   # with the variable x captured by the closure

 inc5(12) # now call the result of the above which is the only place that we call inc
          # note the parenthesis to designate the function call

 # print inc5(12) gives 17

Central to understanding this is the concept of functions as objects. In Python you can do this:

>>> def test(x):
...     return x + 6
...
>>> test(1) # call test with the argument x = 1
7
>>> a = test # assign the function "test" to a new variable "a" - this is not calling test
>>> a
<function test at 0x101cfbb90> # printing a shows the original function name "test"
>>> a(1) # now call that function again with the same value for x = 1
7

When makeInc is called, it returns a reference to inc within which has a different function signature (taking an argument called y). The fact that they both take a single argument is not relevant.

edited Jul 17, 2014 at 0:06

answered Jul 17, 2014 at 0:01

Peter Gibson

19.6k7 gold badges63 silver badges65 bronze badges

2 Comments

f.rodrigues Over a year ago

spot on. here's a good material too. simeonfranklin.com/blog/2012/jul/1/…

redenigma Over a year ago

Great, your second example has made it more clear now. in the first call we just assign the function inc() to the parent function makeInc(). in the second call we really do the call to the inc() function, and because this last one is aware about the previous x variable , the sum goes nicely. I got it now

Collectives™ on Stack Overflow

python executing nested functions

2 Answers 2

4 Comments

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

4 Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related