A closure is a function that remembers the variables from where it was defined, even after that outer function has returned. The values travel with the function rather than being looked up in the global namespace later.
When you define a function inside another function, the inner function has access to the outer function’s scope. This is called a closure:
def outer_func(msg):
def inner_func():
print(f"Message: {msg}")
return inner_func
my_closure = outer_func("Hello World")
my_closure()Message: Hello World
A decorator is just a function that takes a function and returns a replacement. Everything else about decorators follows from that one sentence.
Decorators are built on top of closures. They take a function as an argument, and return a new function (the wrapper) that adds some behavior before or after calling the original function:
def my_decorator(func):
def wrapper():
print("Before the function runs")
func()
print("After the function runs")
return wrapper
@my_decorator
def say_hello():
print("Hello!")
say_hello()Before the function runs Hello! After the function runs
The @ syntax is pure convenience. Writing @timer above def work(): is exactly the same as writing work = timer(work) afterwards — the decorator runs once, at definition time, and rebinds the name.
Here is an IP01 interactive visualizer that shows how the @my_decorator syntax is exactly the same as calling say_hello = my_decorator(say_hello):
def my_decorator(func):
def wrapper():
print("Before")
func()
print("After")
return wrapper
def say_hello():
print("Hello")
say_hello = my_decorator(say_hello)
say_hello()To decorate functions that take arguments, the inner wrapper function must accept them:
def twice(func):
def wrapper(*args, **kwargs):
func(*args, **kwargs)
func(*args, **kwargs)
return wrapper
@twice
def greet(name):
print(f"Hello {name}")
greet("Alice")Hello Alice Hello Alice
Complete the interactive challenges below to earn XP!
Is the following statement true or false? 'Decorators must use the @ symbol to work.'
False — The @ symbol is just syntactic sugar. You can manually apply a decorator by doing `func = my_decorator(func)`.
Is the following statement true or false? 'Closures cannot modify the variables they capture.'
False — Closures can modify captured variables if you use the nonlocal keyword.
Which of these accurately describes a decorator?
A function returning another function. — A decorator is usually a function returning another function, applied as a transformation.
Write a decorator `bold` that wraps the output of a function in HTML `<b>` tags.
Your wrapper function should call func() and return the result wrapped in HTML tags.
def bold(func):
def wrapper():
return f"<b>{func()}</b>"
return wrapper
@bold
def say_hi():
return "hi"
print(say_hi())Write an outer function `make_counter()` that returns an inner function. The inner function should use the nonlocal keyword to increment and return a count starting at 1.
Use nonlocal count inside the inner function.
def make_counter():
count = 0
def inner():
nonlocal count
count += 1
return count
return inner
counter = make_counter()
print(counter())
print(counter())