Let’s look at three common reasons for writing inner functions.
Remember: In Python, a function is a “first-class” citizen, meaning they are on par with any other object (i.e., integers, strings, lists, modules, etc.). You can dynamically create or destroy them, pass them to other functions, return them as values, and so forth.
This tutorial utilizes Python version 3.4.1.
You use inner functions to protect them from anything happening outside of the function, meaning that they are hidden from the global scope.
Here’s a simple example that highlights that concept:
1 2 3 4 5 6 7 8
Try calling the
1 2 3 4
Now comment out the
inner_increment call and uncomment the outer function call,
outer(10), passing in
10 as the argument:
Keep in mind that this is just an example. Although this code does achieve the desired result, it’s probably better to make the
inner_increment()function a top-level “private” function using a leading underscore:
The following recursive example is a slightly better use case for a nested function:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
Test this out as well. One main advantage of using this design pattern is that by performing all argument checking in the outer function, you can safely skip error checking altogether in the inner function.
For a more detailed discussion of recursion see, Problem Solving with Algorithms and Data Structures.
2. Keepin’ it DRY
Perhaps you have a giant function that performs the same chunk of code in numerous places. For example, you might write a function which processes a file, and you want to accept either an open file object or a file name:
1 2 3 4 5 6 7 8 9
Again, it is common to just make
do_stuff()a private top-level function, but if you want to hide it away as an internal function, you can.
How about a practical example?
Let’s say you want to know the number of WiFi hot spots in New York City. And yes the city has the raw data to tell us: datasource. Visit the site and download the CSV.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
Run the function:
3. Closures and Factory Functions
Now we come to the most important reason to use inner functions. All of the inner function examples we’ve seen so far have been ordinary functions that merely happened to be nested inside another function. In other words, we could have defined these functions in another way (as discussed); there is no specific reason for why they should be nested.
But when it comes to closure, that is not the case: You must utilize nested functions.
What’s a closure?
A closure simply causes the inner function to remember the state of its environment when called. Beginners often think that a closure is the inner function, when it’s really caused by the inner function. The closure “closes” the local variable on the stack and this stays around after the the stack creation has finished executing.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
What’s happening here?
- The ‘generate_power()’ function is a factory function – which simply means that it creates a new function each time it is called and then returns the newly created function. Thus,
raise_threeare the newly created functions.
- What does this new, inner function do? It takes a single argument,
power, and returns
Where does the inner function get the value of
numberfrom? This is where the closure comes into play:
nth_power()gets the value of
powerfrom the outer function, the factory function. Let’s step through this process:
- Call the outer function:
- Build the
nth_power()function which takes a single argument
- Take a snapshot of the state of
- Pass that snapshot into the
- Return the
Put another way, the closure functions to “initialize” the number bar in the
nth_power()function and then returns it. Now, whenever you call that newly returned function, it will always see its own private snapshot that includes
- Call the outer function:
How about a real world example?
1 2 3 4 5 6 7 8 9 10 11 12 13 14
This is a simplified function to check if a certain user has the correct permissions to access a certain page. You could easily modify this to grab the user in session to check if they have the correct credentials to access a certain route. Instead of checking if the user is just equal to ‘Admin’, you could query the database to check the permission then return the correct view depending on whether the credentials are correct or not.
The use of closures and factory functions is the most common, and powerful, use for inner functions. In most cases, when you see a decorated function, the decorator is a factory function which takes a function as argument, and returns a new function which includes the old function inside the closure. Stop. Take a deep breath. Grab a coffee. Read that again.
Put another way, a decorator is just syntactic sugar for implementing the process outlined in the
I’ll leave you with an example:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
If your code editor allows it, view the
generate_power(number) functions side-by-side to illustrate the concepts discussed. (Sublime Text has Column View, for example).
If you have not coded the two functions, open the code editor and start coding. For new programmers, coding is a hands on activity, like riding a bike you just have to do it – and do it solo. So back to the task at hand. After you typed the code, you can now clearly see that the code is similar in that it produces the same results but there are differences. For those who have never used decorators, noting these differences will be the first step in understanding them if you venture down that path.
If you’d like to know more about this syntax and decorators in general, check out our Primer on Python Decorators. Comment below with questions.
Edits made by Derrick Kearney. Thank you!