Day14

总结

多层装饰器

# 语法糖会将紧挨着的被装饰对象的名字当做参数自动传入装饰器函数中，当有多个修饰器时，最先运行的是最靠近被修饰函数的修饰器

def outter1(func1):
    print('加载了outter1')

    def wrapper1(*args, **kwargs):
        print('执行了wrapper1')
        res1 = func1(*args, **kwargs)
        return res1

    return wrapper1


def outter2(func2):
    print('加载了outter2')

    def wrapper2(*args, **kwargs):
        print('执行了wrapper2')
        res2 = func2(*args, **kwargs)
        return res2

    return wrapper2


def outter3(func3):
    print('加载了outter3')

    def wrapper3(*args, **kwargs):
        print('执行了wrapper3')
        res3 = func3(*args, **kwargs)
        return res3

    return wrapper3


@outter1  # outter1拿到wrapper2,outter1的上层没有语法糖,index = outter1(wrapperw)
@outter2  # outter2拿到wrapper3,wrapper3 = outter3(index)
@outter3  # @outter3紧贴index()，outter3调用index()，返回wrapper3，所以wrapper3 = outter3(index)
def index():
    print('from index')

    
'''
    加载了outter3
    加载了outter2
    加载了outter1
'''

有参装饰器

def outter(x):
    def  outter1(func):
        def wrapper(*args,*kwargs):
            res = func(*args,**kwargs)
            print(x)
            return res
        return wrapper
      return outter1
    
# 通过第三层进行传值，使得有参装饰器可以使用其他参数，实现其他功能。


@outter('a')
#可以被看做
#f1 = outter1(f1)
#f1 = wrapper(*args,**kwargs)

:

递归函数

# 函数在运行过程中直接或者间接的调用自身

def index():
    print('from index')
    index()
index()  # maximum recursion depth exceeded while calling a Python object
		# 最大递归深度超出限制，运行了python解释器自带的应急机制
    
# 函数的递归不应该是无限循环的过程，真正的递归函数应该要满足两个要求
# 1.每次递归 复杂度必须降低
# 2.必须要有明确的结束条件
# 递归函数的有点是定义简单，逻辑清晰，理论上，所有递归函数都可以写成循环的方式，不过循环的逻辑不如递归清晰。

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


def get_num(num):
    for i in num:  # 自带结束条件 并且每次传入的数据都比上一次简单
        if isinstance(i, int):  # 判断数据是否属于整型
            print(i)
        else:
            get_num(i)


get_num(l1)

算法之二分法

# 算法的概念：
	算法就是解决问题的有效方法
    
'''
    二分法原理
    获取数据集中间的元素 比对大小
        如果中间的元素大于目标数据  保留数据集的左半边
        如果中间的元素小于目标数据  保留数据集的右半边
    然后对剩下的数据集再二分
        如果中间的元素大于目标数据  保留数据集的左半边
        如果中间的元素小于目标数据  保留数据集的右半边
'''
# 二分法查找适用于数据量较大时，但是数据需要先排好顺序。
lis=[2,3,5,10,15,16,18,22,26,30,32,35,41,42,43,55,56,66,67,69,72,76,82,83,88]


def find(aim,li,start=0,end=None):
    end=len(li) if end is None else end
    middle=(end-start)//2+start
    if start<=end:
        if li[middle]>aim:
            return find(aim,li,start=start,end=middle-1)
        elif li[middle]<aim:
            return find(aim,li,start=middle+1,end=end)
        else:
            return middle
    else:
        return 'not find'
print(find(16,lis))
# 二分法同样存在缺陷
	1.如果要找的元素就在数据集的开头 二分更加复杂
    2.数据集必须有顺序
# 目前并不存在最完美的算法，对会有限制条件

今天学的没有上周五那么绕了，但是不代表就可以放松了，继续加油

: