Nested function

python Allows you to define functions in functions , And the existing scope and variable life cycle remain unchanged .

def A():
	name='mysql'
	def A_children(): #outer Functions defined inside functions 
		print name
	return A_children() # Returns the inner function 

A()

understand ：
stay A In nested functions ,python The interpreter needs to find one called name Local variables for , After the search fails, it will continue to be in the upper scope （ namely , In an external function ） seek .

about A The last sentence in the function , Return the result of the sub function call , One thing to know is , A subfunction is just a function that follows python Variable name of variable resolution rule ,python The interpreter will take precedence over the A Variable names in the scope of A_children Find matching variables .

Put the variable that happens to be the function identifier A_children Return as a return value , Each function outer When called , function A_children Will be redefined , If it's not returned as a variable , It will not exist after each execution .

stay python in , Functions are objects , It's just some ordinary values , In other words, you can pass functions to other functions like parameters or return functions from functions .

return Inner function without parentheses , Only return the address of the function
That is to say if return A_children, The sub function... Will not be executed

Function as variable

# encoding=utf-8
def add(x,y):
	return x+y

def sub(x,y):
	return x-y

def apply(func,x,y):
	return func(x,y)

print("apply(add,2,1):",apple(add,2,1))
print("apple(sub,2,1):",apple(sub,2,1))

apply The function is ready to receive a function variable , It's just an ordinary variable , Like other variables . Then we call the function passed in ：“（） Represents the called operation , And call the value contained in the variable ”

Closure

# encoding=utf-8

def outer():
	name = "python"
	def inner():
		print name
	return inner
res = outer() # The first bracket , obtain inner The address of 
res() # The second bracket calls the function inner()
print res.func_closure # Print which external variables are included in the closure 

Through the scope and life cycle of the above variables , It's not hard to understand ,name Is the function outer A local variable in , In other words, only when outer Running time , This variable will exist .

according to python The mode of operation of , We can't be in a function outer After exiting, you can continue to call inner function , The reason why it can be called successfully , because python Support a feature called function closure .

Closure definition ： If a function is defined within the scope of another function , And references variables of outer functions , Then the function is called a closure . Closure is python A feature supported , It makes non global scope A defined function can reference variables in its peripheral space , The variables referenced in these peripheral spaces are called the environment variables of this function . The environment variable and this non global function together form a closure .

Closure characteristics ： Function object returned by a function , The execution of this function object depends on variables that are not inside the function, and only , This is the time , The actual contents returned by the function are as follows ：

1. Function object
2. The external variables and variable values that the function object needs to use

Popular understanding is that ： Inside, the function executes , You need to use a variable of the external function , therefore , Just combine the outer variable with the inner function , The two things that come together are closures .