Python 简明教程

Python - Decorators

Python 中的装饰器是一个接收另一个函数作为参数的函数。装饰器要装饰的参数函数。装饰器扩展了参数函数的行为，而不会实际修改它。

在本章中，我们 whall 将学习如何使用 Python 装饰器。

Defining Function Decorator

Function in Python 是一个一阶对象。这意味着它可以作为参数传递给另一个函数，就像其他 data types （例如数字、字符串或列表等）。还可以在另一个函数中定义一个函数。这样的函数称为嵌套函数。此外，函数还可以返回其他函数。

装饰器函数的典型定义如下 −

def decorator(arg_function): #arg_function to be decorated
   def nested_function():
      #this wraps the arg_function and extends its behaviour
      #call arg_function
      arg_function()
   return nested_function

此处为一个普通的 Python 函数 −

def function():
   print ("hello")

你现在可以通过将该函数传递给装饰器来装饰它以扩展其行为 −

function=decorator(function)

如果现在执行此函数，它将显示装饰器扩展的输出。

Examples of Python Decorators

练习以下示例来理解 Python 装饰器的概念 −

Example 1

以下代码是装饰器的简单示例 −

def my_function(x):
   print("The number is=",x)

def my_decorator(some_function,num):
   def wrapper(num):
      print("Inside wrapper to check odd/even")
      if num%2 == 0:
         ret= "Even"
      else:
         ret= "Odd!"
      some_function(num)
      return ret
   print ("wrapper function is called")
   return wrapper

no=10
my_function = my_decorator(my_function, no)
print ("It is ",my_function(no))

my_function() 刚输出接收到的数字。但是，通过将它传递给 my_decorator 来修改其行为。内部函数接收数字并返回它是奇数/偶数。上面代码的输出为 −

wrapper function is called
Inside wrapper to check odd/even
The number is= 10
It is Even

Example 2

装饰函数的一种优雅方式是在其定义之前只提一下装饰器名前面加上 @ 符号。上面的例子使用这种符号重写了 −

def my_decorator(some_function):
   def wrapper(num):
      print("Inside wrapper to check odd/even")
      if num%2 == 0:
         ret= "Even"
      else:
         ret= "Odd!"
      some_function(num)
      return ret
   print ("wrapper function is called")
   return wrapper

@my_decorator
def my_function(x):
   print("The number is=",x)
no=10
print ("It is ",my_function(no))

Python 的标准库定义了以下内置装饰器 −

@classmethod Decorator

classmethod 是一个内置函数。它将方法转换为类方法。类方法不同于实例方法。在类中定义的实例方法由其对象调用。该方法接收由 self 引用的隐式对象。另一方面，类方法隐式地将类本身作为第一个参数接收。

Syntax

为了声明类方法，使用了以下装饰器符号 −

class Myclass:
   @classmethod
   def mymethod(cls):
   #....

@classmethod 表单是前面描述的函数装饰器的形式。mymethod 接收对类的引用。它可以由类及其对象调用。这意味着 Myclass.mymethod 和 Myclass().mymethod 都是有效的调用。

Example of @classmethod Decorator

让我们在以下示例的帮助下了解类方法的行为−

class counter:
   count=0
   def __init__(self):
      print ("init called by ", self)
      counter.count=counter.count+1
      print ("count=",counter.count)
   @classmethod
   def showcount(cls):
      print ("called by ",cls)
      print ("count=",cls.count)

c1=counter()
c2=counter()
print ("class method called by object")
c1.showcount()
print ("class method called by class")
counter.showcount()

在类定义中 count 是一个类属性。 init () 方法是构造器，显然是实例方法，因为它接收了 self 作为对象引用。声明的每个对象都会调用此方法，并将计数增加 1。

@classmethod 装饰器将 showcount() 方法转换为类方法，该方法接收对该类的引用作为参数，即使它是由其对象调用的。即使当 c1 对象调用 showcount 时，它也会显示 counter 类的引用。

它将显示以下内容 output −

init called by <__main__.counter object at 0x000001D32DB4F0F0>
count= 1
init called by <__main__.counter object at 0x000001D32DAC8710>
count= 2
class method called by object
called by <class '__main__.counter'>
count= 2
class method called by class
called by <class '__main__.counter'>

@staticmethod Decorator

staticmethod 也是 Python 标准库中的一个内置函数。它会将一个方法转换为一个静态方法。即使是通过类或类的实例调用的，静态方法也不接受任何引用参数。以下是在类中声明静态方法的符号说明−

Syntax

class Myclass:
@staticmethod
def mymethod():
#....

即使 Myclass.mymethod 和 Myclass().mymethod 都是有效的调用，但静态方法都不会接收到对 two 的引用。

Example of @staticmethod Decorator

counter 类进行修改如下−

class counter:
   count=0
   def __init__(self):
      print ("init called by ", self)
      counter.count=counter.count+1
      print ("count=",counter.count)
   @staticmethod
   def showcount():
      print ("count=",counter.count)

c1=counter()
c2=counter()
print ("class method called by object")
c1.showcount()
print ("class method called by class")
counter.showcount()

和以前一样，类属性 count 在 init () 方法中声明每个对象后增加。但是，由于 mymethod() 是一个静态方法，它既不接受 self 参数也不接受 cls 参数。因此，显示类属性 count 的值时，必须显式引用 counter。

以上代码的 output 如下−

init called by <__main__.counter object at 0x000002512EDCF0B8>
count= 1
init called by <__main__.counter object at 0x000002512ED48668>
count= 2
class method called by object
count= 2
class method called by class
count= 2

@property Decorator

Python 的 property() 内置函数是用于访问类的实例变量的一个接口。@property 装饰器将实例方法转换为同名只读属性的“getter”（获得器），并且它将此属性的文档字符串设置为“获取实例变量的当前值”。

您可以使用以下三个装饰器来定义属性−

  1. @property − 将方法声明为属性。

  2. @&lt;property-name&gt;.setter: − 指定用于将值设置为属性的属性的 setter（设定器）方法。

  3. @&lt;property-name&gt;.deleter − 指定用于删除属性的属性的 delete（删除器）方法。

property() 函数返回的属性对象具有 getter、setter 和 delete 方法。

property(fget=None, fset=None, fdel=None, doc=None)

fget 参数是 getter 方法，fset 是 setter 方法。它还可以选择性地使用 fdel 作为删除对象的方法，而 doc 是文档字符串。

Syntax

还可以使用以下语法为 property() 对象的 setter 和 getter 赋值。

speed = property()
speed=speed.getter(speed, get_speed)
speed=speed.setter(speed, set_speed)

其中 get_speed() 和 set_speeds() 是在 Car 类中检索和设置实例变量 speed 的值的方法。

可以通过 @property 装饰器实现上述语句。使用装饰器后，重新编写的 car 类如下−

Example of @property Decorator

class car:
   def __init__(self, speed=40):
      self._speed=speed
      return
   @property
   def speed(self):
      return self._speed
   @speed.setter
   def speed(self, speed):
      if speed<0 or speed>100:
         print ("speed limit 0 to 100")
         return
      self._speed=speed
      return

c1=car()
print (c1.speed) #calls getter
c1.speed=60 #calls setter

属性装饰器是一种非常方便且推荐的实例属性处理方法。