A typical decorator in python or any nested closured functions is usually referring to the state from one or more variable scope above.
def wrapper():
counter = 0
def incr():
counter += 1
return counter
return incr
fn = wrapper()
print(fn())
# Traceback (most recent call last):
# File "sample.py", line 51, in <module>
# print(fn())
# File "sample.py", line 46, in incr
# return counter
# NameError: name 'counter' is not defined
Like in this example with counter variable. The code will fail to execute because counter
is not visible within incr
function scope.
The typical fix is usually either to declare counter as nonlocal or even global .
def wrapper():
counter = 0
def incr():
nonlocal counter
counter += 1
return counter
return incr
fn = wrapper()
print(fn())
# >> 1
This works as expected but is the other way achieve the same?
def wrapper():
v = dict(counter=0)
def incr():
v['counter'] += 1
return v['counter']
return incr
fn = wrapper()
print(fn())
# > 1
As the first trick we can use mutable object like dict to declare and modify the state without nonlocal keyword. Why does it work? Comparing to previous example counter += 1
this is actually syntactic sugar for counter = counter + 1
and python interpret usually has no clue how to resolve to which scope reassign this new counter variable. However if it just mutation by object reference there is no such ambiguity
Another trick derives from the previous example but I found it more readable and concise.
def wrapper():
class Vars:
counter = 0
def incr():
Vars.counter += 1
return Vars.counter
return incr
fn = wrapper()
print(fn())
# >> 1
Top comments (0)