多层装饰器

* 多层装饰器也就是多了闭包函数 使得装饰器更加清晰。
def outter1(func1):
    print('加载了outter1')
    def wrapper1(*args,**kwargs):
        print('执行了wrapper1')
        res1=func1(*args,**kwargs)
        return res1
    return wrapper1
def outter2(func2):
    print('加载了uotter2')
    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)
        res3=func3(*args,**kwargs)
        return res3
    return wrapper3
@outter1
@outter2
@outter3
def index():
    print('from index')
    

有参装饰器

* 我们的装饰器最多也就三层 不管内部的那层函数需要用到都是外部的函数进传参  
目的也是为了给装饰器传递更多的额外的数据
def outer(condition,type_user):   
    def login_auth(func_name):
        def inner(*args,**kwargs):
            username=input('username>>>:').strip()
            password=input('password>>>').strip()
            if type_user=='yqb':
                print('vip')
                if condition=='列表':
                print('使用列表作为数据的来源比对原来的数据')
            elif condition=='文件':
                print('使用文件作为数据的来源比对原来的数据')
            elif condition=='字典':
                print('使用字典作为数据的来源比对原来的数据')
            else:
               print('现在只有三种方式')
               return inner
            return login_auth
        @outer('文件','yqb')
        def inddex():
            print('from index')
            

递归函数

  * 在函数内部可以调用其他的函数，如果一个函数在内部调用自身本身这个函数就是递归函数。
  * 在python中允许最大递归雕鹰的次数官方给的是1000  但也有是不准  会有一定的偏差的。

     直接调用：
     def index（）
         print（‘from index’）
         index（）
    简介调用：
    def index():
        print('from index')
        func()
    def func():
        print('from func')
        index()
        func()    

递归函数应用在递推和回溯 每次都要比上一次要简单 在最终结束的时候都要有一个明确的结束条件。

算法二分法

二分法其实是分治算法的一种特殊方式，将区间均匀分配。基本思想就是将一个有序区间，以中间数为界限，缩小查找值所在的区间。也是最简答的算法，

l1 = [11, 23, 32, 45, 65, 78, 90, 123, 432, 467, 567, 687, 765, 876, 999, 1131, 1232]
def get_num(l1, target_num):
    if len(l1) == 0:
        print('不好意思 找不到')
        return
    middle_index=len(l1)//2
    middle_value=l1[middle_index]
    if target_num>middle_value:
        right_l1=l1[middle_index+1:]
        print(right_l1)
        get_num(right_l1,target_num)
    elif target_num<middle_value:
        left_l1=l1[:middle_index]
        print(left_l1)
        get_num(left_l1,target_num)
    else:
        print('找到了',target_num)
get_num(l1, 999)

1.尝试编写有参函数将多种用户验证方式整合到其中 直接获取用户数据比对 数据来源于列表 数据来源于文件 2.尝试编写递归函数 推导指定某个人的正确年龄 eg: A B C D E 已知E是18 求A是多少

def func(n):  
    if n ==1: 
        return 18
    else:
        return 2+func(n-1)
A=func(5)
print(A)

    

3.自行查阅资料 提前收集常见算法 快拍 插入 冒泡等

    快排：从一堆杂乱的数据中挑选一个基准值，将这些数字和基准值一一比较，大的放基准值的右边，小的放左边
    实现思路：定义一个函数，挑选列表的首个数字作为基准值，其他数字比基准值小的数字生成列表，同理，其他数字和基准值大的数字生成另一个列表，再递归快排这两个列表
            def quick_sort(nums):

          if len(nums) < 2:
                return nums
            else:
                base = nums[0]
                left = [ i for i in nums[1:] if i <base ]
                right = [i for i in nums[1:] if i > base]
                return quick_sort[left] + [base] + quick_sort[right]

        nums = [5, 88, 35, 1, -8, 52, 552, 103254, 956, 235, 154, 22]
        print(quick_sort(nums))
        输出：[-8, 1, 5, 22, 35, 52, 88, 154, 235, 552, 956, 103254]

 冒泡：从左向右，两两比较，如果左边大于右边，则交换位置
    def bubble_sort(arr):
      length = len(arr)

   for i in range(length):
        for j in range(length - i - 1):
          if arr[j] > arr[j + 1]:
               arr[j], arr[j + 1] = arr[j + 1], arr[j]
      return arr