Closure
1. Nested functions
A function that is defined inside another function is known as a nested function.
- Nested functions are able to access variables of the enclosing scope.
- In Python, these non-local variables can be accessed only within their scope and not outside their scope. But Closure can be access non-local variables
#nested function example
def nested_func(text):
temp = text
def test2():
print( 'temp : {}'.format(temp))
return test2()
# free_variable is non-local variable
nested_func('test')
> temp : test
2. Closure
A Closure is a function object that remembers values in enclosing scopes even if they are not present in memory.
- It is a record that stores a function together with an environment: a mapping associating each free variable of the function
- A closure—unlike a plain function—allows the function to access those captured variables through the closure’s copies of their values or references, even when the function is invoked outside their scope.
- below example The function test has its scope only inside the closure function. But with the use of closures, we can easily extend its scope to invoke a function outside its scope.
- Closures provide some form of data hiding.
- A closure can also be a highly efficient way to preserve state across a series of function calls.
# free variable = str
def closure(text):
text = text
def test():
print( 'free variable : {}'.format(text))
return test
a = closure('closure_test')
print(a)
> <function closure.<locals>.test at 0x0000017E492D8700>
a()
> free variable : closure_test
# free variable = function
def logger(func):
def log_func(*args):
print(func(*args))
return log_func
def risk_up(x,y):
return x+y
def risk_down(x,y):
return x-y
add_logger = logger(risk_up)
add_logger(3,3)
# > 6
sub_logger = logger(risk_down)
sub_logger(6,2)
# > 4