python之装饰器补充与递归函数与二分查找

目录

• 多层装饰器
• 有参装饰器
• 递归函数
  • 基本演示
  • 斐波那契数列
  • 总结
  • 小拓展
• 算法之二分法
  • 简介
  • 举例
  • 总结

多层装饰器

我们已经知道了语法糖的作用是将装饰对象自动装饰到装饰器中，一个语法糖的应用我们已经学会了，那么多个语法糖该怎么应用呢？

让我们来看一串代码：

# 装饰器outer1
def outer1(func1):
    print('加载了outer1')
    def wrapper1(*args, **kwargs):
        print('执行了wrapper1')
        res1 = func1(*args, **kwargs)
        return res1
    return wrapper1

# 装饰器outer2
def outer2(func2):
    print('加载了outer2')
    def wrapper2(*args, **kwargs):
        print('执行了wrapper2')
        res2 = func2(*args, **kwargs)
        return res2
    return wrapper2

# 装饰器outer3
def outer3(func3):
    print('加载了outer3')
    def wrapper3(*args, **kwargs):
        print('执行了wrapper3')
        res3 = func3(*args, **kwargs)
        return res3
    return wrapper3

# 连用三个语法糖
@outer1
@outer2
@outer3
def index():
    print('from index')

当连用多个语法糖的时候，优先执行靠近装饰对象的语法糖，并且直到最远的语法糖才会赋值给装饰对象的函数名。

也就是说，在上述代码中，优先执行@outer3，将wrapper3装饰到index中，但此时不会赋值给index函数名，执行到@outer1时，这时就会执行赋值语句，也就是index = outer3(index)。

这三句语法糖总的来说：index = outer3(outer2(outer1(index)))，就相当于执行力这段语句。

执行结果：

有参装饰器

我们都知道，装饰器里面只有一个形参，这个形参用于接收函数的名字，那么我们应该如何在给装饰器传一些额外参数进去呢？

需要一些额外参数的装饰器：

def outer(func_name):
    def inner(*args, **kwargs):
        """此时这里需要一个参数用于决定处理数据的方式"""
        if source_data == '1':
            print('操作方式1')
        elif source_data == '2':
            print('操作方式1')
        elif source_data == '3':
            print('操作方式1')
        else:
            print('其他操作情况')
        res = func_name(*args, **kwargs)
        return res

    return inner

@outer()
def index():
    print('from index')

这个装饰器里的source_data应该在哪传进去呢？

很明显，装饰器outer括号里面是不能更改的，因为它要用于接收函数名，inner显然也是不能更改的，它要用于接收装饰对象的参数。

解决方法：在装饰器外层在套一个函数

# 最外层函数，可以接收参数给装饰器使用
def outer_outer(source_data):
    # 装饰器
    def outer(func_name):
        def inner(*args, **kwargs):
            if source_data == '1':
                print('操作方式1')
            elif source_data == '2':
                print('操作方式1')
            elif source_data == '3':
                print('操作方式1')
            else:
                print('其他操作情况')
            res = func_name(*args, **kwargs)
            return res

        return inner

    # 这里返回装饰器的函数名
    return outer

"""
这段语法糖会优先执行函数
因为outer_outer函数返回的是装饰器的名字
所以变成了@outer，又回到了最初的语法糖
"""
@outer_outer('3')
def index():
    print('from index')

递归函数

在编程语言中，函数直接或间接调用函数自身，则该函数称为递归函数。

基本演示

# 直接调用自身
def index():
    print(1)
    # 在函数内部调用了自身
    index()
index()

# 间接调用自身
def a():
    print('a')
    # a函数中调用b函数
    b()

def b():
    print('b')
    # b函数中调用a函数
    a()
a()

简单的来说，就是套娃，但是要注意，递归函数最好有个可以让它结束继续递归的条件，不然python解释器就会报错。

这段报错说明你的函数超过了最大递归深度，也可以说是最大递归次数，超过了这个次数就会报错

斐波那契数列

一个数列如果它的前2项数值为1，从第三项开始每一项等于前2项之和，那么这个数列称为斐波那契数列。

代码实现：

def f(a):
    # 前2项为1
    if a <= 2:
        return 1
    # 每一项等于前2项之和
    res = f(a - 1) + f(a - 2)
    return res

print(f(6))  # 结果：8

总结

1. 递归就是函数直接或间接调用自身
2. 递归一定要有可以结束的条件
3. 递归过程中，每进行一次递归都要离结束近一点

小拓展

获取默认最大递归深度

import sys
print(sys.getrecursionlimit())

修改最大递归深度

sys.setrecursionlimit(2000)

算法之二分法

在了解二分法之前，我们得先了解什么是算法。

算法其实就是解决问题的有效方法，在大多数情况下，它可以让问题的解决更加的迅速。

简介

我们在查找列表中某一个值的所在位置的时候，除了使用index()函数外，在没有接触算法之前，最简单易懂是不是就是将列表中的元素遍历一遍，一个个比较过去？

这种方法只能作用在比较小的列表中，那如果遇到了有着几十万元素的列表的时候，我们就无法使用这种遍历的方法了，这时候就可以使用二分法了。

二分法：对一个已经排序好的数据集从1/2处开始查找。

如果是降序数据集：如果比1/2处的值大了，去掉右边的数据，去比对左边的1/2处；如果比1/2的值小了，去掉左边的数据，去比对右边的1/2处；直到找到为止。

如果是升序数据集：如果比1/2处的值大了，去掉左边的数据，去比对右边的1/2处；如果比1/2的值小了，去掉右边的数据，去比对左边的1/2处；直到找到为止。

举例

找到[1, 2, 3, 4, 5, 6, 7, 8, 9]中的3

"""普通二分法查找"""
l = [1, 2, 3, 4, 5, 6, 7, 8, 9]
def get_target(l1, target_num):
    i = 0
    j = len(l1)
    while i != j:
        # 列表的1/2处
        half_l1 = (i + j) // 2
        if l1[half_l1] == target_num:
            print('找到了！在第%s个' % (half_l1 + 1))
            break
        elif target_num > l1[half_l1]:
            # 如果值比1/2处的大，查找范围变为[half_l1:j]
            i = half_l1 + 1
        else:
            # 如果值比1/2处的小，查找范围变为[i:half_l1]
            j = half_l1
    else:
        # 直到i == j了都没找到说明没有这个值
        print('没找到！')
get_target(l, 3)

"""递归二分法查找"""
l = [1, 2, 3, 4, 5, 6, 7, 8, 9]
def get_target(l1, target_num):
    if len(l1) == 0:
        print('没找到！')
        return
    # 列表的1/2处
    half_l1 = len(l1) // 2
    if target_num == l1[half_l1]:
        print('找到了!')
    elif target_num > l1[half_l1]:
        # 如果比1/2处的值大了，去掉左边的数据，去比对右边的1/2处
        get_target(l1[half_l1 + 1:], target_num)
    else:
        # 如果比1/2处的值小了，去掉右边的数据，去比对左边的1/2处
        get_target(l1[:half_l1], target_num)
get_target(l, 30)

总结

二分查找虽然在数据大的情况下查找更为迅速，但也有缺陷：

1. 数据集必须为升序或降序
2. 如果要查找的元素在数据的开头，二分查找更为复杂