5 Levels of Understanding Closures in Python
Introduction
Functions in Python are first-class citizens. This means we can operate functions like other objects:
- Pass functions as arguments
- Assign a function to a variable
- Return a function from another function (nested functions)
Based on these, Python supports a powerful technique: closure.
Most of us heard about the closure, but totally understand it and use it well are not easy.
Fortunately, this post will uncover the mystery of closures layer by layer. It’s time to make a cup of coffee and enjoy this technique. ☕️
Level 0: Understand What the Closure Is
The closure is a concept in the context of nested functions. Let’s see it by an interesting example:
The above example could be very wired if you haven’t known closures yet. We have already deleted the outer_func function. However, the f() can still print “Yang Zhou”, which is the local variable of the outer_func function. Why its local variable is still alive after removing the function?
Obviously, it is not because Yang Zhou is a magician. This is the effect of the closure technique.
Operationally, a closure is a record storing a function together with an environment. (Wikipedia)
As to our example, the inner function print_leader can “remember” the variables in the outer function.
In a word, the closure in Python is a function which remembers values in its enclosing scope.
Level 1: Distinguish Closures From Nested Functions
Although closures are in the context of nested functions, nested functions are not necessarily closures. The appearance of the closure must meet three conditions:
- There are nested functions.
- The inner function must use variables defined in its outer function.
- The outer function must return the inner function.
Let’s change a little bit of the previous example:
As the above shown, if we return the result of the inner function. No closures will occur. The f is a NoneType since it didn’t receive the print_leader function, the print_leader function has already executed.
Level 2: Know How to Get the Enclosed Values
In fact, every function in Python has a special attribute called __closure__, which stores all the “remembered” values.
As the above example shown, the outer_func is not a closure and its __closure__ attribute is None. In the other hand, the __closure__ of f contains a cell object which saves the “remembered” value.
Level 3: Implement a Bug-Free Closure
Closures are not easy to implement and we should use them carefully.
A negative example
Let’s look at an example program, which is going to save three functions in a list and run them one by one to print three different even numbers:
The results of the above example are not as expected. Why all the three functions printed the same values?
Review the code again and we can see that the enclosed variable i was already equal to 2 when we really run the f1(), f2(), and f3() in the print() method. If we print their __closure__ attributes, the results are as following:
An interview question
Based on the above example, here comes a good interview question:
How to change the code to print three different values by different functions?
Stop for two minutes and think about it!
A solution is as following:
As the above shown, we use a variable j to receive parameter i, and the results are as expected! However, this time the three functions are not closures since they don’t need to “remember” any variables in their enclosing scope.
Recall the second condition of the 3 conditions to build a closure mentioned in level 1:
The inner function must use variables defined in its outer function.
In the above example, the variable i was not used in the inner function. It just passed a value as an argument to the parameter j of the inner function. Therefore, no closure was created.
A lesson learned from the above examples
We should be careful when the inner function references some enclosing variables which will be changed later.
Level 4: Use Closures Skilfully
The closure is an advanced weapon of Python. It could be a little hard for beginners. However, if we can totally understand it and use it skilfully, it will help us a lot. Actually, decorators in Python are just extensive applications of closures.
In this final level, two significant tips will be shown to help you master closures.
Use lambda function to simplify the code
We can make the previous example code more elegant by the lambda function:
Closures hide private variables more effectively
Python doesn’t have built-in keywords like public or private to control the accessibility of variables. By convention, we use double underscores to define a private member of a class. But the “private” variable can still be accessed.
Sometimes, we need stronger protections to a hidden variable. Closures can help!
As the example6.py shown, it’s more difficult to get and change the value of the leader variable in the function f. The leader variable is more “private”.
Conclusion
Python supports the closure, which is a functional programming relative technique. After completely understanding it, we can use it to write more elegant and functional style programs.
Thanks for reading! Relative posts:
