函数和算法

今日总结

• 多层语法糖内部本质

• 有参装饰器

• 递归函数

• 算法之二分法

多层装饰器

'''语法糖会将紧挨着的被装饰对象的名字当作参数自动传入装饰器函数中'''
#判定七句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')
    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
@outter2
@outter3
def index():
    print('from index')
index()

 

 

有参装饰器

def outter(source_data):
    def login_auth(func_name):  # 不能动 只能接收一个被装饰对象名字
        def inner(*args,**kwargs):  # 不能动 是专门用来给被装饰的对象传参的
            username = input('username:').strip()
            pwd = 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
    '''
    函数名加括号 执行优先级最高
    
    @outter('3')
        左侧是语法糖结构 右侧是函数名加括号结构
            先执行函数调用 outter('3') 返回值是login_auth
            再执行语法糖结构 @login_auth
        发现最后还是一个普通的装饰器
    有参装饰器目的仅仅是给装饰器传递额外的参数
    装饰器最多就三层嵌套
    '''
​
    @outter('3')
    def index():
        print('from index')

递归函数

# 本质：递归函数也称为函数的递归
    函数在运行过程中直接或简介调用了自身
# 基本演示
# 直接调用自身
def index():
    print('from index')
    index()
index()

 

 

'''
最大递归深度超出限制了 python解释器自带的应急机制
有些编程语言 没有应急机制 代码执行到计算机崩溃为止
'''
#间接调用自己
def index():
    print('from index')
    func()
def func():
    print('from func')
    index()
func()
​

 

 

'''
这对python最大递归深度
    回答 997 998 1000都可以
    官方给出的是1000
'''
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.必须要有明确的结束条件
''''''
​
l = [1,[2,[3,[4,[5,[6,[7,[8]]]]]]]]
  # 定义一个函数
def inner(l):
    #for 循环判断是否为整形
    for i in l:
        if isinstance(i,int):
            print(i)
        else:
            inner(i)
inner(l)

 

 

​

算法之二分法

什么是算法？
    算法其实就是解决问题的有效方法
算法之二分法
    二分法是算法里面最入门的一个 主要是感受算法的魅力所在
''''''二分法使用有前提：数据集必须有先后顺序(升序 降序)''''''
二分法原理
    获取数据集中间的元素 对比大小
        如果中间的元素大于目标元素 那么保留数据集的左边一半
        如果中间的元素小于目标元素 那么保留数据集的右边一半
    然后针对剩下的数据集再二分
        如果中间的元素大于目标元素 那么保留数据集的左边一般
        如果中间的元素小于目标元素 那么保留数据集的右边一半
        ...
​
#  算法之二分法
l1 =[1,22,31,55,66,78,98,112,333,444,555]
def get_num(l1,find_num):
    #  要考虑找不着的情况
    if len(l1) == 0:
        print('没找着')
        return
    #  1.获取中间元素的索引值(只能是整数)
    mid_index = len(l1) // 2
    #  2.判断中间索引对应的数据与目标数据的大小
    if find_num > l1[mid_index]:
        #  3.保留数据集右侧
        l1_left = l1[mid_index+1:]
        #  3.1.对右侧继续二分 重复执行相同代码 并且复杂度降低
        print(l1_left)
        get_num(l1_left,find_num)
    elif find_num < l1[mid_index]:
        #  4.保留数据集左侧
        l1_right = l1[:mid_index]
        print(l1_right)
        #  4.1.对右侧继续二分 重复执行代码 并且复杂度降低
        get_num(l1_right,find_num)
    else:
        print('找到',find_num)
​
get_num(l1,66)
get_num(l1,98)
​

 

 

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