递归函数和有参装饰器

多层装饰器

'''语法糖会把紧挨着的被装饰对象的名字当作参数自动传入装饰器函数里面'''
# 判断多个语法糖装饰器函数运行顺序
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 warpper2(*args, **kwargs):
        print('执行了wrapper2')
        res2 = func2(*args, **kwargs)
        return res2
    return wrapper2

def ottuer(func3):
    print('加载了oitter3')
    def warpper3(*args, **kwarge):
        print('执行了warpper3')
        res3 = (*args, **kwargs)
        return res3
    return wrapper3

@outter1
@outter2
@outter3
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')

递归函数

# 本质：递归函数也称函数的递归
	函数在运行过程中直接或者间接的调用了自身
# 基本演示
直接自己调用自己
def index():
    print('from index')
    index()
index()
"""
maximum recursion depth exceeded while calling a Python object
最大递归深度超出限制了     python解释器自带的应急机制

在有些编程语言中 甚至没有遇警机制 代码执行真的一致到计算机崩溃为止
"""
'''这对python最大递归深度
        回答997 998 1000都可以
    官方给出的是1000
'''

# 封装函数
def get_age(n):
    if n == 1:
        return 18  # 有明确的结束条件
    return get_age(n-1) + 2
print(get_age(4))
'''千万不要想复杂了 就记嵌套图即可 有结果就是由内而外一层层拨开'''    
    

递归练习

l1 = [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(l1)

算法之二分法

# 什么是算法
解决计算问题的有效方法
"""
  算法比较偏向于学术研究 很枯燥 并且产出很少
  甚至只有非常大的互联网公司才会有算法部分
  	算法工程师薪资待遇很高 但是产出很少
  	有时候甚至几年都没有任何的成果 有点类似于研究所!!!
"""
# 二分法
前提是数据要有先后顺序（升序，降序）
l1 = [13,21,35,46,52,67,76,87,99,123,213,321,432,564,612]
# 查找一个数 123
"""
二分法原理
    获取数据集中间的元素 比对大小
        如果中间的元素大于目标数据  那么保留数据集的左边一半
        如果中间的元素小于目标数据  那么保留数据集的右边一半
    然后针对剩下的数据集再二分
        如果中间的元素大于目标数据  那么保留数据集的左边一半
        如果中间的元素小于目标数据  那么保留数据集的右边一半
    ...
"""
def get_target(l1,target_num):
    # 最后要考虑找不到情况 l1不能无限制二分
    if len(l1) == 0:
        print('不好意思没有该数据')
        return
    # 获取中间值 整数
    middle_index = len(l1) // 2
    # 判断数据的大小
    if target_num > l1[middle_index]:
        # 保留右侧
        l1_left = l1[middle_index + 1:]
        # 重复二分
        print(l1_left)
        get_target(l1_left,target_num)
    elif target_num < l1[middle_index]:
        # 保留左侧
        l1_ringht = l1[:middle_index]
        print(l1_ringht)
        # 继续二分法
        get_target(l1_ringht,target_num)
    else:
        print('找到了',target_num)
get_target(l1,432)
get_target(l1,22)
get_target(l1,13)  
"""
二分法的缺陷
    1.如果要找的元素就在数据集的开头 二分更加复杂
    2.数据集必须有顺序
目前没有最完美的算法 都有相应的限制条件
"""
"""
以后面试的时候  可能会让你手用python写一些算法
    二分法 快排 插入 冒泡 堆排序
        上述知识面试之前临时抱佛脚即可 平时无需过多研究
"""