天狼大大

天狼大大

关注
发信
关注(28)粉丝(399)

Python基础（十四）

今日主要内容

  • 装饰器扩展
    • 有参装饰器
    • 多个装饰器装饰一个函数
  • 递归

一、装饰器扩展

（一）含有参数的装饰器

  • 先来回顾一下装饰器的标准模式

    def wrapper(fn):
  def inner(*args, **kwargs):
      """扩展内容"""
      ret = fn(*args, **kwargs)
      """扩展内容"""
  return inner

@wrapper
def func():
  pass

func()

  • 回顾一下之前的游戏模拟，通过装饰器给我的游戏过程扩展了开挂的功能，装饰之后每次想玩游戏的时候调用函数都会给你先把挂打开，此时你的游戏函数已经被装饰了，但是现在有一个问题，我今天想自己玩一把，不想开挂了，怎么办？我们可以给装饰器传一个参数，来控制我的装饰器的开启和关闭就可以了

    def wrapper_outer(argv):  # 给装饰器加一个参数，控制装饰器开启关闭
    def wrapper(fn):
        def inner(hero):
            if argv:  # 如果是True执行添加装饰
                print("开启外挂！")
                ret = fn(hero)
                print("关闭外挂！")
                return ret
            else:  # 如果是False，执行原函数
                ret = fn(hero)
                return ret
        return inner
    return wrapper

@wrapper_outer(True)
def play_lol(hero):  # 基础函数参数
  print("登陆游戏")
  print("开始排位...")
  print(f"选择英雄:{hero}")
  print("游戏中...")
  print("胜利！！！")
  print("结束游戏")
  return "坑比队友:xxx"  # 基础函数返回值

print(play_lol("盖伦"))

运行结果：
开启外挂！
登陆游戏
开始排位...
选择英雄:盖伦
游戏中...
胜利！！！
结束游戏
关闭外挂！
坑比队友:xxx

    • 刨析一下：

      • 先来看装饰器和语法糖
        • @wrapper_outer(True)先执行函数调用，函数调用返回的是我内层装饰器的函数名，相当于@wrapper
        • 装饰器最外层的参数控制内层包装函数inner里面的函数部分是否执行，如果argv为真，相当于执行了包装，如果argv为假，执行原函数
      • 通过给装饰器传参起到了控制装饰器是否生效的功能
      def wrapper_outer(argv):
    def wrapper(fn):
        def inner(hero):
            if argv:  # 为真执行这里
                print("开启外挂！")
                ret = fn(hero)
                print("关闭外挂！")
                return ret
            else:  # 为假执行这里
                ret = fn(hero)
                return ret
        return inner
    return wrapper

@wrapper_outer(True)  # 先执行函数调用
      • 注意：一旦给函数装饰过，装饰器的参数是不能变化的，因为闭包的原因参数已经被闭进去了，只能调用内层函数，无法再修改最外层的装饰器参数
      flag = True
def wrapper_outer(argv):
    def wrapper(fn):
        def inner(*args, **kwargs):
            if argv:
                """扩展功能"""
                ret = fn(*args, **kwargs)
                """扩展功能"""
                return ret
            else:
                ret = fn(*args, **kwargs)
                return ret
        return inner
    return wrapper

@wrapper_outer(flag)
def func():
    pass

flag = False
func()  # 此时flag依然是True，装饰过就不能修改参数的值

  • 有参装饰器的标准模式

    def wrapper_outer(argv):
    def wrapper(fn):
        def inner(*args, **kwargs):
            if argv:
                """扩展功能"""
                ret = fn(*args, **kwargs)
              """扩展功能"""
                return ret
            else:
                ret = fn(*args, **kwargs)
                return ret
        return inner
    return wrapper

@wrapper_outer(True)
def func():
    pass

func()

（二）多个装饰器装饰一个函数

  • 执行原理：从里到外进行包装

    def wrapper1(fn):
  def inner(*args, **kwargs):
      print("扩展功能1")
      ret = fn(*args, **kwargs)
      print("扩展功能4")
      return ret
  return inner

def wrapper2(fn):
  def inner(*args, **kwargs):
      print("扩展功能2")
      ret = fn(*args, **kwargs)
      print("扩展功能3")
      return ret
  return inner

@wrapper1
@wrapper2
def func():
  print("目标函数")

func()

运行结果：
扩展功能1
扩展功能2
目标函数
扩展功能3
扩展功能4

    • 刨析一下：

      • 从里往外看，先用第一层装饰器@wrapper2装饰目标函数func(),装饰完将其看作成一个整体，在被上层装饰器@wrapper1装饰
      • 返回值：执行完目标函数，将目标函数的返回值先反给最近的装饰器@wrapper2内部的inner包装函数中，之后再将@wrapper2内部的inner包装函数的返回值返回给上一层装饰器@wrapper1内部的inner中，最终得到的返回值是我调用函数的返回值
      • 最终调用目标函数其实真正执行的是最外层装饰器中的包装函数inner，而最外层装饰器中的包装函数inner包装着内层装饰器的包装函数inner，而内层装饰器的包装函数inner包装着真正的目表函数func
      # 伪代码:

def 装饰器1(传入目标函数):
    def 内层包装函数1，也是真正执行的函数(目标函数的参数):
        """前扩展功能"""
        目标函数(目标函数的参数)
        """后扩展功能"""
    return 包装函数的函数名

def 装饰器2(传入目标函数):
    def 内层包装函数2，也是真正执行的函数(目标函数的参数):
        """前扩展功能"""
        目标函数(目标函数的参数)
        """后扩展功能"""
    return 包装函数的函数名

@装饰器1
@装饰器2
def 目标函数(形参):
    函数体

目标函数(实参)

# 真正执行过程:
先执行:装饰器1的内层包装函数1，而传入的目标函数是:装饰器2的内层包装函数2
再执行:装饰器2的内层包装函数2，而传入的目标函数是:目标函数

二、递归

（一）什么是递归

  • 首先递归是一个函数，只要满足两个要求的函数就是递归函数：
    • 不断调用自己本身
    • 有明确的结束条件

（二）递归深度

  • 如果只是在不断的调用自己本身，没有一个明确的结束条件，那么就是一个死递归（无限循环）。

  • Python官方规定，为了避免无限制的调用自己本身，递归的最大深度为1000（最多只能调用自己本身1000次），实际递归深度为998

    def func():
    print(1)
    func()

func()

运行结果：
[Previous line repeated 994 more times]
1
1
1
...(共打印998个1)

  • 可以通过导入sys模块，修改最大递归深度

    import sys
sys.setrecursionlimit(100)  # 修改递归深度

def func():
    print(1)
    func()

func()

运行结果：
[Previous line repeated 94 more times]
1
1
1
...(实际打印98个1)

（三）递归的应用

  1. 求n的阶乘

    def factorial(n):
    if n == 1:
        return 1
    return factorial(n - 1) * n

print(factorial(5))

运行结果：
120

  2. 计算斐波那契序列

    def fib(n):
 if n <= 2:
     return 1
 return fib(n-1) + fib(n-2)

print(list(map(fib,range(1, 6))))

运行结果：
[1, 1, 2, 3, 5]

  3. 打印列表嵌套的每一个元素

    l1 = [1, 2, [3, 4, [5, [6, 7, [8, 9], 10], 11, 12], 13], 14, 15]

def func(lst):
    for el in lst:
        if type(el) == list:
            func(el)
        else:
            print(el, end=" ")

func(l1)

运行结果：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

  4. 给列表去重，不能使用集合

    l1 = [1, 1, 2, 3, 4, 5, 6, 3, 3, 5, 6, 3, 4, 5]

def del_repetition(lst):
    for el in lst:
        if lst.count(el) > 1:
            lst.remove(el)
            del_repetition(lst)

del_repetition(l1)
print(l1)

运行结果：
[1, 2, 6, 3, 4, 5]

  5. 遍历文件夹中所有的文件

    import os

def read(filepath, n):
    files = os.listdir(filepath)  # 获取到当前文件夹中的所有文件
    for fi in files:  # 遍历文件夹中的文件, 这里获取的只是本层文件名
        fi_d = os.path.join(filepath, fi)  # 加入文件夹 获取到文件夹文件
        if os.path.isdir(fi_d):  # 如果该路径下的文件是文件夹
            print("\t" * n, fi)
            read(fi_d, n + 1)  # 继续进行相同的操作
        else:
            print("\t" * n, fi)  # 递归出口. 最终在这里隐含着return

# 递归遍历目录下所有文件
read('../day16/', 0)

  6. 二分查找

    # 普通递归版本⼆二分法
lst = [22, 33, 44, 55, 66, 77, 88, 99, 101, 238, 345, 456, 567, 678, 789]
n = 567
left = 0
right = len(lst) - 1

def binary_search(n, left, right):
    if left <= right:
        middle = (left + right) // 2
        if n < lst[middle]:
            right = middle - 1
        elif n > lst[middle]:
            left = middle + 1
        else:
            return middle
        return binary_search(n, left, right)
        # 这个return必须要加. 否则接收到的永远是None.
    else:
        return -1

print(binary_search(567, 0, len(lst) - 1))

  7. 三级菜单进入返回

    menu = {
    '北京': {
        '海淀': {
            '五道口': {
                'soho': {},
                '网易': {},
                'google': {}
            },
            '中关村': {
                '爱奇艺': {},
                '汽车之家': {},
                'youku': {},
            },
            '上地': {
                '百度': {},
            },
        },
        '昌平': {
            '沙河': {
                '北邮': {},
                '北航': {},
            },
            '天通苑': {},
            '回龙观': {},
        },
        '朝阳': {},
        '东城': {},
    },
    '上海': {
        '闵行': {
            "人民广场": {
                '炸鸡店': {}
            }
        },
        '闸北': {
            '火车战': {
                '携程': {}
            }
        },
        '浦东': {},
    },
    '天津': {
        "和平": {
            "小白楼": {},
            "五大道小洋楼": {},
            "滨江道": {},
        },
        "南开": {
            "天大": {},
            "南开": {},
            "理工": {},
        },
        "河北": {
            "天津之眼": {},
            "海河": {},
            "意式风情区": {},
            "世纪钟": {},
            "大悲院": {},
        },
    },
}

def menu_func(menu):
    while True:
        for k in menu:
            print(k)
        key = input('input>>').strip()
        if key == 'b' or key == 'q':
            return key
        elif menu.get(key):
            ret = menu_func(menu[key])
            if ret == 'q':
                return 'q'

menu_func(menu)
10-03 11:05
Powered by LMLPHP ©2024 天狼大大 0.040839