Introduction
Python closure is a technique for binding function with an environment where the function gets access to all the variables defined in the enclosing scope. Closure typically appears in the programming language with first class function, which means functions are allowed to be passed as arguments, return value or assigned to a variable.
This definition sounds confusing to the python beginners, and sometimes the examples found from online also not intuitive enough in the way that most of the examples are trying to illustrate with some printing statement, so the readers may not get the whole idea of why and how the closure should be used. In this article, I will be using some real-world example to explain how to use closure in your code.
Nested function in Python
To understand closure, we must first know that Python has nested function where one function can be defined inside another. For instance, the below inner_func is the nested function and the outer_func returns it’s nested function as return value.
def outer_func():
print("starting outer func")
def inner_func():
pi = 3.1415926
print(f"pi is : {pi}")
return inner_func
When you invoke the outer_func, it returns the reference to the inner_func, and subsequently you can call the inner_func. Below is the output when you run in Jupyter Notebook:
After you have got some feeling about the nested function, let’s continue to explore how nested function is related to closure. If we modify our previous function and move the pi variable into outer function, surprisedly it generates the same result as previously.
def outer_func():
print("starting outer func")
#move pi variable definition to outer function
pi = 3.1415926
def inner_func():
print(f"pi is : {pi}")
return inner_func
You may wonder the pi variable is defined in outer function which is a local variable to outer_func, why inner_func is able access it since it’s not a global scope? This is exactly where closure happens, the inner_func has the full access to the environment (variables) in it’s enclosing scope. The inner_func refers to pi variable as nonlocal variable since there is no other local variable called pi.
If you want to modify the value of the pi inside the inner_func, you will have to explicitly specify “nonlocal pi” before you modify it since it’s immutable data type.
With the above understanding, now let’s walk through some real-world examples to see how we can use closure in our code.
Hide data with Python closure
Let’s say we want to implement a counter to record how many time the word has been repeated. The first thing you may want to do is to define a dictionary in global scope, and then create a function to add in the words as key into this dictionary and also update the number of times it repeated. Below is the sample code:
counter = {}
def count_word(word):
global counter
counter[word] = counter.get(word, 0) + 1
return counter[word]
To make sure the count_word function updates the correct “counter”, we need to put the global keyword to explicitly tell Python interpreter to use the “counter” defined in global scope, not any variable we accidentally defined with the same name in the local scope (within this function).
Sample output:
The above code works as expected, but there are two potential issues: Firstly, the global variable is accessible to any of the other functions and you cannot guarantee your data won’t be modified by others. Secondly, the global variable exists in the memory as long as the program is still running, so you may not want to create so many global variables if not necessary.
To address these two issues, let’s re-implement it with closure:
def word_counter():
counter = {}
def count(word):
counter[word] = counter.get(word, 0) + 1
return counter[word]
return count
If we run it from Jupyter Notebook, you will see the below output:
With this implementation, the counter dictionary is hidden from the public access and the functionality remains the same. (you may notice it works even after the word_counter function is deleted)
Convert small class to function with Python closure
Occasionally in your project, you may want to implement a small utility class to do some simple task. Let’s take a look at the below example:
import requests
class RequestMaker:
def __init__(self, base_url):
self.url = base_url
def request(self, **kwargs):
return requests.get(self.url.format_map(kwargs))
You can see the below output when you call the make_request from an instance of RequestMaker:
Since you’ve already seen in the word counter example, the closure can also hold the data for your later use, the above class can be converted into a function with closure:
import requests
def request_maker(url):
def make_request(**kwargs):
return requests.get(url.format_map(kwargs))
return make_request
The code becomes more concise and achieves the same result. Take note that in the above code, we are able to pass in the arguments into the nested function with **kwargs (or *args).
Replace text with case matching
When you use regular express to find and replace some text, you may realize if you are trying to match text in case insensitive mode, you will not able to replace the text with proper case. For instance:
import re
paragraph = 'To start Python programming, you need to install python and configure PYTHON env.'
re.sub("python", "java", paragraph, flags=re.I)
Output from above:
It indeed replaced all the occurrence of the “python”, but the case does not match with the original text. To solve this problem, let’s implement the replace function with closure:
def replace_case(word):
def replace(m):
text = m.group()
if text.islower():
return word.lower()
elif text.isupper():
return word.upper()
elif text[0].isupper():
return word.capitalize()
else:
return word
return replace
In the above code, the replace function has the access to the original text we intend to replace with, and when we detect the case of the matched text, we can convert the case of original text and return it back.
So in our original substitute function, let’s pass in a function replace_case(“java”) as the second argument. (You may refer to Python official doc in case you want to know what is the behavior when passing in function to re.sub)
re.sub("python", replace_case("java"), paragraph, flags=re.IGNORECASE)
If we run the above again, you should be able to see the case has been retained during the replacement as per below:
Conclusion
In this article, we have discussed about the general reasons why Python closure is used and also demonstrated how it can be used in your code with 3 real-world examples. In fact, Python decorator is also a use case of closure, I will be discussing this topic in the next article.
