一．递归调用

　　递归调用: 一个函数自己调用自己, 变成一个循环了，最多一个函数递归调用自己999,作用和运行循环是一样的，区别就是循环是没有次数限制的，递归调用最多999次，超过999次会报错：

递归的特性：

1、 必须有一个明确的结束条件
2、每次进入更深一层递归时，问题规模相比上次递归都应有所减少
3、递归效率不高，少用递归

eg：通过循环，函数自己调用自己

def test1():while True:num = int(input('please enter a number：'))if num%2==0:#判断输入的数字是不是偶数return True #如果是偶数的话，程序就退出了，返回trueprint('不是偶数请重新输入！')test1() #调用test

eg:通过递归，循环函数多次调用自己

def test1():num = int(input('please enter a number：'))if num%2==0:#判断输入的数字是不是偶数return True #如果是偶数的话，程序就退出了，返回trueprint('不是偶数请重新输入！')return test1()#如果不是偶数的话继续调用自己，输入值test1()#调用test

二．高阶函数

　　高阶函数： 如果一个函数的入参是一个函数名的话，这个函数就是高阶函数

　　函数即变量:虽然是一个函数，但是函数名是一个变量，变量存的是内存地址，指向的是函数体，加上括号了才是函数，那么给函数名重新赋值给一个变量的话，新变量与函数名是一样的，对新的变量名进行调用就和对原函数调用一样eg:函数即变量的例子

def hello(name):print(name)
new_hello=hello #hello是一个普通的变量，将hello的值赋值给new_hello，代表的是内存地址hello('hello...')#hello()调用hello函数new_hello('newhello..') #new_hello()调用的跟hello()是一样的

eg:高阶函数的例子--入参是函数名就是高阶函数

def add(x,y,z): res=z(x)+z(y) #函数才可以用z()调用return res
print(add('99','100',int))#int就是一个函数名

三．装饰器

装饰器：就是函数嵌套加高阶函数，像在打开淘宝购物的时候，哪些模块需要登录才可以操作的话，就需要用到装饰器了。

　装饰器作用，在不改变原有函数调用方式入参的情况下，给函数添加新功能,偷偷给函数加上新功能，但是不改变原来的函数

1.  函数里可以嵌套定义函数:但是函数不管在哪都是调用了才会执行，不调用是不会执行的

Eg:函数有内嵌函数，但是没有调用

def warpper():print('我在外面')def deco():print('我在里面')def hh():print('我在最里面')
warpper()

返回结果：

我在外面

Eg:函数有内嵌函数，且有调用

def warpper():print('我在外面')def deco():print('我在里面')def hh():print('我在最里面')hh()deco()
warpper()

返回结果：

我在里面zhang

VVVzhang

2.函数作用域，是就近原则，函数里有的话就先取自己，自己没有的话，就找父级的,父级没有再往外找，查找的原则是从里往外找
# 函数只有被调用才会执行，执行顺序按照函数调用的顺序

Eg: 函数作用域例子

name='luoluo'def warpper():print('我在外面%s'%name)def deco():name = 'MLing'print('我在里面%s'%name)def hh():print('我在最里面%s'%name)hh()deco()
warpper()

3. 装饰器：函数效率不高，查找哪个原因导致效率慢装饰器作用，在不改变原有函数调用方式入参的情况下，给函数添加新功能,偷偷给函数加上新功能，但是不改变原来的函数

Eg：下面的例子获取函数的运行时间--改变原来的调用方式了 原调用方式run()---后来调用方式run_time(run)

import timedef run():print('run..')time.sleep(1)def run_time(func):start_time=time.time()func() #run传给func，func里面就是函数里的代码体，指向run函数里的两行代码end_time=time.time()print("run函数运行是",end_time-start_time)
run_time(run)#run代表变量，指向的函数体里的代码，

Eg: 下面的这个函数，其实就是就是返回了一个函数名而已deco函数没调用

import timedef timer(func): #定义一个函数，入参是函数名def deco(): #再定义个函数，将要给函数新加的功能写进去start_time = time.time()func()end_time = time.time()print("run函数运行是", end_time - start_time)return deco #返回这个定义的函数体def run():print('run..')time.sleep(1)
timer(run) #这样调用是没有结果的，因为deco没有调用，所以timer只返回了一个deco函数名r=timer(run)#其实r=decor()#其实就是deco()，是给原来的run函数增加了新功能之后的，但是有改变原来的调用方式，由run()变为了r()

装饰器的处理逻辑：

1、调用timer函数的时候，要传入一个方法名func，timer函数在函数内部定义了一个函数叫做deco
2、deco函数内有新功能，且在函数内部调用了timer里面传入的方法-func()
3、当调timer函数时，返回的是函数体deco,可用函数deco已经把方法-func()要实现的功能都完成了，这个直接运行deco就实现了新功能
4、既然函数deco实现了新功能，函数即变量，给deco重新赋值就行，run=deco的话，run就有了新功能

Eg:装饰器例子1—与上面的例子类似def run():print('run..')time.sleep(1)import timedef run_time(func):def deco():start_time=time.time()func()end_time=time.time()print("run函数运行是",end_time-start_time)return deco#返回这个定义的函数体
run=run_time(run)
run()

Eg:装饰器例子2---@run_time=run=run_time(run)import timedef run_time(func):#固定格式def deco():#固定格式start_time=time.time()func()end_time=time.time()print("run函数运行是",end_time-start_time)return deco#固定格式
@run_time #哪个函数用，就放在哪个函数前面def run():print('run..')time.sleep(1)
run()

注意：疑惑的是为什么要内嵌一个函数，就是为了不改变原来函数的调用方式,返回的是函数体，其实就是把新功能封装在了deco这个函数体里面了def run():print('run..')time.sleep(1)import timedef run_time(func):def deco():start_time=time.time()func()end_time=time.time()print("run函数运行是",end_time-start_time)return deco
run=run_time(run)
print('返回的deco是什么',run)

返回结果：

返回的deco是什么 <function run_time.<locals>.deco at 0x000000F442D8E730>

注意：当函数有入参的话，就需要接收传入函数的参数—下面例子是比较完美的装饰器了，有没有入参都可以

import time,os,sysdef timer(func):def deco(*args,**kwargs):#*args,**kwargs用来接收传入函数的参数start_time = time.time()res = func(*args,**kwargs)#获取返回值         end_time = time.time()print('runtime',end_time-start_time)         return res     return deco

@timerdef run2(name):print(name)time.sleep(0.5) run2('niuhanyang')