python函数微讲解（四）

1.多层装饰器

多层装饰器顾名思义就是有多个装饰器，具体代码如下：

def outer1(func_name):
    print('我是outer1')
    def inner1():
        print('我是inner1')
        res = func_name()
        return res
    return inner1
def outer2(func_name):
    print('我是outer2')
    def inner2():
        print('我是inner2')
        res2 = func_name()
        return res2
    return inner2
def outer3(func_name):
    print('我是outer3')
    def inner3():
        print('我是inner3')
        res3 = func_name()
        return res3
    return inner3
@outer1  # 这里定义一个变量名outer2，然后调用outer1函数，参数是inner2函数名，赋值给变量名outer2，然后执行outer1，返回inner1：outer2 = outer1(inner2) inner1
@outer2  # 这里定义一个变量名outer3，然后调用outer2函数，参数是inner3函数名，赋值给变量名outer3，然后执行outer2，返回inner2：outer3 = outer2(inner3) inner2
@outer3  # 这里定义一个变量名index，然后调用outer3函数，参数是下面的index函数名，赋值给变量名index，然后执行outer3，返回inner3：index = outer3(index) inner3
def index():
    print('我是index')

调用index函数输出为：

我是outer3
我是outer2
我是outer1
我是inner1
我是inner2
我是inner3
我是index

2.有参装饰器

def outer(guess):  # 在最外部再加一个函数，用于给判断条件传参
    def inner(func_name):  # 这里的参数不能动，因为这里接收的是被装饰对象的函数名
        def index(*args,**kwargs):  # 这里的参数不能动，因为这里接收的是被装饰对象的传参
            if guess == '1':
                print('我是1')
            elif guess == '2':
                print('我是2')
            elif guess == '3':
                print('我是3')
            else:
                pass
            res = func_name()
            return res
        return index
    return inner


@outer('2')  # 语法糖的函数名后面加括号，先执行函数，然后在执行语法糖，所以这句的意思就是先执行outer('2')，返回inner，然后在执行@inner
def home():
    print('我是home')

装饰器最多只有三层函数，三层的用到的也很少，它的用处就是给装饰器额外的值传参。

3.函数的递归

本质：函数在运行的过程中直接或间接的调用了自己

直接调用自己：

def index():
    print('123')
    index()

这就是一个自己调用自己的一个简单例子，不过这个代码运行的话会报：“maximum recursion depth exceeded while calling a Python object”这个错误，他的意思是说“调用Python对象时超出了最大递归深度”，这里就引出来一个知识点：最大递归深度

最大递归深度

这是python解释器自带的一种应急机制，保护CPU，有些编程语言是没有这种应急机制的，他会一直运行，一直到计算机崩溃为止。

最大递归深度我们是可以算出来是多少的：

count = 0
def index():
    print('123')
    global count
    count += 1
    print(count)
    index()

一般情况下都是997、998、1000，不同的电脑可能不同，官方的回答是1000，我们可以查一下：

import sys  # 导入包
print(sys.getrecursionlimit())  # 获取默认的最大递归深度  # 1000
sys.setrecursionlimit(1500)  # 还可以修改最大递归深度

间接调用自己：

def index():
    print('111')
    home()
def home():
    print('222')
    index()
index()

看似上述两个例子是递归函数，其实不然，递归函数不是无限循环的，应该满足两个要求：

1.每一次的递归复杂度要降低，也就是下一次要比上一次简单

2.必须要有明确的结束条件

满足这两个要求的才是递归函数，我们来看一个例子：

l1 = [1, [2, [3, [4, [5, [6, [7, [8, [9, ]]]]]]]]]
'''需求:循环打印出列表中每一个数字'''

def index(l):
    for i in l:
        if type(i) == int:  # 判断元素是否是整型，是的话就输出，不是的话就执行下面的语句
            print(i)
        else:
            index(i)  # 如果不是整型，再次调用函数并传参

4.算法之二分法

1.什么是算法？

算法就是解决问题的有效方法。算法比较偏向于学术研究，类似于研究所。

2.什么是二分法？

二分法一般用于寻找值，当一个数据集有很多的值，我们就可以用二分法，它有一个硬性要求，就是数据集必须是有序排列的，它的原理是，寻找中间的值，与自己想要寻找的值进行比较，大的话就取左边的，小的话就取右边的，然后接着取中间的，在判断，知道找到。

l = [11, 22, 33, 44, 55, 66, 77, 88, 99, 111, 222, 333, 666, 999]
# 寻找333
def index(a,number):
    number_center = len(a) // 2  # 先找到中间值
    if len(a) == 0:
        print('找不到了')
    if a[number_center] > number:  # 如果中间值大于我们要找的值
        left_number = a[:number_center]  # 就取左边的
        print(left_number)
        index(left_number,number)  # 然后再执行函数
    elif a[number_center] < number:  # 如果中间的值小于我们要找的值
        right_number = a[number_center:]  # 就取右边的
        print(right_number)
        index(right_number,number)  # 然后再执行函数
    else:
        print('找到了')

index(l,333)

这里是IT小白陆禄绯，欢迎各位大佬的指点！！！