函数的高级运用这部分知识的核心内容就是你要把“函数即变量”这个概念理解并运用得出神入化...
一、函数的递归调用
所谓递归调用就是函数自己调用自己，在Python中如果不做限制递归调用的死循环最多可循环调用999次，当超过999次的时候就会报错。
函数递归调用的效率很低，我们在写代码时不提倡使用，如果使用一定要有明确的结束条件。
def is_even():
num = int(input("Please input a number here: "))
if num % 2 == 0:
print("Good, the number is even number.")
return True
print("Your input is not Even number, please input again!")
is_even()
is_even()
二、高阶函数
如果一个函数的入参是个函数名的话，那这个函数就是个高阶函数。
def sum(x , y , z ):
res = z(x) + z(y)
return res
print(sum(1.98,3.14,int))
三、嵌套定义函数
函数的里面是可以再定义函数的，多层嵌套函数的作用域是采取就近并从内向外的原则，另外，函数只有被调用时才被执行。
def warpper():
print("我在外面")
def deco():
print("我在里面")
def hhh():
print("xxx")
warpper()
函数的结果： 我在外面
因为在执行过程中只有warpper()函数被调用了，至于它里面的函数只是被定义了没有被调用过。
name = 'python'
def warpper():
name = '函数第一层'
def deco():
name = '函数第二层'
print (name)
def hhh():
name = '函数第三层'
print(name)
hhh()
deco()
print(name)
warpper()hhh
函数结果：
函数第二层
函数第三层
函数第一层
因为首先调用warpper(): name 被赋值 ‘函数第一层’，之后定义函数deco只是定义不用管它，
接下来是调用deco(): name 被赋值为‘函数第二层’，紧接着打印输出这个name即函数第二层，之后定义hhh只是定义不用理它，
接下来是调用hhh(): name 被赋值为‘函数第三层’，紧接着打印输出这个name即函数第三层，到此deco()调用完毕，
接下来继续执行warpper的最后一句，打印输出 name，之前的name都是局域的变量执行完局部代码就消失了，此处的neme仍然是最初
被赋值为‘函数第一层’的name，所以刚刚被打印输出。
三、装饰器
装饰器的定义其实就是函数嵌套加高阶函数。它的用途是，给函数添加了功能，但调用函数时扔保持原样不变，好像什么四也米有发僧。
举个栗子：
import time
def run(): # 定义一个简单函数
print ("run ...")
time.sleep(3)
run() # 调用这个简单函数
有需求，要查看这个函数执行的时间，于是程序变成下面的样纸：
import time
def run():
print ("run ...")
time.sleep(3)
start_time = time.time() # 在函数调用之前获取时间
run()
end_time = time.time() # 在函数执行结束是获取时间
print("run()函数运行的时间是：", end_time - start_time)
继续演化：
def run_time(func):
start_time = time.time()
func()
end_time = time.time()
print("run()函数的运行时间是：",end_time-start_time)
run_time(run)
继续演化：其实这里已经差不多是个装饰器了
def timer(func):
def deco():
start_time = time.time()
func()
end_time = time.time()
print("runtime is: ", end_time-start_time)
return deco
run = timer(run)
run()
解释如下：
def timer(func): # 定义一个对func进行处理的函数，func是个函数名，如何处理看里面定义。
def deco(): # deco()即是把原func()丰富了计时功能后的那个函数 即变厉害了的func()，deco即是新func，我们就是要用它来偷换原来的旧func。
start_time = time.time()
func()
end_time = time.time()
print("runtime is: ", end_time-start_time)
return deco # 对func进行处理后返回变厉害了新func名，deco。
run = timer(run) # 对run()处理后，把变厉害的run()的名字再交给run，这时候run已经不是原来的run,而是变厉害的run。
run() # 这里不是run()在跑，而是厉害的新run()在跑，但看起来好像还是原来的run()在跑。
上面这一整段代码即是处理+置换的过程，而这个过程，把“函数即变量”运用得炉火纯青...
装饰器在定义的时候要更加适应被处理（或者叫做被装饰）的函数参数的多样化，这是第一点；
再有，实现偷天置换的关键语句run = timer(run),要让这句看起来更具有伪装性。
基于以上俩原因，标准的装饰器写法出炉了:
import time
def timer(func): # 定义装饰器
def deco(*args,**kwargs): # 传非必填形式参数，这样便可应对被处理对象函数各种参数的情况
start_time = time.time()
func(*args,**kwargs) # 传非必填形式参数，这样便可应对被处理对象函数各种参数的情况
end_time = time.time()
print("runtime is: ", end_time-start_time)
return deco
@timer # 在定义被处理函数之前@装饰器名字
def run():
print("run ...")
time.sleep(3)
run()
过程可以总结为：定义装饰器 ---> 在定义被处理的函数之前写@装饰器名字 ---> 最后在调用函数。
前后顺序不对的话，会报错哦 ...