python装饰器总结

最新推荐文章于 2021-10-13 16:38:45 发布
最新推荐文章于 2021-10-13 16:38:45 发布
阅读量134 收藏
点赞数
分类专栏： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SXxtyz/article/details/115497079
版权
装饰器的使用方法

装饰器是什么？当程序函数写好之后业务做了修改，此时需要更改原来的函数。为了简化此操作，即不再改变原函数，python提供了装饰器机制。

同时也可以避免大量的代码重复，例如有三个函数f1,f2,f3分别需要计算三个函数的执行时间，如下所示：

from time import time, sleep
def f2():
    start = time()
    for i in range(100):
        eval('1 + 1 * 2')
    sleep(1)
    end = time()
    print(f'f2执行时间为{end - start}')


def f3():
    start = time()
    for i in range(50):
        eval('2 + 1 / 3')
    sleep(3)
    end = time()
    print(f'f3执行时间为{end - start}')


def f4():
    start = time()
    for i in range(25):
        eval('4 + 1 + 5')
    sleep(2)
    end = time()
    print(f'f4执行时间为{end - start}')


if __name__ == '__main__':
    f2()
    f3()
    f4()

需要将代码段

start = time()
...
end = time()
print(f'执行时间为{end - start}')

写三次，当函数很多时，显然会降低编码效率，因此我们引入了装饰器，顾名思义，就是对一个函数进行“装饰”。

无参数的装饰器
# coding=utf-8


def decorate(func):
    def wrapper():
        print(f'函数{func.__name__}开始执行...')
        func()
        print(f'函数{func.__name__}执行完毕')
    return wrapper


@decorate
def f1():
    print('计算1+1的结果')


@decorate
def f2():
    print('计算2+2的结果')


f1()
f2()

在函数f1执行时，会把f1函数作为参数传到装饰器decorate中，然后返回decorate中的函数wrapper，实际执行的是wrapper函数（wrapper函数中的func函数会执行f1函数）

以上代码的输出结果为：

函数f1开始执行...
计算1+1的结果
函数f1执行完毕
函数f2开始执行...
计算2+2的结果
函数f2执行完毕

到此，我们可以通过装饰器修改以上计算运行时间的代码段

# coding=utf-8
from time import time, sleep


def decorate(func):
    def wrapper():
        start = time()
        func()
        end = time()
        print(f'{func.__name__}执行时间为{end - start}')
    return wrapper


@decorate
def f2():
    for i in range(100):
        eval('1 + 1 * 2')
    sleep(1)


@decorate
def f3():
    for i in range(50):
        eval('2 + 1 / 3')
    sleep(3)


@decorate
def f4():
    for i in range(25):
        eval('4 + 1 + 5')
    sleep(2)


if __name__ == '__main__':
    f2()
    f3()
    f4()

以上代码的执行结果依然为：

f2执行时间为1.0111098289489746
f3执行时间为3.00311541557312
f4执行时间为2.0160653591156006
带固定参数函数的装饰器
# coding=utf-8
def decorate(func):
    def wrapper(number):
        print(f'{func.__name__}函数开始执行...')
        func(number)
        print(f'number的值为{number}')
        print(f'{func.__name__}函数运行结束\n')
    return wrapper


@decorate
def f1(number):
    print(f'计算{number}+{number}的值...')


@decorate
def f2(number):
    print(f'计算{number}*{number}+{number}的值...')


f1(1)
f2(2)

输出结果为

f1函数开始执行...
计算1+1的值...
number的值为1
f1函数运行结束

f2函数开始执行...
计算2*2+2的值...
number的值为2
f2函数运行结束
带不定参数函数的装饰器
# coding=utf-8
def decorate(func):
    def wrapper(*args, **kwargs):
        print(f'{func.__name__}函数开始执行...')
        func(*args, **kwargs)
        print(f'{func.__name__}函数运行结束\n')
    return wrapper


@decorate
def f1(number1, number2):
    print(f'计算{number1}+{number2}的值...')


@decorate
def f2(number1, number2, number3):
    print(f'计算{number1}*{number2}+{number3}的值...')


f1(1, 2)
f2(2, 3, 4)

输出结果为

f1函数开始执行...
计算1+2的值...
f1函数运行结束

f2函数开始执行...
计算2*3+4的值...
f2函数运行结束
带参数的装饰器
# coding=utf-8


def decorate(style):
    def wrapper(func):
        def wrapped(*args, **kwargs):
            print(f"装饰器的参数为{style}")
            print(f"{func.__name__}函数开始执行...")
            func(*args, **kwargs)
            print(f'{func.__name__}函数执行完毕\n')
        return wrapped
    return wrapper


@decorate(style='invis')
def f1(num, cnt):
    print(f"num={num}, cnt={cnt}")


@decorate(style='bold')
def f2(x, y, z):
    print(f"x={x}, y={y}, z={z}")


f1(1, 2)
f2(3, 4, 5)

输出结果为

装饰器的参数为invis
f1函数开始执行...
num=1, cnt=2
f1函数执行完毕

装饰器的参数为bold
f2函数开始执行...
x=3, y=4, z=5
f2函数执行完毕
类作为装饰器

类作为装饰器时要实现类的__init__方法和__call__方法

不带参数

不带参数的装饰器中的__init__方法要传入函数

# coding=utf-8


class Decorate:

    def __init__(self, func):
        self.func = func

    def __call__(self, *args, **kwargs):
        print(f'{self.func.__name__}函数开始执行...')
        self.func(*args, **kwargs)
        print(f'{self.func.__name__}函数执行完毕\n')


@Decorate
def f1(x, y):
    print(f"x={x}, y={y}")


@Decorate
def f2(x, y, z):
    print(f'x={x}, y={y}, z={z}')


f1(1, 2)
f2(3, 4, 5)

输出结果为

f1函数开始执行...
x=1, y=2
f1函数执行完毕

f2函数开始执行...
x=3, y=4, z=5
f2函数执行完毕
带参数

带参数的装饰器中的__init__方法传入参数，__call__方法传入函数

# coding=utf-8


class Decorate:

    def __init__(self, style):
        self.style = style

    def __call__(self, func):
        def wrapper(*args, **kwargs):
            print(f'装饰器参数值为{self.style}')
            print(f'{func.__name__}函数开始执行...')
            func(*args, **kwargs)
            print(f'{func.__name__}函数执行完毕\n')
        return wrapper


@Decorate(style='invis')
def f1(x, y):
    print(f"x={x}, y={y}")


@Decorate(style='bold')
def f2(x, y, z):
    print(f'x={x}, y={y}, z={z}')


f1(1, 2)
f2(3, 4, 5)

输出结果为

装饰器参数值为invis
f1函数开始执行...
x=1, y=2
f1函数执行完毕

装饰器参数值为bold
f2函数开始执行...
x=3, y=4, z=5
f2函数执行完毕
类内的成员函数作为类内函数的装饰器使用
# coding=utf-8


class Test:

    def __init__(self, num):
        self.num = num

    def decorate(func):
        def wrapper(self, *args, **kwargs):
            print(f'{func.__name__}函数开始执行...')
            func(self, *args, **kwargs)
            print(f'{func.__name__}函数执行完毕\n')
        return wrapper

    @decorate
    def standard_output(self, x, y, z):
        print(f'x={x}, y={y}, z={z}')


s = Test(2)
s.standard_output(3, 4, 5)

输出结果为

standard_output函数开始执行...
x=3, y=4, z=5
standard_output函数执行完毕
类的成员函数作为类外函数的装饰器
# coding=utf-8


class Test:

    def __init__(self, num):
        self.num = num

    def decorate(func):
        def wrapper(*args, **kwargs):
            print(f'{func.__name__}函数开始执行...')
            func(*args, **kwargs)
            print(f'{func.__name__}函数执行完毕\n')
        return wrapper


@Test.decorate
def standard_output(x, y, z):
    print(f'x={x}, y={y}, z={z}')


standard_output(3, 4, 5)

输出结果为

standard_output函数开始执行...
x=3, y=4, z=5
standard_output函数执行完毕
python内置装饰器
property和setter,deleter

先看这么一个例子

# coding=utf-8


class Student:
    
    def __init__(self, name, sex):
        self.name = name
        self.sex = sex
        self.info = f'姓名:{self.name}, 性别:{self.sex}'

    def modify_sex(self):
        self.sex = '男'


s = Student(name='刘能', sex='女')
print(s.info)
s.modify_sex()  # 此时性别变为男
print(s.info)   # 性别输出仍为女

输出结果为

姓名:刘能, 性别:女
姓名:刘能, 性别:女

虽然改变了性别，但是因为没有改变info，此时输出结果不会变

当然，可以采用下列方法，在修改sex的同时修改info

def modify_sex(self):
    self.sex = '男'
    self.info = f'姓名:{self.name}, 性别:{self.sex}'

但是程序已经成形时，在每一地方添加以上代码会耗费大量的时间，

因此我们可以把一个成员方法看作是一个变量，即使用property装饰器

# coding=utf-8


class Student:

    def __init__(self, name, sex):
        self.name = name
        self.sex = sex
        #self.info = f'姓名:{self.name}, 性别:{self.sex}'

    def modify_sex(self):
        self.sex = '男'

    @property
    def info(self):
        return f'姓名:{self.name}, 性别:{self.sex}'


s = Student(name='刘能', sex='女')
print(s.info)
s.modify_sex()
print(s.info)

输出结果为

姓名:刘能, 性别:女
姓名:刘能, 性别:男

显然，这种方法是只读的，即不能根据info函数修改对象的成员变量，所以我们可以引入setter装饰器

# coding=utf-8


class Student:

    def __init__(self, name, sex):
        self.name = name
        self.sex = sex
        self._info = f'姓名:{self.name}, 性别:{self.sex}'

    @property
    def info(self):
        return self._info

    @info.setter
    def info(self, student_info):
        if not isinstance(student_info, str):
            raise TypeError('类型错误')
        self._info = student_info


s = Student(name='刘能', sex='女')
print(s.info)
s.info = '姓名: 刘不能, 性别: 未知'
print(s.info)

输出结果为

姓名:刘能, 性别:女
姓名: 刘不能, 性别: 未知
staticmethod装饰器

staticmethod方法一般其参数与类本身、类对象无关，通过类名或者对象名调用即可

# coding=utf-8


class Dog:

    num = 0

    def __init__(self, name='lisa'):
        self.name = name
        Dog.num += 1

    @staticmethod
    def print_num():
        print(f'num={Dog.num}')

    def __del__(self):
        Dog.num -= 1


a = Dog()
b = Dog()
a.print_num()
del a
Dog.print_num()

输出结果为

num=2
num=1
classmethod装饰器

classmethod是类的方法，因为python不像c++一样可以重载，则可以用classmethod装饰器实现重载，类似于普通类方法中的self，classmethod中有关键字cls

# coding=utf-8


class Time:

    def __init__(self, second, minute, hour):
        self.second = second
        self.minute = minute
        self.hour = hour

    @classmethod
    def from_string(cls, s):
        second, minute, hour = list(map(eval, s.split(':')[:3]))
        return cls(second, minute, hour)

    @classmethod
    def from_default(cls):
        return cls(0, 0, 0)

    def __str__(self):
        return '%02d:%02d:%02d' % (self.hour, self.minute, self.second)


a = Time(11, 22, 12)
print(a)
b = Time.from_default()
print(b)
c = Time.from_string('59:59:23')
print(c)

输出结果为

12:22:11
00:00:00
23:59:59
SXxtyz
关注
专栏目录
python 静态方法 类方法 的作用_python中的静态方法和类方法
weixin_39707201的博客
11-23 1880
静态方法和类方法在python2.2中被引用，经典类和新式类都可以使用。同时，一对内建函数：staticmethod和classmethod被引入，用来转化类中某一方法为这两种方法之一。静态方法：静态方法是类中的函数，不需要实例。静态方法主要是用来存放逻辑性的代码，主要是一些逻辑属于类，但是和类本身没有交互，即在静态方法中，不会涉及到类中的方法和属性的操作。可以理解为将静态方法存在此类的名称空间中...
Python装饰器总结
qq_39655563的博客
09-09 212
装饰器（Decorators）是在不改变函数接口的情况下修改其他函数功能的函数。用一个装饰器类来完整解释装饰器。
Python 面向对象 Time类的定义 python
qq_43618642的博客
11-08 3388
acm A - 2-2 Time类的定义 python 下面展示一些 内联代码片。 // A code block var foo = 'bar'; class Time: def __init__(self): self.__h = 12 self.__m = 0 self.__s = 0 def setHour(self,h): if h > 12 or h < 0: self.__h
Java学习
记录一些工作日常和学习
10-12 585
使用 final 声明变量时，要求全部的字母大写 final 修饰类 表示该类是无法被任何其他类继承的，意味着此类在一个继承树中是一个叶子类，并且此类的设计已被认为很完美而不需要进行修改或扩展 使用 main() 方法时应该注意如下几点： 1访问控制权限是公有的（public） 2main() 方法是静态的。如果要在 main() 方法中调用本类中的其他方法，则该方法也必须是静态的，否则需要先创建本类的实例对象，然后再通过对象调用成员方法 3main() 方法没有返回值，只能使用 void 4.
python学习第二天
dddd97的博客
06-01 301
2021年6月1日 主要学习类的知识，也就是所谓的分装，通过以下两个例题加以学习，首先是时钟的一个分装类，然后是一个点运动的分装类。 《时钟》 import time class Clock: def __init__(self,hour=0,minute=0,second=0): self.hour=hour self.minute=minute self.second=second def run(self): self.s
python练习题12
lilianggui的博客
01-03 238
定义一个类描述数字时钟 from time import sleep class Clock(object): def __init__(self, hour, minute, second): self.hour = hour self.minute = minute self.second = second def run(self): self.second += 1 if self.second
Python装饰器的应用场景代码总结
09-17
Python装饰器是Python语言中的一个重要特性，它允许我们修改或增强已有函数的功能，而不必直接修改函数源代码。装饰器本质上是一个接收函数作为参数并返回新函数的高阶函数。以下是一些装饰器在实际应用中的常见场景...
类的成员
cnmeimei的博客
08-06 1414
一. 细分类的组成成员 之前咱们讲过类大致分两块区域，如下图所示： 每个区域详细划分又可以分为： class A: company_name = '老男孩教育' # 静态变量(静态字段) __iphone = '1353333xxxx' # 私有静态变量(私有静态字段) def __init__(self,name,age): #特殊方法 self.name = name #对象属性(普通字段) self.__age = age #.
http://mail.163.com/help/help_spam_16.htm?ip=118.186.207.7&hostid=smtp5&time=1358341921
热门推荐
云计算?
01-16 73万+
0INRMumLsiQwT0xVgvYVmNCBWS7mV8LzSeLOZGHzflL3ziBSx+iej3G1syAeYvPZxqagQ0P7mgdX /qgnEWWuIcv4cTR6ZI5QNmqULAGtRkCtCNsphAD7cLBiV7UpV7yvURpKw6H8jHyDDZc8zP5P8QF9 abbRoeoTcPcDs/Ij0+JSX9fkdkqCvmUFYzy/GBb+hMWJ...
各音视频格式文件下载地址清单分享
mandagod的博客
12-29 2万+
https://samples.mplayerhq.hu/allsamples.txt https://samples.mplayerhq.hu/A-codecs/AC3/Broadway-5.1-48khz-448kbit.ac3 . ./00-README ./3D ./3D/00001-2.MTS ./3D/00001-2.MTS.txt ./3D/00001
python---封装对象实现时间效果
WGS.
03-20 303
# 钟表 import time class Clock(): def __init__(self, hour, minute, second): # 时 分 秒 self.hour = hour self.minute = minute self.second = second @classmethod def now...
python基础练习11
ForsetiRe的博客
02-28 655
以下练习必须用面向对象的方式完成。 初级 1.刘凯买了一台玫瑰红iphone10，价值8000元，可以打电话、玩游戏。 2.写一个计算器类，可以进行加、减、乘、除计算。 3.设计两个类： 一个点类，属性包括x，y坐标。 一个Rectangle类（矩形） ,属性有左上角和右下角的坐标，可以计算矩形的面积；可以判断点是否在正方形内。 实例化一个点，一个正方形，输出正方形的面积，输出点是否在正方形内。 ...
python定义时钟类并且实现简单的时钟的功能
Xu_Mingyong的博客
10-13 537
定义时钟类并且实现简单的时钟的功能 import os import time from datetime import datetime class Clock: def __init__(self): self.hour = datetime.now().hour self.minute = datetime.now().minute self.second = datetime.now().second def show_time
Python继承
weixin_44799030的博客
11-22 171
面向对象三大特征：封装、继承、多态 1.继承 面向对象编程 (OOP) 语言的一个主要功能就是“继承”，所谓继承就是使现有的类无需编码便可以拥有原有类的方法和属性。 被继承的类可以称之为***父类、基类、超类***。继承的类可以称之为***子类、派生类***。派生和继承是一体两面，从父类向子类看就是派生，从子类向父类看就是继承。子类和父类的关系可以用“is a”类表示，即子类是父类的一种，是一个更具体、更加强大的父类。python支持单继承和多继承。 继承的优点： 可以简化代码，减少冗余度 提高了代码的可
Python基础知识个人总结
weixin_43580438的博客
10-09 1284
Python函数
【python学习笔记】task08 模块与datetime模块
一一xi的博客
08-07 278
【python学习笔记】task08 模块与datetime模块模块1.什么是模块2.命名空间3.导入模块4.if __name__ == '__main__'5.搜索路径6. 包（package）相关资料练习题datetime模块1.datetime类2.data类3.time类4. timedelta类练习题 模块 模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数等功能。这也是使用 Python 标准库的方法 1.什么是模块 容器 -&gt
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值