装饰器/递归/算法

多层装饰

"""语法糖会将紧挨着的被装饰对象的名字当做参数自动传入装饰器函数中"""
# 判断七句print执行顺序
def outter1(func1):
    print('加载了outter1') 打印顺序③  和前面的定义对应
    def wrapper1(*args, **kwargs):
        print('执行了wrapper1')  打印顺序④  由于index = outter1(wrapper2)这里的index是wrapper1
        res1 = func1(*args, **kwargs)   这里的func相当于wrapper2进行执行
        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    #index = outter1(wrapper2)  #上方没有语法糖了，这时候才命名   执行顺序③
@outter2    #outter2(wrapper3)  返回值是wrapper2     执行顺序②
@outter3    #outter3(真正的index)  返回值是wrapper3  执行顺序①
def index():
print('from index')

 

有参装饰器

def outer(source_data):
    def login_auth(func_name):  # 不能动  只能接收一个被装饰对象名字
        def inner(*args, **kwargs):  # 不能动 是专门用来给被装饰的对象传参的
            username = input('username>>>:').strip()
            password = input('password>>>:').strip()
            # 校验用户数据  数据的来源可以有很多 比如全局字典 全局列表 文本文件 数据库
            # 数据的来源不同 处理方式就不同 对应的代码编写就不一样
            # 分支结构处理 然后根据不同的参数提示 匹配不同的流程
            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')

递归函数

本质:递归函数也称为函数的递归
函数在运行过程中直接或者间接的调用了自身

‘’‘maximum recursion depth exceeded while calling a Python object’‘’
最大递归深度( 回答997 998 1000都可以)超出限制了 python解释器自带的应急机制（报错）

在有些编程语言中 甚至没有遇警机制 代码执行真的一致到计算机崩溃为止

直接调用自己
 def index():
#     print('from index')
#     index()
# index()


# 间接调用自己   用装饰器
# def index():
#     print('from index')
#     func()
# def func():
#     print('from func')
#     index()
# func()                                

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


count = 1#计算最大递归深度
 def index():
     print('from index')
     global count
     print(count)
     count += 1
     index()
 index()

函数的递归不应该是无限循环的过程 真正的递归函数应该要满足两个要求
1.每次递归 复杂度必须降低(下一次递归要比上一次递归解答)
大白话 越往下递归应该离解决问题的答案越近
2.必须要有明确的结束条件

'''千万不要想复杂了 就记嵌套图即可 有结果就是由内而外一层层拨开'''

#需求:我想知道我们班坐在第一排的某个学生年龄，总共四排，前一排比后一排大两岁，最后一排18岁

# 封装函数
def get_age(n):
    if n == 1:
        return 18  # 有明确的结束条件
    return get_age(n-1) + 2
print(get_age(4))

递归练习

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

完整步骤 
    1.for循环大列表
    2.判断元素是否是数字 如果是则打印
    3.如果不是则for循环
    4.判断元素是否是数字 如果是则打印
    5.如果不是则for循环
    6.判断元素是否是数字 如果是则打印
    7.如果不是则for循环
ps:重复做一些事情 但是每次都比上一次简单一些 >>>:  递归函数


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

算法之二分法

什么是算法?
算法其实就是解决问题的有效方法
eg:比如打开易拉罐的问题
方法1:使用金属撬棍
方法2:直接手扣
方法3:一阳指戳

二分法是算法里面最入门的一个 主要是感受算法的魅力所在

"""二分法使用有前提: 数据集必须有先后顺序(升序 降序)"""

二分法原理
获取数据集中间的元素 比对大小
如果中间的元素大于目标数据 那么保留数据集的左边一半
如果中间的元素小于目标数据 那么保留数据集的右边一半
然后针对剩下的数据集再二分
如果中间的元素大于目标数据 那么保留数据集的左边一半
如果中间的元素小于目标数据 那么保留数据集的右边一半

l1 = [13,21,35,46,52,67,76,87,99,123,213,321,432,564,612]
def get_target(l1,target_num):
    # 最后需要考虑找不到的情况 l1不可能无限制二分
    if len(l1) == 0:
        print('不好意思 真的没有 找不到')
        return
    # 1.获取中间元素的索引值(只能是整数)
    middle_index = len(l1) // 2   #整除
    # 2.判断中间索引对应的数据与目标数据的大小
    if target_num > l1[middle_index]:
        # 3.保留数据集右侧
        l1_left = l1[middle_index+1:]   从中间一个值加一的右边取数据集
        # 3.1.对右侧继续二分 重复执行相同代码 并且复杂度降低
        get_target(l1_left,target_num)
    elif target_num < l1[middle_index]:
        # 4.保留数据集左侧
        l1_right = l1[:middle_index]# 4.1.对右侧继续二分 重复执行相同代码 并且复杂度降低
        get_target(l1_right,target_num)
    else:
        print('找到了',target_num)
# get_target(l1,432)

二分法的缺陷
1.如果要找的元素就在数据集的开头 二分更加复杂
2.数据集必须有顺序
目前没有最完美的算法 都有相应的限制条件

以后面试的时候 可能会让你手用python写一些算法
二分法 快排 插入 冒泡 堆排序
上述知识面试之前临时抱佛脚即可 平时无需过多研究