今日内容概要

• 作业讲解

• 多层语法糖内部本质

• 有参装饰器

• 递归函数

• 算法之二分法

作业讲解

# 基本要求:给多个函数加上用户认证功能
# 2.多个函数都需要添加一个相同的功能  毫无疑问首先应该考虑使用装饰器
'''装饰器的使用原则与函数一致  也必须先定义后调用'''
def login_auth(func_name): 
    def inner(*args, **kwargs):
        username = input('username>>>:').strip()
        password = input('password>>>:').strip()
        if username == 'jason' and password == '123':
            res = func_name(*args, **kwargs)  # 正常执行函数
            return res
        else:
            print('用户名或密码错误 没有权限')
    return inner
# 1.先定义出多个函数
@login_auth
def index():
    print('from index')
@login_auth
def home():
    print('from home')
@login_auth
def func():
    print('from func')
"""
上述装饰器可以实现 哪个函数需要用户认证就给哪个函数加上
之后每次执行都需要验证身份 类似于生活中手机支付 每次都需要验证一样
"""

进阶版练习：

　　多个函数被装饰后 只要有一次认证成功 之后就不需要认证

# 3.思考如何记住用户是否认证成功 再考虑到可变不可变类型在局部被修改的特点 建议使用可变类型
is_auth = {'is_login':False}  # 默认用户没有登录
# 1.先编写装饰器模板
def login_auth(func_name):
    def inner(*args, **kwargs):
        # 每次验证之前 应该先判断用户是否已经登录
        if is_auth.get('is_login'):
            res = func_name(*args, **kwargs)
            return res  # 装饰器本质也是函数 遇到return也会自动结束
        username = input('username>>>:').strip()
        password = input('password>>>:').strip()
        if username == 'jason' and password == '123':
            # 认证成功 正常执行函数
            res = func_name(*args, **kwargs)
            # 修改全局变量
            is_auth['is_login'] = True
            return res
        else:
            print('用户名或密码错误 没有权限')
    return inner
# 2.定义基本函数
@login_auth
def index():
    print('from index')
@login_auth
def home():
    print('from home')
@login_auth
def func():
    print('from func')
index()
home()
func()
'''在日常生活中 比如很多网站的登录 只要成功一次 之后很长时间都不需要再次登录'''

多层语法糖

"""语法糖会将紧挨着的被装饰对象的名字当做参数自动传入装饰器函数中"""
# 判断七句print执行顺序
def outter1(func1):  # 第十步
    print('加载了outter1')  # 第十一步
    def wrapper1(*args, **kwargs):  #第十二步
        print('执行了wrapper1')
        res1 = func1(*args, **kwargs)
        return res1
    return wrapper1  # 第十三步

def outter2(func2):
    print('加载了outter2')  # 第六步 执行'加载了outter2'
    def wrapper2(*args, **kwargs):  # 第七步定义了一个wrapper2
        print('执行了wrapper2')
        res2 = func2(*args, **kwargs)
        return res2
    return wrapper2  # 第八步返回了一个wrapper2

def outter3(func3):
    print('加载了outter3')  # 第二步开始运行'加载了outter3'
    def wrapper3(*args, **kwargs):  # 第三步定义了一个wrapper3
        print('执行了wrapper3')
        res3 = func3(*args, **kwargs)
        return res3
    return wrapper3  # 第四步返回了一个wrapper3


@outter1  # 第九步 outter1(wrapper2)
@outter2  # 第五步 outter2（wrapper3）
@outter3
def index():  # 第一步  将index函数名当作参数传给outter3
    print('from index')
index（） # wrapper1()

"""
所以加载的顺序：
  加载了outter3
  加载了outter2
  加载了outter1
"""

有参装饰器

顾名思义就是有具体参数的装饰器，作用是传额外的参数

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()　

"""
maximum recursion depth exceeded while calling a Python object
最大递归深度超出限制了 python解释器自带的应急机制

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

间接调用自己
def index():
    print('from index')
    func()
def func():
    print('from func')
    index()
func()

"""
maximum recursion depth exceeded while calling a Python object
这对python最大递归深度
回答997 998 1000都可以
官方给出的是1000
"""

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

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

2.必须要有明确的结束条件

递归练习

```python
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)
```

算法之二分法

算法其实就是解决问题的有效方法，二分法是算法里面最入门的一个 主要是感受算法的魅力所在。

二分法使用有前提:

数据集必须有先后顺序(升序 降序)

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

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