Python装饰器详解

装饰器

装饰器

一、基础准备

1、可调用对象

在Python中，除了用户定义的函数，调用运算符（即 ()）还可以应用到其他对象上。如果想判断对象能否调用，可以使用内置的 callable() 函数。Python 数据模型文档列出了以下 7 种可调用对象：

用户定义的函数

使用def语句或lambda表达式创建
内置函数

使用C语言（CPython）实现的函数，如：len()
内置方法

使用C语言实现的方法，如：dict.get(key)
方法

在类的定义体的函数
类

调用类是会运行类的__new__()方法创建一个实例，然后运行__init__()方法，初始化实例。最后把实例返回给调用方。因为Python没有new运算符，所以调用类相当于调用函数。（通常，调用类会创建那个类的实例，不过覆盖 __new__ 方法的话，也可能出现其他行为。）
类的实例

如果类定义了__call__方法，那么它的实例可以作为函数调用
生成器函数

使用yield关键字的函数或方法。调用生成器函数返回的是生成器对象

实例：把类的实例变成可调用对象

 class Callable:
    def __call__(self, *args, **kwargs):
        return "类的实例对象被调用"
 
 
call = Callable()
print(call())
print(callable(call))

其相当于C语言里面的函数调用运算符的重载

2、嵌套函数

嵌套函数是在另一个函数中定义的函数

使用场景：

封装 - 数据隐藏
贯彻 DRY原则
闭包

2.1.1 封装

可以使用内层函数来保护它们不受函数外部变化的影响，也就是说把它们的作用域转换为局部作用域

 def outer(n):
    count = 0  # 统计内层函数的调用次数
 
    def inner():
        print("内层函数被调用")
        nonlocal count
        count += 1  # 闭包处理
 
    return count

在全局作用域下，尝试去访问count变量会报错，访问内层函数也会报错

实例，递归函数的高级实现

 def multi(n):
    if not isinstance(n, int):
        # 如果数字不是整型
        raise TypeError("n must be Integer")
    if n < 0:
        # 如果输入的数据小于0
        raise ValueError("n must be zero or positive")
 
    def inner_multi(n):
        # 内层函数嵌套求乘积
        if n <= 1:
            return 1
        return n * inner_multi(n - 1)
 
    return inner_multi(n)
 
 
print(multi(3))

当传入的数据不符合求乘积的规则时，报错

2.1.2 贯彻 DRY 原则

DRY 原则：

是指在程序设计以及计算中避免重复代码，因为这样会降低灵活性、简洁性，并且有可能导致代码之间的矛盾
其更多的是一种架构设计思想，在软件开发过程中的万事万物均可能重复，大到标准、框架、开发流程；中到组件、接口；小到功能、代码均纯存在自我重复。而 DRY 提倡的就是在软件开发过程中应消除所有这些自我重复

比如，函数装饰器的使用

2.1.3 闭包

闭包的介绍：

在一个内部函数中，对外部作用域的变量进行引用，（并且一般外部函数的返回值为内部函数），那么内部函数就被认为是闭包

闭包的作用：

当闭包执行完后，仍然能够保持住当前的运行环境
闭包可以根据外部作用域的局部变量来得到不同的结果

Python装饰器的本质是返回一个函数地址，然后发生函数调用

比如

 def print_():
    print("你好")
    def inner():
        print("hello")
    return inner  # 将内层函数的地址返回
def main(print_):
    # 将函数作为参数传输
    inner = print_()
    print(inner)  # 其为内层函数的地址
    inner()  # 调用内层函数
main(print_)

函数可以当做其他函数的参数进行传入，同时如果返回值是函数，则返回该函数的内存地址

3、描述器

3.1 简介

描述器是一个Python对象，只要其具有__get__(), __set__(), __delete__()方法中任意一个方法的对象就叫做描述器。一个对象在访问描述器时，如果该属性是一个描述器，则默认属性回调规则会被__set__(), __get__(), __delete__()方法所覆盖

作用：

python内部自带的staticmethod, classmethod, property, super等都是描述器，在很多Python库中也都有描述器的身影，使用描述器能让你有更高的概率写出优美的代码、更简洁的API，并且会加深对Python理解

3.2 使用描述器

 class Des:
 
    def __get__(self, instance, owner):
        print('returned from des obj')  
        return self.value  # 访问实例属性触发
 
    def __set__(self, instance, value):
        print('set in des obj')
        self.value = value  # 设置对象属性的值时
 
    def __delete__(self, instance):
        print('delete in des obj')
        del self.value  # 删除对象时触发
 
 
class Foo:
    d = Des()
 
 
f = Foo()
f.d = 10
print(f.d)
del f.d

关于描述器的更多内容，请查看官方文档，这里只要求了解

二、函数装饰器

使用函数作为装饰器

1、无参装饰器

语法：

 @函数名
def test():
    pass

实例：

 def decorate(func):  # 将函数传入其中
    print("函数传入")
    print(func.__name__)
 
    def inner(*args, **kwargs):
        print("函数开始运行")
        func(*args, **kwargs)  # 如果此函数有返回值，则要给内层函数添加返回值
        print("函数运行结束")
 
    return inner  # 将内层函数，返回给外层函数
 
 
@decorate
def test():
    print("你好李华")
 
 
test()
print(test.__name__)  # 发现函数名称变为了inner
"""
# 如果不使用装饰器的话
test = decorate(test)  # 接收内层函数
test()  # 调用内层函数
"""

注意：

__name__：属性获取函数的名称

__doc__：属性获取函数里面的注释

装饰器语法实现在运行时，将待装饰的函数重定向到装饰后的函数，装饰后的原函数__name__属性发生改变

那么，如何使得函数属性name的问题呢？

 from functools import wraps
 
def decorate(func):
    print("函数传入")
 
    @wraps(func)  # 再次使用一个装饰器，使得函数名称不会改变
    def inner(*args, **kwargs):
        print("函数开始运行")
        func(*args, **kwargs)
        print("函数运行结束")
 
    return inner
 
 
@decorate
def test():
    print("你好李华")
 
 
test()
print(test.__name__)

2、有参装饰器

 from functools import wraps
 
 
def decorate_outer(name):
    print(name)
 
    def decorate(func):
        print("函数传入")
 
        @wraps(func)  # 再次使用一个装饰器，使得函数名称不会改变
        def inner(*args, **kwargs):
            print("函数开始运行")
            func(*args, **kwargs)
            print("函数运行结束")
 
        return inner
 
    return decorate
 
 
@decorate_outer("你好呀")
def test():
    print("你好李华")
 
 
test()

通过使用三层函数嵌套来实现，最外层函数接收的参数为装饰器自带的参数，次外层函数接收的参数是使用装饰器的函数

当装饰器给类使用时，实现步骤也是一样：

 from functools import wraps
 
 
def decorate(cls):
    print("类传入")
 
    @wraps(cls)  # 再次使用一个装饰器，使得类名称不会改变
    def inner(*args, **kwargs):
        print("类开始创建")
        print(cls.__name__)
        c = cls(*args, **kwargs)  # 创建类
        print("类创建结束")
        return c  # 将创建的类返回
 
    return inner
 
 
@decorate
class A:
    def print_print(self):
        print("李华好呀")
 
 
a = A()
a.print_print()
# 相当于
# A = decorate(A)
# a = A()

三、类装饰器

1、查找对象属性

 class A:
    def __init__(self, name):
        self.name = name
 
    def test(self):
        print("test")
 
 
a = A("李华")
print(dir(a))  # 获取对象属性或者实例属性
print(a.__dict__)  # 存储对象属性（类和类的实例均为对象）的一个字典，其键为属性名，值为属性的值

属性查找顺序：

判断是不是系统是自动产生的属性
在对象实例属性的字典（a.dict）中查找
在对象属性的字典（A.dict）中查找
在对象的父类中的字典（dict）中查找

只有在类的字典中找到属性，python才会去看看它有没有get等方法，对一个在实例的字典中找到的属性，python不会理会有没有get方法，而是直接返回属性本身

基于前面的使用函数作为装饰器的理解，将类作为装饰器时需要保证以下几点

类的实例是可调用的
类需要一个地方讲被装饰的函数传入到类的实例里

第一条可以通过__call__实现，第二条可以通过__init__实现

2、 `call`实现类装饰器

 class Decorate:
    def __init__(self, func):
        print("函数正在传入")
        self.func = func
 
    def __call__(self, *args, **kwargs):
        print("函数开始运行")
        self.func(*args, **kwargs)  # 如果有返回值，则要在最后面使用return返回
        print("函数运行结束")
 
 
@Decorate
def print_hello():
    print("hello")
 
 
print_hello()
print(print_hello.__name__)  # 发现报错
"""
相当于
print_hello = Decorate(print_hello)
print_hello()
"""

我们发现无法输出__name__，根据约定使用装饰器不能改变函数的__name__属性，因此我们还需要改进将类作为装饰器的使用方法

解决方法，添加一个wraps(func)(self)

 from functools import wraps
class Decorate:
    def __init__(self, func):
        print("函数正在传入")
        self.func = func
        wraps(func)(self)  # 为属性增加一个__wrapped__作为类实例属性
 
    def __call__(self, *args, **kwargs):
        print("函数开始运行")
        self.__wrapped__(*args, **kwargs)  # self.__wrapped__即为self.func
        print("函数运行结束")
 
 
@Decorate
def print_hello():
    print("hello")
 
 
print_hello()
print(print_hello.__name__)  # 返回的名字即为函数名

那么，我们以及会将此类作为装饰器正确使用了，似乎定义了__call__方法就说明问题就解决了，那么真的是如此吗？

3、将类装饰器添加到成员函数

如果直接添加到成员函数中，会直接报错

那么，但类装饰器应用于成员函数时，类成员函数变成什么样呢？

 import types
from functools import wraps
 
class Decorate:
    def __init__(self, func):
        print("函数正在传入")
        self.func = func
        wraps(func)(self)  # 为属性增加一个__wrapped__作为类实例属性
 
    def __call__(self, *args, **kwargs):
        print("函数开始运行")
        self.__wrapped__(*args, **kwargs)  # self.__wrapped__即为self.func
        print("函数运行结束")
 
    def __get__(self, instance, cls):
        """:param: instance: 即为调用装饰器的实例对象
                    cls: 即为类对象"""
        # print(instance, cls, self)
        if instance is None:
            return self
        else:
            return types.MethodType(self, instance)  # 将A实例对象添加给self里面
 
class A:
 
    @Decorate
    def test(self):
        print('hello')
 
 
a = A()
a.test()

这里需要添加__get__魔法方法，将装饰器的self对象的指向，添加A的实例对象

魔法方法具体使用，在官方文档中有详细描述：【https://docs.python.org/zh-cn/3/reference/datamodel.html】

4、带参数的类装饰器

带参数和不带参数的类装饰器有很大不同。

__init__：不再接收被装饰函数，而是接收传入参数

__call__：接收被装饰的函数，实现装饰逻辑

 from functools import wraps
 
 
class logger(object):
    def __init__(self, level='INFO'):
        self.level = level
 
    def __call__(self, func):  # 接受函数
        @wraps(func)
        def wrapper(*args, **kwargs):
            print("[{level}]: the function {func}() is running...".format(level=self.level, func=func.__name__))
            func(*args, **kwargs)
 
        return wrapper  # 返回函数
 
 
@logger(level='WARNING')
def say(something):
    print("say {}!".format(something))
 
 
say("hello")
print(say.__name__)

四、装饰器修饰协程

使用异步装饰器装饰协程比较写法比较简单，调用外部函数是要使用await挂起

同时，内层函数必须转换为协程函数

 import asyncio
from functools import wraps
from time import time
 
 
def decorate(func):
    print("协程函数传入")
 
    @wraps(func)
    async def inner(*args, **kwargs):
        # 将装饰器转换成协程函数
        print("开始运行函数")
        ret = await func(*args, **kwargs)
        print("函数运行完成")
        return ret
 
    return inner
 
 
@decorate
async def print_(a):
    await asyncio.sleep(2)
    return a
 
 
async def main():
    tasks = [asyncio.create_task(print_(i)) for i in range(10)]
    done, padding = await asyncio.wait(tasks)
    for i in list(done):
        print(i.result())  # 获取返回值
 
start = time()
asyncio.run(main())
print(f"用时{time() - start}")

posted @ 2022-04-30 15:07 Kenny_LZK 阅读(695) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· Python魔法方法

· python中pydantic库

· Python 装饰器

· python测试开发面试常考题：装饰器

· python装饰器

阅读排行：
· DeepSeek 开源周回顾「GitHub 热点速览」
· 物流快递公司核心技术能力-地址解析分单基础技术分享
· .NET 10首个预览版发布：重大改进与新特性概览！
· AI与.NET技术实操系列（二）：开始使用ML.NET
· 单线程的Redis速度为什么快？

公告

昵称： Kenny_LZK
园龄： 3年3个月
粉丝： 68
关注： 5

+加关注

2025年3月

日

一

二

三

四

五

六

随笔分类 (297)

随笔档案 (185)

文章分类 (5)

国学(5)

Kenny

Python装饰器详解

装饰器

一、基础准备

1、可调用对象

2、嵌套函数

2.1.1 封装

2.1.2 贯彻 DRY 原则

2.1.3 闭包

3、描述器

3.1 简介

3.2 使用描述器

二、函数装饰器

1、无参装饰器

2、有参装饰器

三、类装饰器

1、查找对象属性

2、 `call`实现类装饰器

3、将类装饰器添加到成员函数

4、带参数的类装饰器

四、装饰器修饰协程

公告

搜索

常用链接

最新随笔

积分与排名

随笔分类 (297)

随笔档案 (185)

文章分类 (5)

文章档案 (5)

相册 (7)

阅读排行榜

评论排行榜

推荐排行榜

最新评论

	class Callable:
	def __call__(self, args, *kwargs):
	return "类的实例对象被调用"


	call = Callable()
	print(call())
	print(callable(call))

	def outer(n):
	count = 0 # 统计内层函数的调用次数

	def inner():
	print("内层函数被调用")
	nonlocal count
	count += 1 # 闭包处理

	return count

	def multi(n):
	if not isinstance(n, int):
	# 如果数字不是整型
	raise TypeError("n must be Integer")
	if n < 0:
	# 如果输入的数据小于0
	raise ValueError("n must be zero or positive")

	def inner_multi(n):
	# 内层函数嵌套求乘积
	if n <= 1:
	return 1
	return n * inner_multi(n - 1)

	return inner_multi(n)


	print(multi(3))

	def print_():
	print("你好")
	def inner():
	print("hello")
	return inner # 将内层函数的地址返回
	def main(print_):
	# 将函数作为参数传输
	inner = print_()
	print(inner) # 其为内层函数的地址
	inner() # 调用内层函数
	main(print_)

	class Des:

	def __get__(self, instance, owner):
	print('returned from des obj')
	return self.value # 访问实例属性触发

	def __set__(self, instance, value):
	print('set in des obj')
	self.value = value # 设置对象属性的值时

	def __delete__(self, instance):
	print('delete in des obj')
	del self.value # 删除对象时触发


	class Foo:
	d = Des()


	f = Foo()
	f.d = 10
	print(f.d)
	del f.d

	def decorate(func): # 将函数传入其中
	print("函数传入")
	print(func.__name__)

	def inner(args, *kwargs):
	print("函数开始运行")
	func(args, *kwargs) # 如果此函数有返回值，则要给内层函数添加返回值
	print("函数运行结束")

	return inner # 将内层函数，返回给外层函数


	@decorate
	def test():
	print("你好李华")


	test()
	print(test.__name__) # 发现函数名称变为了inner
	"""
	# 如果不使用装饰器的话
	test = decorate(test) # 接收内层函数
	test() # 调用内层函数
	"""

	from functools import wraps

	def decorate(func):
	print("函数传入")

	@wraps(func) # 再次使用一个装饰器，使得函数名称不会改变
	def inner(args, *kwargs):
	print("函数开始运行")
	func(args, *kwargs)
	print("函数运行结束")

	return inner


	@decorate
	def test():
	print("你好李华")


	test()
	print(test.__name__)

	from functools import wraps


	def decorate_outer(name):
	print(name)

	def decorate(func):
	print("函数传入")

	@wraps(func) # 再次使用一个装饰器，使得函数名称不会改变
	def inner(args, *kwargs):
	print("函数开始运行")
	func(args, *kwargs)
	print("函数运行结束")

	return inner

	return decorate


	@decorate_outer("你好呀")
	def test():
	print("你好李华")


	test()

	from functools import wraps


	def decorate(cls):
	print("类传入")

	@wraps(cls) # 再次使用一个装饰器，使得类名称不会改变
	def inner(args, *kwargs):
	print("类开始创建")
	print(cls.__name__)
	c = cls(args, *kwargs) # 创建类
	print("类创建结束")
	return c # 将创建的类返回

	return inner


	@decorate
	class A:
	def print_print(self):
	print("李华好呀")


	a = A()
	a.print_print()
	# 相当于
	# A = decorate(A)
	# a = A()

	class A:
	def __init__(self, name):
	self.name = name

	def test(self):
	print("test")


	a = A("李华")
	print(dir(a)) # 获取对象属性或者实例属性
	print(a.__dict__) # 存储对象属性（类和类的实例均为对象）的一个字典，其键为属性名，值为属性的值

	class Decorate:
	def __init__(self, func):
	print("函数正在传入")
	self.func = func

	def __call__(self, args, *kwargs):
	print("函数开始运行")
	self.func(args, *kwargs) # 如果有返回值，则要在最后面使用return返回
	print("函数运行结束")


	@Decorate
	def print_hello():
	print("hello")


	print_hello()
	print(print_hello.__name__) # 发现报错
	"""
	相当于
	print_hello = Decorate(print_hello)
	print_hello()
	"""

	import types
	from functools import wraps

	class Decorate:
	def __init__(self, func):
	print("函数正在传入")
	self.func = func
	wraps(func)(self) # 为属性增加一个__wrapped__作为类实例属性

	def __call__(self, args, *kwargs):
	print("函数开始运行")
	self.__wrapped__(args, *kwargs) # self.__wrapped__即为self.func
	print("函数运行结束")

	def __get__(self, instance, cls):
	""":param: instance: 即为调用装饰器的实例对象
	cls: 即为类对象"""
	# print(instance, cls, self)
	if instance is None:
	return self
	else:
	return types.MethodType(self, instance) # 将A实例对象添加给self里面

	class A:

	@Decorate
	def test(self):
	print('hello')


	a = A()
	a.test()

	from functools import wraps


	class logger(object):
	def __init__(self, level='INFO'):
	self.level = level

	def __call__(self, func): # 接受函数
	@wraps(func)
	def wrapper(args, *kwargs):
	print("[{level}]: the function {func}() is running...".format(level=self.level, func=func.__name__))
	func(args, *kwargs)

	return wrapper # 返回函数


	@logger(level='WARNING')
	def say(something):
	print("say {}!".format(something))


	say("hello")
	print(say.__name__)

	import asyncio
	from functools import wraps
	from time import time


	def decorate(func):
	print("协程函数传入")

	@wraps(func)
	async def inner(args, *kwargs):
	# 将装饰器转换成协程函数
	print("开始运行函数")
	ret = await func(args, *kwargs)
	print("函数运行完成")
	return ret

	return inner


	@decorate
	async def print_(a):
	await asyncio.sleep(2)
	return a


	async def main():
	tasks = [asyncio.create_task(print_(i)) for i in range(10)]
	done, padding = await asyncio.wait(tasks)
	for i in list(done):
	print(i.result()) # 获取返回值

	start = time()
	asyncio.run(main())
	print(f"用时{time() - start}")

Kenny

Python装饰器详解

装饰器

一、 基础准备

1、 可调用对象

2、 嵌套函数

2.1.1 封装

2.1.2 贯彻 DRY 原则

2.1.3 闭包

3、 描述器

3.1 简介

3.2 使用描述器

二、 函数装饰器

1、 无参装饰器

2、 有参装饰器

三、 类装饰器

1、 查找对象属性

2、 __call__实现类装饰器

3、 将类装饰器添加到成员函数

4、 带参数的类装饰器

四、 装饰器修饰协程

公告

搜索

常用链接

最新随笔

积分与排名

随笔分类 (297)

随笔档案 (185)

文章分类 (5)

文章档案 (5)

相册 (7)

阅读排行榜

评论排行榜

推荐排行榜

最新评论

一、基础准备

1、可调用对象

2、嵌套函数

3、描述器

二、函数装饰器

1、无参装饰器

2、有参装饰器

三、类装饰器

1、查找对象属性

2、 `call`实现类装饰器

3、将类装饰器添加到成员函数

4、带参数的类装饰器

四、装饰器修饰协程