多层语法糖与递归函数

多层装饰器
有参装饰器
递归函数
递归函数练习
二分法

多层装饰器

'''
语法糖会将紧挨着的被装饰对像的名字当作参数自动传入装饰器函数中
'''
# 判断print的打印顺序
def outter1(func1):
    print('outter1')
    def wrapper1(*args, **kwargs):
        print('wrapper1')
        res1 = func1(*args, **kwargs)
        retern 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')
        res2 = func3(*args, **kwargs)
        return res3
    return wrapper3


@outter3
@outter2
@outter1
def index():
    print('index')

有参装饰器

def outter(data):
    def login_auth(func_name):  #不能动，只能接收被装饰对象的名字
        def inner(*args, **kwargs):  # 只能给被装饰对象传参
            username = input('username>>>').strip
            owd = input('pwd>>>').strip
'''
	校验用户数据  数据的来源可以有很多 比如全局字典 全局列表 文件等 数据的来源不同 处理方式就不同 对应的代码编写就不一样分支结构处理 根据不同的参数 匹配不同的流程
'''
			if data == '1'
    			print('使用字典的方式处理数据')
			if data == '2'
            	print('使用处理列表的方式处理数据')
             else:
                print('采用其他方式')
			res = func_name(*args, **kwargs)
			return res
        return inner
    return login_auth
'''
函数名加括号的执行优先级最高

@outer('2')
	左侧是语法糖结构 右侧是函数调用，由于函数调用优先级最高，所以，现调用outer('2') 返回值login_auth
	然后就变成了   @login_auth
	与普通的装饰器一样
'''

递归函数

# 递归函数，也被称为函数的递归
本质是，函数在运行过程中，直接或者间接的调用函数本身
#直接调用自己
def index():
	print('index')
    index()
index()
#间接调用自己
def func():
	index()
def index():
	finc()
index()
'''
当上面这种情况发生，也就是，函数一直递归调用，没有结束条件，函数的复杂的没有降低，也就是，无意义的递归，在函数递归调用1000次后，python解释器会强行停止递归，并报错提醒，超出最大递归深度
'''
# 可以通过sys模块中的getrecursionlimit()方法获取最大递归深度，setrecursionlimit()方法修改最大递归深度
import sys
print(sys.getrecursionlimit())  # 获取最大递归深度
sys.setrecursionlimit(2000)  # 修改最大递深度
'''
递归函数的使用应该满足两个条件：
	1.每次递归复杂的应该降低
	2.有明确的结束条件
'''

递归函数练习

'''
五排学生最后一排学生18，前面一排学生比后面的学生大2岁，求第一排学生的年龄
'''
def func(count):
    if count == 1:
    	return 18
    return func (count - 1) + 2
print(func(5))
'''
取出列表l = [1,[2,[3,[4,[5]]]]]中的每一个数字
'''
l = [1,[2,[3,[4,[5]]]]]
def func(list):
    for i in list:
        if isinstance(i,int):
            print(i)
        else:
            return func(i)
func(l)

二分法

'''
二分法是一个基础的算法，是算法里面比价简单的一个， 算法就是解决问题的有效方法，方法不同，效率不同
'''

# 使用二分法的前提是，数据集必须是升序或者降序
l1 =[13,21,35,46,52,67,76,87,99,123,213,321,432,564,612]
# 查找  a = 99
'''
二分法原理，获取数据集的中间元素，与所查元素比较大小
以升序为例
如果中间元素大于99,就保留数据集左边的元素，再次二分，循环往复，直到找到对应元素
如果中间元素小于99，则保留右边的元素
'''
def index(l, num):
    if len(l) == 0:
        print('没有这个数')
    res = len(l)
    middle = res // 2
    if l[middle] == num:
        print('找到了')
    if l[middle] > num:
        l_left = l[0:middle]
        print(l)
        index(l_left, num)
    if l[middle] < num:
        l_right = l[middle + 1:]
        print(l)
        index(l_right, num)
index(l1,99)
index(l1, 99)
'''
二分法的缺陷
	1.如果要找的元素在开头，二分法会更复杂
	2.数据集必须是有序的
'''