【python 8】python 装饰器

文章目录

一、什么是 python 装饰器
二、装饰器的使用
三、装饰器类型
- 3.1 特性装饰器 @property
- 3.2 类装饰器 @classmethod
- 3.3 静态装饰器 @staticmethod
- 3.4 抽象方法装饰器 @abstractmethod

一、什么是 python 装饰器

装饰器是一个 python 的函数，可以让其他函数在不增加任何代码的情况下增加功能，也就是将其他函数“包装”起来，可以简化代码，做到代码重用。

装饰器能接收一个函数作为输入，返回值也是一个函数对象。

二、装饰器的使用

例子来源

def a_new_decorator(a_func):def wrapTheFunction():print("I am doing some boring work before executing a_func()")a_func()print("I am doing some boring work after executing a_func()")return wrapTheFunctiondef a_function_requiring_decoration():print("I am the function which needs some decoration to remove my foul smell")a_function_requiring_decoration()
#outputs: "I am the function which needs some decoration to remove my foul smell"a_function_requiring_decoration = a_new_decorator(a_function_requiring_decoration)
#now a_function_requiring_decoration is wrapped by wrapTheFunction()a_function_requiring_decoration()
#outputs:I am doing some boring work before executing a_func()
#        I am the function which needs some decoration to remove my foul smell
#        I am doing some boring work after executing a_func()

从上面这个例子可以看出，装饰器就是能把扔进他的函数做一个装饰。@符号是装饰器的语法糖，使用@符号的写法如下：

@a_new_decorator
def a_function_requiring_decoration():"""Hey you! Decorate me!"""print("I am the function which needs some decoration to ""remove my foul smell")a_function_requiring_decoration()
#outputs: I am doing some boring work before executing a_func()
#         I am the function which needs some decoration to remove my foul smell
#         I am doing some boring work after executing a_func()#the @a_new_decorator is just a short way of saying:
a_function_requiring_decoration = a_new_decorator(a_function_requiring_decoration)

我们都知道函数有一些原信息，如 docstring， _ _name _ _等，如果使用装饰器的话，原函数的元信息就会被装饰器的信息所代替，如下所示：

print(a_function_requiring_decoration.__name__)
# Output: wrapTheFunction

所以 python 提供了一个装饰器：functools.wraps，wraps 本身就是一个装饰器，能把原函数的元信息拷贝到装饰器函数中，使得装饰器函数有和原函数一样的元信息。

from functools import wrapsdef a_new_decorator(a_func):@wraps(a_func)def wrapTheFunction():print("I am doing some boring work before executing a_func()")a_func()print("I am doing some boring work after executing a_func()")return wrapTheFunction@a_new_decorator
def a_function_requiring_decoration():"""Hey yo! Decorate me!"""print("I am the function which needs some decoration to ""remove my foul smell")print(a_function_requiring_decoration.__name__)
# Output: a_function_requiring_decoration

所以，典型的蓝本如下：

from functools import wraps
def decorator_name(f):@wraps(f)def decorated(*args, **kwargs):if not can_run:return "Function will not run"return f(*args, **kwargs)return decorated@decorator_name
def func():return("Function is running")can_run = True
print(func())
# Output: Function is runningcan_run = False
print(func())
# Output: Function will not run

三、装饰器类型

常见的内置装饰器有三种：

@property
@staticmethod
@classmethod

3.1 特性装饰器 @property

@property：可以把一个方法变成其同名属性，以支持实例访问和调用

在函数前面加上 @property 后，就可以把 getter 和 setter 方法变成属性，定义 getter 方法就是一个只读属性，定义 setter 方法就是一个可读可写的。

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

# birth 是可读写属性，age 是只读属性，注意这里 birth 函数返回的是 self._birth，不能返回 self.birth
class Student(object):@propertydef birth(self):return self._birth@birth.setterdef birth(self, value):self._birth = value@propertydef age(self):return 2015 - self._birth

3.2 类装饰器 @classmethod

@classmethod ：用来指定一个类的方法为类方法，其修饰的方法不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等

传入的 cls 通常用作类方法的第一参数，对于普通的类来说，要使用的话必须先进行实例化，而在一个类中，某个函数前面加上了 classmethod 或 staticmethod，这个函数就可以不用实例化，可以直接通过类名进行调用。

class A:@classmethoddef func(cls, arg1, arg2):...

例子：

import time
class Date:def __init__(self, year, month, day):self.year = yearself.month = monthself.day = day@classmethoddef today(cls):t = time.localtime()return cls(t.tm_year, t.tm_mon, t.tm_mday)

调用：

a = Date(2020, 4, 6)
b = Date.today()

3.3 静态装饰器 @staticmethod

改变一个方法为静态方法，静态方法不需要传递隐性的第一参数，静态方法的本质类型就是一个函数。

静态方法可以直接通过类进行调用，也可以通过实例进行调用：

import time
class Date:def __init__(self,year,month,day):self.year=yearself.month=monthself.day=day@staticmethoddef now(): #用Date.now()的形式去产生实例,该实例用的是当前时间t=time.localtime() #获取结构化的时间格式return Date(t.tm_year,t.tm_mon,t.tm_mday) #新建实例并且返回@staticmethoddef tomorrow():#用Date.tomorrow()的形式去产生实例,该实例用的是明天的时间t=time.localtime(time.time()+86400)return Date(t.tm_year,t.tm_mon,t.tm_mday)

a = Data(2020, 4, 6)
print(a.year, a.month, a.day)
# 静态方法无需实例化
b = Data.now()
print(b.year, b.month, b.day)
c = Data.tomorrow
print(c.year, c.month, c.day)
# 静态方法也可实例化后调用
a.now()

3.4 抽象方法装饰器 @abstractmethod

抽象方法表示基类的中一个方法，在基类中没有实现，所以不能被实例化，在子类中实现了以后才能被实例化，继承了含有抽象方法基类类的子类必须复写所有的抽象方法，未被 @abstractmethod 修饰的可以不重写。

abstractmethod 的好处在哪里：

可以把某个方法装饰成抽象的方法，类似于接口，可以用具有同一属性的对象实现同一个抽象的方法，这样无论是维护还是从代码结构来说，都比较清晰。

from abc import ABC, abstractmethod
class a(ABC):@abstractmethoddef writeblog(self):pass
class b(a):def writeblog(self):print('writing blogs')if __name__=='__main__':# 使用如下的方法会报错，因为被抽象装饰器装饰的方法需要不能直接实例化c = a()# 可以让 b 继承 a，然后在 b 里边重写被装饰的 writeblog 的方法，然后实例化 bc = b()c.writeblog() # output 'writing blogs'