今日总结

  • 多层装饰器
  • 有参装饰器
  • 递归函数
  • 算法之二分法

多层装饰器

# 语法糖会将紧挨着的被装饰对象的名字当做参数自动传入装饰器函数中
eg:
    def outer1(func1):
        print('加载了outer1')
        def wrapper1(*args,**kwargs):
            print('执行了wrapper1')
            res1 = func1(*args,**kwargs)
            return res1
        return wrapper1
    
    def outer2(func2):
        print('加载了outer2')
        def wrapper2(*args.**kwargs):
            print('执行了wrapper2')
            res2 = func2(*args,**kwargs)
            return res2
        return wrapper2
    
    def outer3(func3):
        print ('加载了outer3')
        def wrapper3(*args,**kwargs):
            print('执行了warpper3')
            res3 = func3(*args,**kwargs)
            return res3
        return wrapper3
    
    @outer1
    @outer2
    @outer3
    def index():
        print('from index')
# 多层语法糖解读顺序是先看语法糖有几个，然后再由下往上去看，遇到最后一个才会使用相同的变量名传给装饰器函数使用
# 语法糖三：wrapper3 = outer3(index),加载了outer3
# 语法糖二：wrapper2 = outer2(wrapper3)，加载了outer2
# 语法糖一；index = outer1(wrapper2),加载了outer1
# 执行顺序就是：wrapper1>>>>>wrapper2>>>>>wrapper3
# 加载outer3>>>加载outer2>>>加载outer1>>>index()>>>运行wrapper1函数体代码
# >>>然后再执行outer2函数体代码>>>然后再执行wrapper3的函数体代码

有参装饰器

# 有参函数的目的就是给装饰器传递额外的参数，装饰器最多就三层嵌套，三层嵌套的结构使用率不高
eg:
    def outer(source_data):
        def login_auth(func_name):
            def inner(*args,**kwargs):
                username = input('username>>>:').strip()
                password = input('password>>>:').syrip()
                # 校验用户数据，数据的来源有很多种，比如全局字典，全局列表，文本文件，数据库
                # 数据的来源不同，处理方式不同，对应的代码编写就不一样
                # 分支结构处理，然后根据不同的参数提示，匹配不同的流程
                if source_data == '1':
                    print('使用字典的方式处理数据')
                elif source_data == '2':
                    print('使用列表的方式处理数据')
                elif source_data == '3':
                    print('使用文件操作处理数据')
                else:
                    print('其他操作情况')
                res = func_name(*args,**kwargs)
                return res
            return inner
        return login_auth
    @outer('3') # 左侧是语法糖结构，右侧是函数名加括号结构，先执行函数调用'outer('3')',返回值是login_auth,再执行语法糖结构'@login_auth'
    	from functools import wraps
        @wraps(func_name)
    @outer('3')
    def index():
        print('from index')

递归函数

# 递归函数的本质：函数的递归，就是函数在运行过程中直接或间接的调用了自身
eg；
def index():
    print('from index')
    index()
index()
#在python解释器中，递归函数的最大递归数官方是1000，但是实际情况有的是997,998，但是不影响，最大递归深度也能自己设置
#递归函数不应该是无限循环的过程，有两个条件：
1.每次递归，复杂度必须降低
2.必须要有明确的结束条件

算法之二分法

# 算法就是解决问题的有效办法，里面最入门的一个就是二分法
# 二分法使用前，数据都必须要有先后顺序(升序或降序)
# 二分法的原理其实就是一直对半分，先获取数据集中间的元素，然后与目标数据比对大小，如果中间的元素大于目标数据，那么就保留数据集的左边一半；如果中间的元素小于目标元素，那么就保留数据集的右边一半。然后针对剩下的数据集再二分，如果中间的元素大于目标数据，就保留数据集的左边一半；如果中间的元素小于目标数据，那么就保留数据集的右边一半。一直这样二分，直到找到目标数据为止。
# 获取中间元素的索引值只能是整数
二分法的缺陷：
1.如果目标数据就在数据集开头或结尾，二分法更麻烦
2.数据集必须得有顺序，如果是乱序二分法就没用