python装饰器2：进阶

本文是装饰器相关内容的第二篇，接上一篇python函数装饰器详解。

函数装饰器装饰方法

函数装饰器装饰普通函数已经很容易理解了：

@decorator
def func():...

#等价于
def func():...
func = decorator(func)

如果装饰器是带参装饰器，那么等价的形式大概是这样的(和装饰器的编码有关，但最普遍的编码形式如下)：

@decorator(x, y, z)
def func():...

# 等价于
def func():...
func = decorator(x, y, z)(func)

这样的函数装饰器也可以去装饰类中的方法。看下面的方法装饰形式：

class cls:
    @decorator
    def method(self,arg1,arg2):
        ...

它等价于：

class cls:
    def method(self,arg1,arg2):
        ...
    method = decorator(method)

在decorator的编码中，仍然像普通的函数装饰器一样编写即可。例如:

def decorator(F):
    @wraps(F)
    def wrapper(*args, **kwargs):
        ...    # args[0] = self_instance
               # args[1]开始才是手动传给method的参数
    return wrapper

但必须要考虑到method的第一个参数self，所以包装器wrapper()的第一个参数也是self。

如此一来，函数装饰器既可以装饰函数，又可以装饰方法。

下面是一个示例：

from functools import wraps

def decorator(F):
    @wraps(F)
    def wrapper(*args, **kwargs):
        result = F(*args, **kwargs)
        print(args)
        return result
    return wrapper

@decorator
def func(x,y):
    return x + y

print(func(3, 4))

print("-" * 30)

class cls:
    @decorator
    def method(self, x, y):
        return x + y

c = cls()
print(c.method(3, 4))

输出结果：

(3, 4)
7
------------------------------
(<__main__.cls object at 0x01DF1C50>, 3, 4)
7

让类称为装饰器

不仅函数可以作为装饰器，类也可以作为装饰器去装饰其它对象。

如何让类作为装饰器

要让类作为装饰器，先看装饰的形式：

class Decorator:
    ...

@Decorator
def func():
    ...

func(arg1, arg2)

如果成功装饰，那么它等价于：

def func(): ...
func = Decorator(func)

func(arg1, arg2)

这和函数装饰器看上去是一样的，但区别在于Decorator这里是一个类，而不是函数，且Decorator(func)表示的是创建一个Decorator类的实例对象，所以这里赋值符号左边的func是一个对象。所有后面的func(arg1, arg2)是调用对象，而不是调用函数。

要让实例对象成为可调用对象，它必须实现__call__方法，所以应该在Decorator类中定义一个__call__。而且每次调用实例对象的时候，都是在调用__call__，这里的__call__对等于函数装饰器中的包装器wrapper，所以它的参数和逻辑应当和wrapper一样。

如下：

class Decorator():
    def __call__(self, *args, **kwargs):
        ...

再看func = Decorator(func)，func是Decorator类创建实例的参数，所以Decorator类还必须实现一个__init__方法，接受func作为参数：

class Decorator:
    def __init__(self, func):
        ...
    def __call__(self, *args, **kwargs):
        ...

元数据问题

这样的装饰器已经能正常工作了，但是会丢失func的元数据信息。所以，必须使用functools的wraps()保留func的元数据：

from functools import wraps

class Decorator:
    def __init__(self, func):
        wraps(func)(self)
        ...
    def __call__(self, *args, **kwargs):
        ...

为什么是wraps(func)(self)？这里显然不能@wraps(func)的方式装饰包装器，所以只能使用wraps()的原始函数形式。在wraps()装饰函数包装器wrapper的时候，@wraps(func)等价于wrapper = wraps(func)(wrapper)，所以这里wraps(func)(self)的作用也是很明显的：保留func的元数据，并装饰self。被装饰的self是什么？是Decorator的实例对象，因为Decorator类实现了__call__，所以self是可调用的，所以这里的self类似于函数装饰器返回的wrapper函数(实际上self是Decorator(func)返回的各个实例对象)。

类作为装饰器的参数问题

虽然self是Decorator的可调用实例对象，但是上面的代码中self并不具有func属性，也就是说无法从self去调用func()函数，这似乎使得整个过程都崩塌了：废了老大的劲去解决各种装饰器上的问题，结果却不能调用被装饰的函数。

有两种方式可以解决这个问题：

  1. 在__init__中使用self.func = func保留func对象作为装饰器的一个属性
  2. 在使用wraps()后直接在包装器__call__中使用__wrapped__调用原始func函数

这两种方式其实是等价的，因为self.func和__wrapped__都指向原始的函数。

def __init__(self,func):
    wraps(func)(self)
    self.func = func
def __call__(self, *args, **kwargs):
    result = self.func(*args, **kwargs)

#-------------------------------

def __init__(self, func):
    wraps(func)(self)
def __call__(self, *args, **kwargs):
    result = self.__wrapped__(*args, **kwargs)

但这两种方式都有缺陷，缺陷在于装饰类中方法时。(注：在装饰普通函数、类方法的时候，上面的方式不会出错)

class cls:
    @decorator
    def method(self, x, y):...

因为self.func和__wrapped__装饰cls中的方法时指向的都是cls的类变量(只不过这个属性是装饰器类decorator的实例对象而已)，作为类变量，它无法保存cls的实例对象，也就是说method(self, x, y)的self对装饰器是不可见的。

用一个示例解释更容易：

import types
from functools import wraps

# 作为装饰器的类
class decorator:
    def __init__(self,func):
        self.func = func
    def __call__(self, *args, **kwargs):
        print("(1): ",self)      # (1)
        print("(2): ",self.func) # (2)
        print("(3): ",args)      # (3)
        return self.func(*args, **kwargs)

class cls:
    @decorator
    def method(self, x, y):
        return x + y

c = cls()
print("(4): ",c.method)      # (4)
print(c.method(3, 4))

输出结果：

(4):  <__main__.decorator object at 0x03261630>
(1):  <__main__.decorator object at 0x03261630>
(2):  <function cls.method at 0x032C2738>
(3):  (3, 4)
Traceback (most recent call last):  File "g:/pycode/scope.py", line 21, in <module>
    print(c.method(3, 4))
  File "g:/pycode/scope.py", line 12, in __call__    return self.func(*args, **kwargs)
TypeError: method() missing 1 required positionalargument: 'y'

注意观察上面__call__中输出的几个对象：

  • self对应的是decorator的实例对象method，而非cls的实例对象c，看输出结果的前两行即可知
  • self.func指向的是原始方法method，它是类变量，是类方法(函数)，是装饰器赋予它作为函数的。也就是说，self.func指向的不是对象方法，而是类方法，类方法不会自动传递实例对象
  • args中保存的参数列表是(3, 4)，但是cls.method中多了一个self位置参数，使得3赋值给了self，4被赋值给了x，y成了多余的，所以最后报错需要位置参数y。

如果将上面的method()的定义修改一下，把self去掉，将会正确执行：

class cls:
    @decorator
    def method(x, y):
        return x + y

执行结果：

(4):  <__main__.decorator object at 0x03151630>
(1):  <__main__.decorator object at 0x03151630>
(2):  <function cls.method at 0x031B2738>
(3):  (3, 4)
7

因此参数问题必须解决。解决方案是进行判断：如果是通过实例对象触发的方法调用(即c.method())，就将外部函数通过types.MethodType()链接到这个实例对象中，否则就返回原始self(因为它指向被装饰的原始对象)。

这需要借助描述符来实现，关于这一段的解释，我觉得直接看代码自行脑部更佳。

class decorator:
    def __init__(self,func):
        wraps(func)(self)
        self.func = func
    def __call__(self, *args, **kwargs):
        return self.func(*args, **kwargs)
    def __get__(self, instance, owner):
        # 如果不是通过对象来调用的
        if instance is None:
            return self
        else:
            return types.MethodType(self, instance)

class cls:
    @decorator
    def method(self, x, y):
        return x + y

c = cls()
print(c.method(3, 4))  # 调用__get__后调用__call__

对于__wrapped__也一样可行：

class decorator():
    def __init__(self, func):
        wraps(func)(self)
    def __call__(self, *args, **kwargs):
        return self.__wrapped__(*args, **kwargs)
    def __get__(self, instance, owner):
        if instance is None:
            return self
        else:
            return types.MethodType(self, instance)

装饰时是否带参数

如果要让作为装饰器的类在装饰时带参数，就像函数装饰器带参一样decorator(x,y,z)(func)，可以将参数定义在__init__上进行处理，然后在__call__中封装一层。

class Decorator:
    def __init__(self, *args, **kwargs):
        ... do something with args ...
    def __call__(self, func):
        def wrapper(*args, **kwargs):
            return func(*args, **kwargs)
        return wrapper

和函数装饰器一样，如果想要达到下面这种既能无参装饰，又能带参装饰：

@Decorator         # 无参装饰
@Decorator(x,y,z)  # 带参装饰
@Decorator()       # 带参装饰，只不过没给参数

可以直接在__init__上进行参数有无的判断：

import types
from functools import wraps, partial

class Decorator:
    def __init__(self, func=None, arg1=1, arg2=2, arg3=3):
        # 带参装饰器
        if func is None:
            self.func = partial(Decorator, arg1=arg1, arg2=arg2, arg3=arg3)
        else:       # 无参装饰器
            wraps(func)(self)
            self.func = func

    def __call__(self, *args, **kwargs):
        return self.func(*args, **kwargs)

    def __get__(self, instance, owner):
        if instance is None:
            return self
        else:
            return types.MethodType(self, instance)

这样的限制是装饰器如果带参数时，必须使用keyword方式指定参数。例如：

# 带参装饰普通函数，使用keywords参数方式
@Decorator(arg1=1, arg2=3, arg3=5)
def func(x, y):
    return x + y

print(func(11, 22))

print('-' * 30)

# 无参装饰普通函数
@Decorator
def func1(x, y):
    return x + y

print(func1(111, 22))

print('-' * 30)

# 无参装饰方法
class cls:
    @Decorator
    def method(self, x, y):
        return x + y

c = cls()
print(c.method(3, 4))

print('-' * 30)

# 带参装饰方法
class cls1:
    @Decorator(arg1=1, arg2=3, arg3=5)
    def method(self, x, y):
        return x + y

cc = cls1()
print(cc.method(3, 4))

总结：类作为装饰器的通用格式

如果不考虑装饰时是否带参数的问题，根据上面的一大堆分析，类作为装饰器时的通用代码格式如下：

import types
from functools import wraps

class Decorator:
    def __init__(self, func):
        wraps(func)(self)
        # self.func = func

    def __call__(self, *args, **kwargs):
        # return self.func(*args, **kwargs)
        # return self.__wrapped__(*args, **kwargs)

    def __get__(self, instance, owner):
        if instance is None:
            return self
        else:
            return types.MethodType(self, instance)

至于选择self.func的方式，还是self.__wrapped__的方式，随意。

如果需要考虑装饰时带参数问题，那么参考上一小节内容。

选择类谁作为装饰器？

函数可以作为装饰器，类也可以作为装饰器。它们也都能处理处理各种需求，但是类作为装饰器的时候解释了好大一堆，非常麻烦。所以，如果可以的话，选择函数作为装饰器一般会是最佳方案。

原文地址：https://www.cnblogs.com/f-ck-need-u/p/10204617.html

时间： 2024-08-01 18:49:05

python装饰器2：进阶的相关文章

由浅入深,走进Python装饰器-----第二篇:进阶--函数装饰函数

上一篇:由浅入深,走进Python装饰器-----第一篇:基础 装饰器的使用种类: # 第一种 @函数 被装饰函数 # 第二种 @函数 被装饰类 # 第三种 @类 被装饰类 # 第四种 @函数 被装饰函数 本篇介绍第一种 @函数 被装饰函数 1.1 对带参数的原函数进行修饰 # 默认将old函数的参数传给outer里面的第一层函数 def outer(f): def inner(var): print("1 我是outer函数,接收外部传进来的old :",f) print("

5.初识python装饰器 高阶函数＋闭包＋函数嵌套＝装饰器

一.什么是装饰器? 实际上装饰器就是个函数,这个函数可以为其他函数提供附加的功能. 装饰器在给其他函数添加功能时,不会修改原函数的源代码,不会修改原函数的调用方式. 高阶函数+函数嵌套+闭包 ＝ 装饰器 1.1什么是高阶函数? 1.1.1函数接收的参数,包涵一个函数名. 1.1.2 函数的返回值是一个函数名. 其实这两个条件都很好满足,下面就是一个高阶函数的例子. def test1(): print "hamasaki ayumi" def test2(func): return t

python装饰器通俗易懂的解释！

python装饰器 刚刚接触python的装饰器,简直懵逼了,直接不懂什么意思啊有木有,自己都忘了走了多少遍Debug,查了多少遍资料,猜有点点开始明白了.总结了一下解释得比较好的,通俗易懂的来说明一下: 小P闲来无事,随便翻看自己以前写的一些函数,忽然对一个最最最基础的函数起了兴趣: 1 def sum1(): 2 sum = 1 + 2 3 print(sum) 4 sum1() 此时小P想看看这个函数执行用了多长时间,所以写了几句代码插进去了: 1 import time 2 3 def

python装饰器1

第八步:让装饰器带 类 参数 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 # -*- coding:gbk -*- '''示例8: 装饰器带类参数''' class locker:     def __init__(self):         print("locker.__init__() should be not called.")   

Python装饰器由浅入深

装饰器的功能在很多语言中都有,名字也不尽相同,其实它体现的是一种设计模式,强调的是开放封闭原则,更多的用于后期功能升级而不是编写新的代码.装饰器不光能装饰函数,也能装饰其他的对象,比如类,但通常,我们以装饰函数为例子介绍其用法.要理解在Python中装饰器的原理,需要一步一步来.本文尽量描述得浅显易懂,从最基础的内容讲起. (注:以下使用Python3.5.1环境) 一.Python的函数相关基础 第一,必须强调的是python是从上往下顺序执行的,而且碰到函数的定义代码块是不会立即执行它的,只

python 装饰器学习（decorator）

最近看到有个装饰器的例子,没看懂, #!/usr/bin/python class decorator(object): def __init__(self,f): print "initial decorator" f() def __call__(self): print "call decorator" @decorator def fun(): print "in the fun" print "after " fun

【转】九步学习python装饰器

本篇日志来自:http://www.cnblogs.com/rhcad/archive/2011/12/21/2295507.html 纯转,只字未改.只是为了学习一下装饰器.其实现在也是没有太看明白,对于装饰器我就是用的时候找例子,能蒙对,但是用过之后一段时间就忘了.还是用的少.有空应该好好看一看的,包括闭包.对于各种现代编程语言来说闭包都是很重要的.在这里先谢过原作者,如有侵权请告知. =-=-=-=-=-=-=-=-=-=-一条不怎么华丽的分隔线-=-=-=-=-=-=-=-=-=-= 这

【Python之旅】第四篇（一）：Python装饰器

有时候拿到一个程序接口,需要对其进行扩展,但是又不能修改原来接口的源代码,这时候就需要使用装饰器了. 有下面一个小程序,假如是别人提供给我们的调用接口: import time def sayHi():         time.sleep(1)         print 'Hello, I am xpleaf.' 一般情况下,如果想要计算该程序的执行时间(因为有可能要对该接口进行某些性能上的测试),就需要把以上接口修改为下面这样,同时执行一下: 程序代码: import time def s

python装饰器原理及相关操作

python装饰器,简单的说就是用于操作底层代码的代码,在不改变底层代码函数的情况下对底层代码进行验证操作等 首先,必须知,道调用func和func的区别,分别为返回函数所在的内存地址和调用该函数,输出执行结果,例如: def func(): print("欢迎光临!!!") print("返回函数所在的内存地址:",func) func() 列举一个简单的web页面调用例子 1 #做登录验证 2 def login(func): 3 print("登录成

python装饰器学习笔记

什么是python装饰器? 装饰器其实也就是一个函数,一个用来包装函数的函数,返回一个修改之后的函数对象,将其重新赋值原来的标识符,并永久丧失对原始函数对象的访问. eg:当需要在Func1和Func2中加一样的功能时,可以在outer中添加一次就可以完成全部函数的添加.装饰器与函数建立连接的方式是在函数的前一行用@+装饰器名称来完成.并且在装饰器中一定要返回被装饰的对象 def outer(fun):     def wrapper():         print '验证'