本文主要是介绍多层有参装饰器递归，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

多层装饰器

  '''语法糖会将紧挨着的被装饰对象的名字当做参数自动传入装饰器函数中'''
  # 判断七局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')

有参装饰器

  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
          @wrps(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解释器自带的应急机制

  在有些编程语言中 甚至没有遇警机制 代码执行真的一致到计算机崩溃为止
  """
  # 间接调用自己
   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)  # 还可以修改最大递归深度
   count = 1
   def index():
       print('from index')
       global count
       print(count)
       count += 1
       index()
   index()

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

  # 诠释
  """
  需求:我想知道我们班坐在第一排的某个学生年龄
  过程:
      我问他多大了 他调皮不告诉我 说比后面那个同学大两岁
      后面的说比他后面的大两岁
      ...
      问到最后你一排 终于开口说 18岁
      ...
      知道最后一排的年级回推就可以知道第一排的年级
  名词:
      递推:一层层往下问
      回溯:根据结果推结论
  """

  # 如何编写代码完成
    # 目标人物的年龄 = 后一排年龄 + 2
    # 后一排年龄 = 后后一排年龄 + 2
    # 后后一排年龄 = 后后后一排年龄 + 2
    # 后后后后一排年龄 = 18
  # 将求问年龄变成函数
       age(5) = age(4) + 2
       age(4) = age(3) + 2
       age(3) = age(2) + 2
       age(2) = age(1) + 2
       age(1) = 18
  # 封装函数
  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)

算法之二分法

  # 什么是算法?
	算法其实就是解决问题的有效方法
  	eg:比如打开易拉罐的问题
      	方法1:使用金属撬棍
        方法2:直接手扣
        方法3:一阳指戳
        ...
  """
  算法比较偏向于学术研究 很枯燥 并且产出很少
  甚至只有非常大的互联网公司才会有算法部分
  	算法工程师薪资待遇很高 但是产出很少
  	有时候甚至几年都没有任何的成果 有点类似于研究所!!!
  """

# 算法之二分法
  二分法是算法里面最入门的一个 主要是感受算法的魅力所在
  """二分法使用有前提: 数据集必须有先后顺序(升序 降序)"""
  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
          # 1.获取中间元素的索引值(只能是整数)
          middle_index = len(l1) // 2
          # 2.判断中间索引对应的数据与目标数据的大小
          if target_num > l1[middle_index]:
              # 3.保留数据集右侧
              l1_left = l1[middle_index+1:]
              # 3.1.对右侧继续二分 重复执行相同代码 并且复杂度降低
              print(l1_left)
              get_target(l1_left,target_num)
          elif target_num < l1[middle_index]:
              # 4.保留数据集左侧
              l1_right = l1[:middle_index]
              print(l1_right)
              # 4.1.对右侧继续二分 重复执行相同代码 并且复杂度降低
              get_target(l1_right,target_num)
          else:
              print('找到了',target_num)
      # get_target(l1,432)
      # get_target(l1,22)
      get_target(l1,13)
  """
  二分法的缺陷
      1.如果要找的元素就在数据集的开头 二分更加复杂
      2.数据集必须有顺序
  目前没有最完美的算法 都有相应的限制条件
  """
  """
  以后面试的时候  可能会让你手用python写一些算法
      二分法 快排 插入 冒泡 堆排序
          上述知识面试之前临时抱佛脚即可 平时无需过多研究
  """

这篇关于多层有参装饰器递归的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！