浅析python 装饰器

最新推荐文章于 2023-06-25 10:54:44 发布

AI蜗牛之家

最新推荐文章于 2023-06-25 10:54:44 发布

阅读量305

点赞数 2

分类专栏： Python

本文链接：https://blog.csdn.net/u014665013/article/details/86064025

版权

Python 专栏收录该内容

52 篇文章 2 订阅

订阅专栏

文章目录

python中的装饰器可能是入门python中的一个不小的“坑”，其实我在之前入门的时候也是这样的，把之前梳理的“凑”成一小博~

1.你为什么需要使用装饰器？

网上的一个不错的案例：
假设程序中有say_hello()和say_goodbye()两个函数。

def say_hello():
    print "hello!"
    
def say_goodbye():
    print "hello!"  # bug here

if __name__ == '__main__':
    say_hello()
    say_goodbye()

但是在实际调用中，我们发现程序出错了，上面的代码打印了两个hello。经过调试你发现是say_goodbye()出错了。老板要求调用每个方法前都要记录进入函数的名称，比如这样：

[DEBUG]: Enter say_hello()
Hello!
[DEBUG]: Enter say_goodbye()
Goodbye!

这里有几个解决方案：

#方案一
def say_hello():
    print "[DEBUG]: enter say_hello()"
    print "hello!"

def say_goodbye():
    print "[DEBUG]: enter say_goodbye()"
    print "hello!"

if __name__ == '__main__':
    say_hello()
    say_goodbye()



#方案二
def debug():
    import inspect
    caller_name = inspect.stack()[1][3]
    print "[DEBUG]: enter {}()".format(caller_name)   

def say_hello():
    debug()
    print "hello!"

def say_goodbye():
    debug()
    print "goodbye!"

if __name__ == '__main__':
    say_hello()
    say_goodbye()

这里用到了inspect包，更多详情参见：

inspect模块—检查活动对象
Python标准库inspect
python：inspect函数自动生成函数名

是不是好一点？那当然，但是每个业务函数里都要调用一下debug()函数，是不是很难受？万一老板说say相关的函数不用debug，do相关的才需要呢？

装饰器本质上是一个Python函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，装饰器的返回值也是一个函数对象。它经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等场景。装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。装饰器的作用就是为已经存在的函数或对象添加额外的功能。

2.初识装饰器

一个通俗版本的装饰器：

def debug(func):
    def wrapper():
        print "[DEBUG]: enter {}()".format(func.__name__)
        return func()
    return wrapper

def say_hello():
    print "hello!"

say_hello = debug(say_hello)  # 添加功能并保持原函数名不变

因为这样写实在不太优雅，在后面版本的Python中支持了@语法糖，下面代码等同于早期的写法。

def debug(func):
    def wrapper():
        print "[DEBUG]: enter {}()".format(func.__name__)
        return func()
    return wrapper

@debug
def say_hello():
    print "hello!"

这是最简单的装饰器，但是有一个问题，如果被装饰的函数需要传入参数，那么这个装饰器就坏了。因为返回的函数并不能接受参数，你可以指定装饰器函数wrapper接受和原函数一样的参数，比如：

def debug(func):
    def wrapper(something):  # 指定一毛一样的参数
        print "[DEBUG]: enter {}()".format(func.__name__)
        return func(something)
    return wrapper  # 返回包装过函数

@debug
def say(something):
    print "hello {}!".format(something)

这样你就解决了一个问题，但又多了N个问题。因为函数有千千万，你只管你自己的函数，别人的函数参数是什么样子，鬼知道？还好Python提供了可变参数*args和关键字参数**kwargs，有了这两个参数，装饰器就可以用于任意目标函数了。

def debug(func):
    def wrapper(*args, **kwargs):  # 指定宇宙无敌参数
        print "[DEBUG]: enter {}()".format(func.__name__)
        print 'Prepare and say...',
        return func(*args, **kwargs)
    return wrapper  # 返回

@debug
def say(something):
    print "hello {}!".format(something)

3.装饰器进阶

3.1,带参数的装饰器

假设我们前文的装饰器需要完成的功能不仅仅是能在进入某个函数后打出log信息，而且还需指定log的级别，那么装饰器就会是这样的。

def logging(level):
    def wrapper(func):
        def inner_wrapper(*args, **kwargs):
            print "[{level}]: enter function {func}()".format(
                level=level,
                func=func.__name__)
            return func(*args, **kwargs)
        return inner_wrapper
    return wrapper

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

# 如果没有使用@语法，等同于
# say = logging(level='INFO')(say)

@logging(level='DEBUG')
def do(something):
    print "do {}...".format(something)

if __name__ == '__main__':
    say('hello')
    do("my work")

3.2.基于类实现的装饰器

装饰器函数其实是这样一个接口约束，它必须接受一个callable对象作为参数，然后返回一个callable对象。在Python中一般callable对象都是函数，但也有例外。只要某个对象重载了__call__()方法，那么这个对象就是callable的。

class Test():
    def __call__(self):
        print 'call me!'

t = Test()
t()  # call me

像__call__这样前后都带下划线的方法在Python中被称为内置方法，有时候也被称为魔法方法。重载这些魔法方法一般会改变对象的内部行为。上面这个例子就让一个类对象拥有了被调用的行为。

回到装饰器上的概念上来，装饰器要求接受一个callable对象，并返回一个callable对象（不太严谨，详见后文）。那么用类来实现也是也可以的。我们可以让类的构造函数__init__()接受一个函数，然后重载__call__()并返回一个函数，也可以达到装饰器函数的效果。

class logging(object):
    def __init__(self, func):
        self.func = func

    def __call__(self, *args, **kwargs):
        print "[DEBUG]: enter function {func}()".format(
            func=self.func.__name__)
        return self.func(*args, **kwargs)
@logging
def say(something):
    print "say {}!".format(something)

3.3.带参数的类装饰器

如果需要通过类形式实现带参数的装饰器，那么会比前面的例子稍微复杂一点。那么在构造函数里接受的就不是一个函数，而是传入的参数。通过类把这些参数保存起来。然后在重载__call__方法是就需要接受一个函数并返回一个函数。

class logging(object):
    def __init__(self, level='INFO'):
        self.level = level
        
    def __call__(self, func): # 接受函数
        def wrapper(*args, **kwargs):
            print "[{level}]: enter function {func}()".format(
                level=self.level,
                func=func.__name__)
            func(*args, **kwargs)
        return wrapper  #返回函数

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

4.python内置装饰器

4.1.property

基础性描述详见：python 进阶之属性函数property
怎么使用property：
在了解这个装饰器前，你需要知道在不使用装饰器怎么写一个属性。

def getx(self):
    return self._x

def setx(self, value):
    self._x = value
    
def delx(self):
   del self._x

# create a property
x = property(getx, setx, delx, "I am doc for x property")

原理：
通常，描述符是具有“绑定行为”的对象属性，其属性访问已经被描述符协议中的方法覆盖。这些方法是__get__()、set()和__delete__()。如果一个对象定义这些方法中的任何一个，它被称为一个描述符。如果对象定义__get__()和__set__()，则它被认为是数据描述符。仅定义__get__()的描述器称为非数据描述符（它们通常用于方法，但是其他用途也是可能的）。

属性查找优先级为：

类属性
数据描述符
实例属性
非数据描述符
默认为__getattr__()

class Property(object):
    '''
    内部property是用c实现的，这里用python模拟实现property功能
    代码参考官方doc文档
    '''

    def __init__(self, fget=None, fset=None, fdel=None, doc=None):
        self.fget = fget
        self.fset = fset
        self.fdel = fdel
        self.__doc__ = doc

    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        if self.fget is None:
            raise (AttributeError, "unreadable attribute")
        print('self={},obj={},objtype={}'.format(self,obj,objtype))
        return self.fget(obj)

    def __set__(self, obj, value):
        if self.fset is None:
            raise (AttributeError, "can't set attribute")
        self.fset(obj, value)

    def __delete__(self, obj):
        if self.fdel is None:
            raise (AttributeError, "can't delete attribute")
        self.fdel(obj)

    def getter(self, fget):
        return type(self)(fget, self.fset, self.fdel, self.__doc__)

    def setter(self, fset):
        return type(self)(self.fget, fset, self.fdel, self.__doc__)

    def deleter(self, fdel):
        return type(self)(self.fget, self.fset, fdel, self.__doc__)


class Student( object ):
    @Property
    def score( self ):
        return self._score
    @score.setter
    def score( self, val ):
        if not isinstance( val, int ):
            raise ValueError( 'score must be an integer!' )
        if val > 100 or val < 0:
            raise ValueError( 'score must between 0 ~ 100!' )
        self._score = val


if __name__ == "__main__":
    s = Student()
    s.score = 60   
    s.score

属性有三个装饰器：setter, getter, deleter ，都是在property()的基础上做了一些封装，因为setter和deleter是property()的第二和第三个参数，不能直接套用@语法。getter装饰器和不带getter的属性装饰器效果是一样的，估计只是为了凑数，本身没有任何存在的意义。经过@property装饰过的函数返回的不再是一个函数，而是一个property对象。

4.2.类方法

定义：使用装饰器@classmethod。第一个参数必须是当前类对象，该参数名一般约定为“cls”，通过它来传递类的属性和方法（不能传实例的属性和方法）；

调用：实例对象和类对象都可以调用。

class ClassMethod(object):
    "python代码实现classmethod原理"
    
    def __init__(self, f):
        self.f = f
    
    def __get__(self, obj, klass=None):
        if klass is None:
            klass = type(obj)
        
        def newfunc(*args):
            return self.f(klass, *args)
        
        return newfunc
    
class E(object):
    #ClassMethod=ClassMethod(f)
    @ClassMethod
    def f(cls,x):
        return x
    
if __name__ == "__main__":
    print(E().f('classMethod Test'))

4.3.静态方法

定义：使用装饰器@staticmethod。参数随意，没有“self”和“cls”参数，但是方法体中不能使用类或实例的任何属性和方法；

调用：实例对象和类对象都可以调用。

class StaticMethod(object):
    "python代码实现staticmethod原理"
    
    def __init__(self, f):
        self.f = f
    
    def __get__(self, obj, objtype=None):
        return self.f


class E(object):
    #StaticMethod=StaticMethod(f)
    @StaticMethod
    def f( x):
        return x

if __name__ == "__main__":
    print(E.f('staticMethod Test'))

从它们的使用上来看,

@staticmethod不需要表示自身对象的self和自身类的cls参数，就跟使用函数一样。如果在@staticmethod中要调用到这个类的一些属性方法，只能直接类名.属性名或类名.方法名。
@classmethod也不需要self参数，但第一个参数需要是表示自身类的cls参数。而@classmethod因为持有cls参数，可以来调用类的属性，类的方法，实例化对象等，避免硬编码。

staticmethod 没有任何必选参数，而 classmethod 第一个参数永远是 cls， instancemethod （实例方法）第一个参数永远是 self。
需要实例化，就普通方法；不需要类实例化，但是会用到类，就用类方法；如果跟类完全没关系，就用静态方法。

静态方法和类方法比较参考

Python 静态方法和类方法的区别
[Python 实例方法、类方法、静态方法的区别与作用] (https://www.cnblogs.com/wcwnina/p/8644892.html)
@staticmethod和@classmethod的作用与区别

参考文献

AI蜗牛之家

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
浅析python 装饰器

python中的装饰器可能是入门python中的一个不小的“坑”，其实我在之前入门的时候也是这样的，把之前梳理的“凑”成一小博~1.你为什么需要使用装饰器？网上的一个不错的案例：假设程序中有say_hello()和say_goodbye()两个函数。def say_hello(): print &quot;hello!&quot; def say_goodbye(): print &quot;...
复制链接

扫一扫

专栏目录