python 装饰器(Decorators)原理说明及操作代码

作者:坦先生的AI资料室 时间:2023-12-11 19:06:50 

本文目的是由浅入深地介绍python装饰器原理

装饰器(Decorators)是 Python 的一个重要部分
其功能是,在不修改原函数(类)定义代码的情况下,增加新的功能
为了理解和实现装饰器,我们先引入2个核心操作:

1 必要的2个核心操作

1.1 核心操作1, 函数内部可以定义函数


def hi(name='world'):
   print(f"hello, {name}")

def howdoyoudo(name2=name):
       print(f"how do you do? {name2}")

howdoyoudo()
   howdoyoudo('world')

hi("ytt") # 但是新函数还是存在的。
hi("ycy") # 但是新函数还是存在的。

try:
   howdoyoudo()
except:
   print("function not found")

在这个例子中,函数hi的形参name,默认为'world'

在函数内部,又定义了另一个函数 howdoyoudo,定义这个函数时,将形参name作为新函数的形参name2的默认值。
因此,在函数内部调用howdoyoudo()时,将以调用hi时的实参为默认值,但也可以给howdoyoudo输入其他参数。
上面的例子运行后输出结果为:

hello, ytt
how do you do? ytt
how do you do? world
hello, ycy
how do you do? ycy
how do you do?
worldfunction not found

这里新定义的howdoyoudo可以称作一个“闭包”。不少关于装饰器的blog都提到了这个概念,但其实没必要给它取一个多专业的名字。我们知道闭包是函数内的函数就可以了

1.2 核心操作2 函数可以作为对象被输入输出

1.2.1 核心操作2的前置条件,函数是对象

当我们进行 def 的时候,我们在做什么?


def hi():
   print("hi")
   return "world"

这时,hi函数,打印一个字符串,同时返回一个字符串。
但hi函数本身也是一个对象,一个可以执行的对象。执行的方式是hi()。
这里hi和hi()有本质区别,
hi 代表了这个函数对象本身
hi() 则是运行了函数,得到函数的返回值。


def hi(name='world'):
   print(f"hello, {name}")
   return name
msg = hi()  # 运行函数,返回字符串,因此msg是个字符串
print(msg)
hello = hi  # 将函数本身赋值给hello,此时hello是另一个函数,即使删除原函数hi,新函数hello也可以正常调用
del hi  # 删除原函数hi
try:
   hi()
except:
   print("func hi not found")
hello("ycy") # 但是新函数还是存在的。

作为对比,可以想象以下代码


a = 'example'
b = a
del a

此时也是b存在,可以正常使用。

1.2.2函数作为输入

我们定义2个函数,分别实现自加1, 自乘2,
再定义一个函数double_exec,内容是将某个函数调用2次
在调用double_exec时,可以将函数作为输入传进来


def func1(n):
   return n+1

def func2(n):
   return n*2

def double_exec(f,x):
   return f(f(x))    

rst = double_exec(func1, 5)
print(rst)
rst = double_exec(func2, 3)
print(rst)

输出结果就是

7
27

1.2.3 函数作为输出

同样,也可以将函数作为输出


def select_func(i):
   def func1(n):
       return n+1

def func2(n):
       return n*2
   func_list = [func1, func2]    
   return func_list[i]

func = select_func(0)  # 第1个函数
print(func(5))
func = select_func(1)  # 第2个函数
print(func(5))

输出结果为

6
10

2 尝试构造装饰器

有了以上两个核心操作,我们可以尝试构造装饰器了。
装饰器的目的:在不修改原函数(类)定义代码的情况下,增加新的功能
试想一下,现在有一个原函数


def original_function:
   print("this is original function")

在不修改原函数定义代码的情况下,如果想进行函数内容的添加,可以将这个函数作为一个整体,添加到这样的包裹中:


def my_decorator(f):
   def wrap_func():
       print(f"before call {f.__name__}")
       f()
       print(f"after call {f.__name__}")
   return wrap_func
new_function = my_decorator(original_function)

我们定义了一个my_decorator函数,这个函数进行了一种操作:
对传入的f,添加操作(运行前后增加打印),并把添加操作后的内容连同运行原函数的内容,一起传出
这个my_decorator,定义了一种增加前后打印内容的行为
调用my_decorator时,对这个行为进行了操作。
因此,new_function是一个在original_function上增加了前后打印行为的新函数
这个过程被可以被称作装饰。

例子中的对象角色说明
wrap闭包函数重新定义了一种格式,这个格式可以任意的,是装饰器的真正内容
my_decorator装饰器定义了按warp这种格式进行操作的函数
f待装饰函数(形参)在定义装饰器时,待装饰函数只是一个参数
original_function实际进行装饰的函数一个具体的需要装饰的函数
new_function装饰后的函数一个具体的装饰完成的函数

这里已经可以发现,装饰器本身对于被装饰的函数是什么,是不需要考虑的。装饰器本身只定义了一种装饰行为,这个行为是通过装饰器内部的闭包函数()进行定义的。
运行装饰前后的函数,可以清晰看到装饰的效果


def original_function():
   print("this is original function")

def my_decorator(f):
   def wrap_func():
       print(f"before calling {f.__name__}")
       f()
       print(f"after calling {f.__name__}")
   return wrap_func

new_function = my_decorator(original_function)
original_function()
print("#########")
new_function()

3装饰器定义的简写

我们复现一下实际要用装饰器的情况,我们往往有一种装饰器,想应用于很多个函数,比如


def my_decorator(f):
   def wrap_func():
       print(f"before calling {f.__name__}")
       f()
       print(f"after calling {f.__name__}")
   return wrap_func

def print1():
   print("num=1")
def print2():
   print("num=2")
def print3():
   print("num=3")

此时,如果我们想给3个print函数都加上装饰器,需要这么做


new_print1 = my_decorator(print1)
new_print2 = my_decorator(print2)
new_print3 = my_decorator(print3)

实际调用的时候,就需要调用添加装饰器的函数名了


new_print1()
new_print2()
new_print3()

当然,也可以赋值给原函数名


print1 = my_decorator(print1)
print1 = my_decorator(print2)
print3 = my_decorator(print3)

这样至少不需要管理一系列装饰前后的函数。
同时,在不需要进行装饰的时候,需要把


print1 = my_decorator(print1)
print1 = my_decorator(print2)
print3 = my_decorator(print3)

全部删掉。

事实上,这样并不方便,尤其对于更复杂的装饰器来说
为此,python提供了一种简写方式


def my_decorator(f):
   def wrap_func():
       print(f"before calling {f.__name__}")
       f()
       print(f"after calling {f.__name__}")
   return wrap_func

@my_decorator
def print1():
   print("num=1")

这个定义print1函数前的@my_decorator,相当于在定义完print1后,自动直接运行了


print1 = my_decorator(print1)

一个新的麻烦及解决办法

不论采用@my_decorator放在新函数前,还是显示地重写print1 = my_decorator(print1),都会存在一个问题:
装饰后的函数,名字改变了(其实不止名字,一系列的索引都改变了)


def print1():
   print("num=1")

print(f"before decorate, function name: {print1.__name__}")
print1 = my_decorator(print1)
print(f"after decorate, function name: {print1.__name__}")

输出结果为:

before decorate, function name: print1
after decorate, function name: wrap_func

这个现象的原因是,装饰行为本身,是通过构造了一个新的函数(例子中是wrap_func函数)来实现装饰这个行为的,然后把这个修改后的函数赋给了原函数名。
这样,会导致我们预期的被装饰函数的一些系统变量(比如__name__)发生了变化。
对此,python提供了解决方案:


from functools import wraps  # 导入一个系统工具
def my_decorator(f):
   @wraps(f)  # 在定义装饰行为函数的时候,增加一个新的装饰器
   def wrap_func():
       print(f"before calling {f.__name__}")
       f()
       print(f"after calling {f.__name__}")
   return wrap_func

经过这个行为后,被装饰函数的系统变量问题被解决了


def print1():
   print("num=1")

print(f"before decorate, function name: {print1.__name__}")
print1 = my_decorator(print1)
print(f"after decorate, function name: {print1.__name__}")

输出结果为

before decorate, function name: print1
after decorate, function name: print1

当然,如果你不需要使用一些系统变量,也可以不关注这个问题。

复杂一点的情况1 被装饰函数有输入输出

刚才的例子都比较简单,被装饰的函数是没有参数的。如果被装饰的函数有参数,只需要在定义装饰行为时(事实上,这个才更通用),增加(*args, **kwargs)描述即可


from functools import wraps  
def my_decorator(f):
   @wraps(f)  
   def wrap_func(*args, **kwargs):  # 增加了输入参数
       print(f"before calling {f.__name__}")
       ret = f(*args, **kwargs)  # 透传了输入参数,并记录了输出
       print(f"after calling {f.__name__}") # line-after
       return ret  # 执行 "line-after" 后,将f的输出返回
   return wrap_func

之前的描述中可以感受到,对于例子中的装饰行为(前后加打印),函数被装饰后,本质上是调用了新的装饰函数wrap_func。
因此,如果原函数需要有输入参数传递,只需要在wrap_func(或其他任意名字的装饰函数)定义时,也增加参数输入(*args, **kwargs),并将这些参数,原封不动地传给待装饰函数f。
这种定义装饰行为的方式更具有普遍性,忘记之前的定义方式吧
我们试一下


@my_decorator
def my_add(x, y):
   return x + y

n = my_add(1, 3)
print(n)

输出

before calling my_add
after calling my_add
4

这里需要注意的是,如果按照以下的方式定义装饰器


from functools import wraps  
def my_decorator(f):
   @wraps(f)  
   def wrap_func(*args, **kwargs):  # 增加了输入参数
       print(f"before calling {f.__name__}")
       return f(*args, **kwargs)  # 透传了输入参数,并记录了输出
       print(f"after calling {f.__name__}") # line-after        
   return wrap_func

那么以下语句将不会执行


print(f"after calling {f.__name__}") # line-after        

因为装饰后实际的函数wrap_func(虽然名字被改成了原函数,系统参数也改成了原函数),运行到return f(*args, **kwargs) 的时候已经结束了

复杂一点的情况2 装饰器有输入

因为装饰器my_decorator本身也是可以输入的,因此,只需要在定义装饰器时,增加参数,并在后续函数中使用就可以了,比如


from functools import wraps  
def my_decorator(f, msg=""):
   @wraps(f)  
   def wrap_func(*args, **kwargs):  # 增加了输入参数
       print(f"{msg}, before calling {f.__name__}")
       return f(*args, **kwargs)  # 透传了输入参数,并记录了输出
       print(f"{msg}, after calling {f.__name__}") # line-after        
   return wrap_func

此时装饰器已经可以有输入参数了


def my_add(x, y):
   return x + y

my_add = my_decorator(my_add, 'yusheng')

n = my_add(1, 3)
print(n)

输出

yusheng, before calling my_add
yusheng, after calling my_add
4

你可能发现,为什么不用简写版的方法了


@my_decorator(msg='yusheng')
def my_add(x, y):
   return x + y

n = my_add(1, 3)
print(n)

因为以上代码会报错!!
究其原因,虽然


@my_decorator
def my_add(x, y):
   return x + y

等价于


def my_add(x, y):
   return x + y
my_add = my_decorator(my_add)

但是,


@my_decorator(msg='yusheng')
def my_add(x, y):
   return x + y

并不等价于


def my_add(x, y):
   return x + y
my_add = my_decorator(my_add, msg='yusheng')

这本身和@语法有关,使用@my_decorator时,是系统在应用一个以单个函数作为参数的闭包函数。即,@是不能带参数的。
但是你应该发现了,之前的@wraps(f)不是带参数了吗?请仔细观察以下代码


def my_decorator_with_parma(msg='')
   def my_decorator(f):
       @wraps(f)  
       def wrap_func(*args, **kwargs):  # 增加了输入参数
           print(f"{msg}, before calling {f.__name__}")
           return f(*args, **kwargs)  # 透传了输入参数,并记录了输出
           print(f"{msg}, after calling {f.__name__}") # line-after        
       return wrap_func
   return my_decorator

通过一层嵌套,my_decorator_with_parma本质上是返回了一个参数仅为一个函数的函数(my_decorator),但因为my_decorator对my_decorator_with_parma来说是一个闭包,my_decorator_with_parma是可以带参数的。(这句话真绕)
通过以上的定义,我们再来看


@my_decorator_with_parma(msg='yusheng')
def my_add(x, y):
   return x + y

可以这么理解,my_decorator_with_parma(msg='yusheng')的结果是原来的my_decorator函数,同时,因为my_decorator_with_parma可以传参,参数实际上是参与了my_decorator的(因为my_decorator对my_decorator_with_parma是闭包),my_decorator_with_parma(msg='yusheng')全等于一个有参数参加的my_decorator
因此,以上代码等价于有参数msg传递的


@my_decorator
def my_add(x, y):
   return x + y

比较绕,需要理解一下,或者干脆强记这种范式:


from functools import wraps  
def my_decorator(msg=''):  # 名字改一下
   def inner_decorator(f):  # 名字改一下
       @wraps(f)  
       def wrap_func(*args, **kwargs):  # 增加了输入参数
           print(f"{msg}, before calling {f.__name__}")
           ret = f(*args, **kwargs)  # 透传了输入参数,并记录了输出
           print(f"{msg}, after calling {f.__name__}") # line-after        
           return ret
       return wrap_func
   return inner_decorator

以上范式包含函数的输入输出、装饰器的输入,可以应对大部分情况了。
实验一下:


@my_decorator(msg='yusheng')
def my_add(x, y):
   return x + y

my_add(1, 2)

输出

yusheng, before calling my_add
yusheng, after calling my_add

有用的函数装饰器例子


from functools import wraps
import datetime

def log(output_path=None):  # 名字改一下
   def decorator(f):  # 名字改一下
       @wraps(f)  
       def wrap_func(*args, **kwargs):  # 增加了输入参数
           now = datetime.datetime.now()
           msg = now.strftime("%Y-%m-%d %H:%M:%S")  # 运行时刻
           msg += f" {f.__name__}()\n"  # 运行的函数名            

ret = f(*args, **kwargs)  # 透传了输入参数,并记录了输出

aft = datetime.datetime.now()
           time_cost = aft - now
           ms = time_cost.total_seconds() * 10**3  # 毫秒
           msg += now.strftime("%Y-%m-%d %H:%M:%S")
           msg += f" {f.__name__}() return, cost {ms} ms"
           if output_path is None:
               print(msg)
           else:
               print(f"print logs into {output_path}")
               with open(output_path, 'a+') as fp:
                   fp.write(msg + '\n')
       return wrap_func
   return decorator

以上是一个log装饰器,利用datetime统计了函数的耗时,

并且,装饰器可以进行输出文件操作,如果给出了文件路径,则输出文件,否则就打印。
利用这个装饰器,可以灵活地进行耗时统计


@log()
def my_sum(x, y):
   s = 0
   for i in range(x, y+1):
       s += i
   return s

my_sum(1, 9999999)

不设置输出文件地址,则打印。运行结果为:

2021-12-03 10:01:52 my_sum()
2021-12-03 10:01:52 my_sum() return, cost 506.3299999999999 ms

也可以输出到文件


@log('test.log')
def my_sum(x, y):
   s = 0
   for i in range(x, y+1):
       s += i
   return s  

my_sum(1, 9999999)

输出结果为

print logs into test.log

同时在当前目录生成了一个test.log 文件,内容为:

2021-12-03 10:03:17 my_sum()
2021-12-03 10:03:17 my_sum() return, cost 461.813 ms

从装饰函数到装饰类

以上的装饰器都是以函数形式出现的,但我们可以稍做改写,将装饰器以类的形式实现。


from functools import wraps
import datetime
class Log:
   def __init__(self, path=None):
       self._output = path

def __call__(self, f):  # 相当于原来的 inner_decorator
       @wraps(f)  
       def wrap_func(*args, **kwargs):  # 增加了输入参数
           now = datetime.datetime.now()
           msg = now.strftime("%Y-%m-%d %H:%M:%S")  # 运行时刻
           msg += f" {f.__name__}()\n"  # 运行的函数名            

ret = f(*args, **kwargs)  # 透传了输入参数,并记录了输出

aft = datetime.datetime.now()
           time_cost = aft - now
           ms = time_cost.total_seconds() * 10**3  # 毫秒
           msg += now.strftime("%Y-%m-%d %H:%M:%S")
           msg += f" {f.__name__}() return, cost {ms} ms"
           if self._output is None:
               print(msg)
           else:
               print(f"print logs into {self._output}")
               with open(self._output, 'a+') as fp:
                   fp.write(msg + '\n')
       return wrap_func

这个装饰器类Log 上个例子里的装饰器函数log功能是一样的,同时,这个装饰器类还可以作为基类被其他继承,进一步增加功能。

本文来自博客园,作者:坦先生的AI资料室,转载请注明原文链接:https://www.cnblogs.com/yushengchn/p/15636944.html

来源:https://www.cnblogs.com/yushengchn/p/15636944.html

标签:python,装饰器,Decorators
0
投稿

猜你喜欢

  • Python操作串口的方法

    2021-11-24 07:09:10
  • Go gRPC服务proto数据验证进阶教程

    2024-03-20 16:54:54
  • python实现发送和获取手机短信验证码

    2023-08-09 08:02:26
  • Python中的左斜杠、右斜杠(正斜杠和反斜杠)

    2022-02-08 07:00:34
  • tensorflow可视化Keras框架中Tensorboard使用示例

    2023-08-09 01:39:27
  • python 限制函数调用次数的实例讲解

    2023-11-11 00:34:23
  • 生成Jupyter Lab快捷方式的小技巧

    2022-11-29 11:55:42
  • PHP下 Mongodb 连接远程数据库的实例代码

    2024-06-05 09:22:29
  • 使用python3调用wxpy模块监控linux日志并定时发送消息给群组或好友

    2022-05-12 03:35:29
  • MySQL 视图 第1349号错误解决方法

    2024-01-18 14:45:41
  • Python 实现自动登录+点击+滑动验证功能

    2023-10-09 01:11:05
  • pytorch 输出中间层特征的实例

    2022-06-08 07:36:39
  • Python 图片文字识别的实现之PaddleOCR

    2022-03-12 19:07:58
  • ASP环境下邮件列表功能的实现

    2007-10-03 14:25:00
  • mysql使用mysqld_multi部署单机多实例的方法教程

    2024-01-15 12:26:01
  • 页面链接方式的统一性

    2008-03-24 17:02:00
  • PHP PDOStatement::closeCursor讲解

    2023-06-07 18:23:31
  • mysql学习笔记之帮助文档

    2024-01-19 08:14:36
  • Python中使用异常处理来判断运行的操作系统平台方法

    2021-03-28 07:37:23
  • python循环控制之break和continue流程控制语句

    2021-02-05 15:22:29
  • asp之家 网络编程 m.aspxhome.com