Search for a command to run...
Transformative Tech Leader | Serial Entrepreneur & Machine Learning Engineer Leveraging 3+ years of expertise in Machine Learning and a background in Web Development, I drive innovation through building, mentoring, and educating. Passionate about harnessing AI to solve real-world problems."
No comments yet. Be the first to comment.
Loops are one of the most fundamental concepts in programming. They allow you to repeat a block of code multiple times without having to write it over and over again. Let's dive deep into Python's two main types of loops: for loops and while loops. ...
What is Git? Introduction to Git Git is a popular version control system used widely by developers and teams for tracking changes in code. Created by Linus Torvalds in 2005 and currently maintained by Junio Hamano, Git helps manage and collaborate o...
Table of Contents Introduction to Lists Working with Lists Introduction to Tuples Working with Tuples Lists vs Tuples Exercises Final Project 1. Introduction to Lists A list is a collection of items in Python that is ordered, changeable (mu...
Your roadmap from beginner to job-ready in AI and Machine Learning Introduction: Why Now Is the Perfect Time to Enter AI Artificial Intelligence and Machine Learning are no longer futuristic concepts—they're reshaping every industry right now. From...
What is CSS CSS is one of those foundational skills every serious front-end developer must master. As someone actively sharpening my craft through The AI Academy, this course didn’t just teach me syntax — it reshaped the way I think about design, str...
By the end of this lesson, you’ll:
Know what a closure is,
Understand how closures work internally,
Learn why we use closures,
See practical real-world examples,
And get practice exercises to solidify your understanding.
A closure is a function that remembers variables from its enclosing scope, even if that scope is no longer active.
In other words:
A closure allows a function to access variables from outside its immediate scope, even after the outer function has finished executing.
def outer_function():
x = 10
def inner_function():
print(x)
inner_function()
outer_function()
Output:
10
Here, inner_function() accesses x from the outer scope — that’s normal.
But now watch what happens if we return the inner function.
def outer_function():
x = 10 # <- This variable is in the enclosing scope
def inner_function():
print(x) # <- inner_function refers to x
return inner_function # <- returning the function, not calling it
my_func = outer_function() # outer_function() executes and returns inner_function
my_func() # we call the returned function
Output:
10
When outer_function() ran, it created x = 10 and defined inner_function.
Then it returned inner_function.
Normally, when a function finishes, its local variables (x) are destroyed.
But because inner_function remembers x, it stays alive inside the returned function.
That “remembering” is called a closure.
You can inspect the closure using the __closure__ attribute:
def outer_function():
x = 5
def inner_function():
print(x)
return inner_function
f = outer_function()
print(f.__closure__) # <--- contains the remembered variables
Output:
(<cell at 0x...: int object at 0x...>,)
You can even look inside the closure cell:
print(f.__closure__[0].cell_contents)
Output:
5
That’s how Python stores the enclosed variable.
Closures are very powerful and used frequently in Python to:
Preserve state without using global variables or classes.
Encapsulate logic neatly.
Build function factories (functions that return customized functions).
Implement decorators (a key part of advanced Python).
You can use closures to create customized functions.
def multiplier(factor):
def multiply(number):
return number * factor
return multiply
double = multiplier(2)
triple = multiplier(3)
print(double(5)) # 10
print(triple(5)) # 15
Here:
Each returned function (double, triple) “remembers” its own factor.
factor stays alive even after multiplier() finishes.
Closures can maintain state between function calls.
def counter():
count = 0
def increment():
nonlocal count # allows modification of outer variable
count += 1
return count
return increment
count1 = counter()
print(count1()) # 1
print(count1()) # 2
print(count1()) # 3
Without nonlocal, Python would treat count as a new local variable inside increment().
Suppose you want to wrap behavior around a specific configuration.
def greet_config(lang):
def greet(name):
if lang == "en":
print(f"Hello, {name}!")
elif lang == "es":
print(f"Hola, {name}!")
else:
print(f"Hi, {name}!")
return greet
english_greet = greet_config("en")
spanish_greet = greet_config("es")
english_greet("Alice")
spanish_greet("Carlos")
Output:
Hello, Alice!
Hola, Carlos!
Each function remembers its lang configuration.
nonlocalWhen using closures, the inner function cannot modify variables from the enclosing scope unless you declare them as nonlocal.
Example:
def outer():
count = 0
def inner():
nonlocal count
count += 1
return count
return inner
f = outer()
print(f()) # 1
print(f()) # 2
Without nonlocal, you’d get an error:
UnboundLocalError: local variable 'count' referenced before assignment
Decorators — Python decorators are implemented using closures.
def logger(func):
def wrapper(*args, **kwargs):
print(f"Running {func.__name__}...")
return func(*args, **kwargs)
return wrapper
@logger
def greet(name):
print(f"Hello, {name}")
greet("John")
Data hiding — Closures let you encapsulate variables.
Callbacks — Used in event handling (e.g., in GUIs or async code).
Custom Function Generators — Like multiplier() above.
Exercise 1: Function Factory
Create a closure power_of(n) that returns a function which raises any number to the power n.
Expected:
square = power_of(2)
cube = power_of(3)
print(square(4)) # 16
print(cube(2)) # 8
Exercise 2: Simple Banking Example
Create a closure bank_account() that:
Starts with a balance of 0.
Has an inner function transaction(amount) that can deposit or withdraw.
Uses nonlocal to modify the balance.
Expected:
account = bank_account()
print(account(100)) # Deposited 100 → balance = 100
print(account(-50)) # Withdrawn 50 → balance = 50
| Concept | Meaning |
| Closure | A function that remembers variables from its enclosing scope |
| How it’s formed | When a nested function references variables from its enclosing function and is returned |
| Use cases | Function factories, decorators, maintaining state, data hiding |
| Keyword | nonlocal allows modification of enclosed variables |
Closures make functions stateful without using classes.
They are foundational for decorators and many advanced Python features.
They provide encapsulation and flexibility in functional programming styles.