Python的@装饰器的作用小结

我们在编程过程中，常常会遇到这种需求：

比如，我想开发一款计算器，我已经写好了一堆函数，用于执行各种计算，那么我们需要在执行各种计算函数前，首先对输入的数据进行检查，确保他们必须得是数值才允许执行函数，而不能是字符串；

又如，我想编写一个用于计算三角形周长、面积、某个角角度的模块，已经写好几个函数用于计算，那么，在执行计算前，首先要确保输入的三条边长能够构成三角形，再进行计算才有意义；

再比如，我想开发某款网络应用，写了一些函数用于实现用户的某些操作，那么，得要先检查确认该用户已经登录了，才允许执行这些操作。

这些需求，归纳起来，就是，在执行主函数之前，常常要先执行某个预函数，进行一些校验之类的操作。

这类需求是非常常见的，也是保证程序完整性、健壮性的重要举措。所以，怎么做才比较简单呢？

你会说，这很简单啊，在每个函数里面写上if语句不就得了。就拿那个计算器而言，如果我们要写加减乘除，我们可以这样：

def plus(a,b):
    if type(a)==type(0) and type(b)==type(0): #假设该计算器只能计算整数，如果要计算小数再or type(0.0)
        return a+b
    else:
        print('Type must be number') #检测到数据类型不对，先输出报警，函数值返回None
        return None

def minus(a,b):
    if type(a)==type(0) and type(b)==type(0):
        return a-b
    else:
        print('Type must be number')
        return None

def multiply(a,b):
    if type(a)==type(0) and type(b)==type(0):
        return a*b
    else:
        print('Type must be number')
        return None

def divide(a,b):
    if type(a)==type(0) and type(b)==type(0):
        return a/b
    else:
        print('Type must be number')
        return None

这个嘛，直接暴力。但是呢，这里只有4个函数，假如你开发的计算器有几十几百个函数，每个函数都要套上if语句，这不得麻烦死了，不烦死也啰嗦死了。

所以怎么弄简单一点呢？聪明的你肯定想到了，我们可以把那个判断if也单独定义一个函数，然后把计算用的函数套在里面，就像这样：

def check(a,b,func): #定义检查函数，变量为待检测参数a,b和检测通过后执行的函数func
    if type(a)==type(0) and type(b)==type(0):
        return func(a,b)
    else:
        print('Type must be number')
        return None

def plus(a,b):
    return a+b

def minus(a,b):
    return a-b
...

#主程序
check(1,2,plus) #计算1+2
check(1,2,minus) #计算1-2
check(1,2,multiply) #计算1*2
check(1,2,divide) #计算1/2

这里面有一点一定要特别注意，主程序的check(1,2,plus) 是把plus函数本身作为变量传递给check，由check函数决定如何执行plus函数，此处不能写成check(1,2,plus(1,2))，plus不能带参数和括号，不是执行plus()后把结果传给check。

这么写程序简洁了不少，加减乘除函数只需要定义他们本身的运算就可以了，变量检测交给了check函数。这么写也是比较容易理解的。

但是对于使用该程序的用户来说，就不是这么回事了，他们会觉得这么写非常难看。

为什么呢？我是要拿程序做加减乘除计算的，但我不论计算什么，每次都是在主调用check这个函数！

那有没有什么办法，可以既好看，又简洁呢？装饰器就是起到了这个神奇的作用。

上面这个需求，用装饰器可以这么写：

def check(func):
    ...

@check
def plus(a,b):
    return a+b

@check
def minus(a,b):
    return a-b

...

#主程序
plus(1,2) #计算1+2
minus(1,2) #计算1-2
...

先直观感受一下，通过@check，check函数就被“注入”到了plus函数中，使得plus函数拥有了参数检测的功能。这样，在主程序中，若要计算加法就可直接调用plus，便可先校验再计算。

那么，这个装饰器check要怎么定义呢？我们来看一下。

def check(func): #定义装饰器check
    def newfunc(a,b): #定义函数模板，即如何处理func
        if type(a)==type(0) and type(b)==type(0):
            return func(a,b)
        else:
            print('Type must be number!')
            return None
    return newfunc #将处理后的func作为新函数newfunc输出

@check
def plus(a,b):
    return a+b

#主程序，计算1+2
plus(1,2)

我们可以看到，当装饰器@check作用于plus函数时，plus函数本身作为参数func传入装饰器中。在装饰器check的定义内部，定义了一个函数模板，描述了对输入的func如何处理。可以看到，newfunc对func（也就是输入的plus）套用了判断数据类型的if语句，最后，再将套好的newfunc输出，替代原来的func。这样，此时执行func就是在执行newfunc，执行plus就是在执行套上if语句的新函数。

所以，通过装饰器，添加上了判断语句的新函数替换了原来的plus函数，但仍通过plus这个函数名调用，所以看起来就是plus函数被“装饰”了。

当然了，如果大家在网络上搜索，关于如何定义装饰器，看到的是一个更加规范的版本。看起来更难理解一些，但其实是一样的：

def checkall(func):
    def wrapper(*args,**kwargs):
        if type(args[0])==type(0) and type(args[1])==type(0):
            return func(*args,**kwargs)
        else:
            print('Type must be number!')
            return None
    return wrapper

模板函数一般习惯用wrapper来表示，这个没啥，建议大家都这么写，规范一些。

参数一般用不定长的*args,**kwargs来表示，这个可能有些人就困惑了。因为被装饰的函数可能有很多种，参数的个数一般也不确定。然后*args,**kwargs是什么东西？args，kwargs这两个形参英文字母是什么无所谓可以自己定，关键是前面的单星号*和双星号**。

假如我定义一个函数，不能确定参数有多少个，例如要对输入的一组数字做连加操作。那么就可以定义plus(*x)，当调用该函数时，若输入多个变量plus(1,2,3)，那么就会把输入的变量组合成一个元祖x=(1,2,3)输入。定义双星号plus(**x)的意思是，调用该函数时若写出形参变量plus(a=1,b=2,c=3)，那么输入变量就会组合成字典x={a:1,b:2,c:3}传入函数。

当然也可以反向操作，定义函数的时候参数个数是明确的plus(a,b,c)，那么调用该函数时，加上星号plus(*(1,2,3))，就是对输入元祖(1,2,3)执行炸开操作，转换为plus(1,2,3)输入。

装饰器里这么写有什么用呢？我们仔细观察一下我们之前写的newfunc(a,b)，那就意味着，指明了新函数有两个参数a,b，假如被装饰的原函数有三个参数怎么办呢？不就没用了吗？

我们来看别人写的，定义时用了wrapper(*args,**kwargs)，即不管有多少个参数，打包输入wrapper。在wrapper当中，调用原函数时又func(*args,**kwargs)，即把输入的元祖解包再传入func。这么一打包一解包，虽然看起来啥都没干，但确适应了函数参数不确定的情况，使得该装饰器可以装饰多种参数数量不同的函数。

就先这样吧。

到此这篇关于Python的@装饰器是干什么用的？的文章就介绍到这了,更多相关Python @装饰器内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

赞 (0)

相关推荐

  • 介绍Python的@property装饰器的用法

    在绑定属性时,如果我们直接把属性暴露出去,虽然写起来很简单,但是,没办法检查参数,导致可以把成绩随便改: s = Student() s.score = 9999 这显然不合逻辑.为了限制score的范围,可以通过一个set_score()方法来设置成绩,再通过一个get_score()来获取成绩,这样,在set_score()方法里,就可以检查参数: class Student(object): def get_score(self): return self._score def set_s

  • Python 中@lazyprop 装饰器的用法

    安装 pip install lazyprop 例子1 from lazyprop import lazyprop class Foo(object): def __init__(self): self.load_count = 0 @lazyprop def lazy(self): self.load_count += 1 f = Foo() f.lazy f.lazy f.lazy print(f.load_count) 输出: 1 例子2 from lazyprop import lazy

  • Python黑魔法@property装饰器的使用技巧解析

    @property有什么用呢?表面看来,就是将一个方法用属性的方式来访问. 上代码,代码最清晰了. class Circle(object): def __init__(self, radius): self.radius = radius @property def area(self): return 3.14 * self.radius ** 2 c = Circle(4) print c.radius print c.area 可以看到,area虽然是定义成一个方法的形式,但是加上@pr

  • Python @property装饰器原理解析

    这篇文章主要介绍了Python @property装饰器原理解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 1.通过@property装饰器,可以直接通过方法名来访问方法,不需要在方法名后添加一对"()"小括号. class Person: def __init__(self, name): self.__name = name @property def say(self): return self.__name xioabai

  • Python Pytest装饰器@pytest.mark.parametrize详解

    Pytest中装饰器@pytest.mark.parametrize('参数名',list)可以实现测试用例参数化,类似DDT 如:@pytest.mark.parametrize('请求方式,接口地址,传参,预期结果',[('get','www.baidu.com','{"page":1}','{"code":0,"msg":"成功"})',('post','www.baidu.com','{"page"

  • 详解Python装饰器之@property

    一.property() 函数讲解 了解 @property 装饰器之前,我们首先要了解内置函数的 property(). class property(fget=None, fset=None, fdel=None, doc=None) 描述: 返回 property 属性. 参数说明: fget -- 获取属性值的函数. fset -- 设置属性值的函数. fdel -- 删除属性值函数. doc -- property 属性的文档字符串,如果没有给出 doc,则该 property 将拷贝

  • 实例讲解Python编程中@property装饰器的用法

    取值和赋值 class Actress(): def __init__(self): self.name = 'TianXin' self.age = 5 类Actress中有两个成员变量name和age.在外部对类的成员变量的操作,主要包括取值和赋值.简单的取值操作是x=object.var,简单的赋值操作是object.var=value. >>> actress = Actress() >>> actress.name #取值操作 'TianXin' >&g

  • Python的@装饰器的作用小结

    我们在编程过程中,常常会遇到这种需求: 比如,我想开发一款计算器,我已经写好了一堆函数,用于执行各种计算,那么我们需要在执行各种计算函数前,首先对输入的数据进行检查,确保他们必须得是数值才允许执行函数,而不能是字符串: 又如,我想编写一个用于计算三角形周长.面积.某个角角度的模块,已经写好几个函数用于计算,那么,在执行计算前,首先要确保输入的三条边长能够构成三角形,再进行计算才有意义: 再比如,我想开发某款网络应用,写了一些函数用于实现用户的某些操作,那么,得要先检查确认该用户已经登录了,才允许

  • 理解python中装饰器的作用

    装饰器的作用就是用一个新函数封装旧函数(是旧函数代码不变的情况下增加功能)然后会返回一个新函数,新函数就叫做装饰器,一般为了简化装饰器会用语法糖@新函数来简化 例子: 这是一段代码,但功能太少,要对这个进行增强,但又不能改变代码. def hello(): return "hello world!" 现在我们的需求是要增强hello()函数的功能,希望给返回加上HTML标签,比如<i>hello world</i>,但要求我们不得改变hello()函数原来的定义

  • Python装饰器用法示例小结

    本文实例讲述了Python装饰器用法.分享给大家供大家参考,具体如下: 下面的程序示例了python装饰器的使用: 示例一: def outer(fun): print fun def wrapper(arg): result=fun(arg) print 'over!' return result return wrapper @outer def func1(arg): print 'func1',arg return 'very good!' response=func1('python'

  • python函数装饰器用法实例详解

    本文实例讲述了python函数装饰器用法.分享给大家供大家参考.具体如下: 装饰器经常被用于有切面需求的场景,较为经典的有插入日志.性能测试.事务处理等.装饰器是解决这类问题的绝佳设计, 有了装饰器,我们就可以抽离出大量函数中与函数功能本身无关的雷同代码并继续重用.概括的讲,装饰器的作用就是为已经存在的对象添加额外的功能. #! coding=utf-8 import time def timeit(func): def wrapper(a): start = time.clock() func

  • Python的装饰器模式与面向切面编程详解

    今天来讨论一下装饰器.装饰器是一个很著名的设计模式,经常被用于有切面需求的场景,较为经典的有插入日志.性能测试.事务处理等.装饰器是解决这类问题的绝佳设计,有了装饰器,我们就可以抽离出大量函数中与函数功能本身无关的雷同代码并继续重用.概括的讲,装饰器的作用就是为已经存在的对象添加额外的功能. 1. 装饰器入门 1.1. 需求是怎么来的? 装饰器的定义很是抽象,我们来看一个小例子. 复制代码 代码如下: def foo():     print 'in foo()'   foo() 这是一个很无聊

  • Python多层装饰器用法实例分析

    本文实例讲述了Python多层装饰器用法.分享给大家供大家参考,具体如下: 前言 Python 的装饰器能够在不破坏函数原本结构的基础上,对函数的功能进行补充.当我们需要对一个函数补充不同的功能,可能需要用到多层的装饰器.在我的使用过程中,遇到了两种装饰器层叠的情况,这里把这两种情况写下来,作为踩坑记录. 情况1 def A(funC): def decorated_C(funE): def decorated_E_by_CA(*args, **kwargs): out = funC(funE)

  • Python函数装饰器原理与用法详解

    本文实例讲述了Python函数装饰器原理与用法.分享给大家供大家参考,具体如下: 装饰器本质上是一个函数,该函数用来处理其他函数,它可以让其他函数在不需要修改代码的前提下增加额外的功能,装饰器的返回值也是一个函数对象.它经常用于有切面需求的场景,比如:插入日志.性能测试.事务处理.缓存.权限校验等应用场景.装饰器是解决这类问题的绝佳设计,有了装饰器,我们就可以抽离出大量与函数功能本身无关的雷同代码并继续重用.概括的讲,装饰器的作用就是为已经存在的对象添加额外的功能. 严格来说,装饰器只是语法糖,

  • python @propert装饰器使用方法原理解析

    这篇文章主要介绍了python @propert装饰器使用方法原理解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 首先,@propert的作用是把类中的方法『变成』了属性,方便通过实例访问.propert可以有两种用法:可以把一个方法变成只读属性:可以对一些属性进行过滤. 想象这样一个场景,在实例化一个类之后,需要对类的一个属性进行赋值,这时候是没有对属性属性被赋予的值进行判断的,如果属性被赋予了一个不合适的值,那么代码在后面执行的时候就会

  • Python闭包装饰器使用方法汇总

    闭包内容: 匿名函数:能够完成简单的功能,传递这个函数的引用,只有功能 普通函数:能够完成复杂的功能,传递这个函数的引用,只有功能 闭包:能够完成较为复杂的功能,传递这个闭包中的函数以及数据,因此传递是功能+数据 对象:能够完成最复杂的功能,传递很多数据+很多功能,因此传递的是数据+功能 ------------------- 对全局函数进行修改:在函数当中加global,在闭包中外边中的变量加nonlocal 闭包定义:有两个函数嵌套使用,里面的函数可以使用外面函数所传输的参数,最后可传递的是

  • Python函数装饰器的使用教程

    Python函数装饰器的使用教程

    典型的函数装饰器 以下示例定义了一个装饰器,输出函数的运行时间: 函数装饰器和闭包紧密结合,入参func代表被装饰函数,通过自由变量绑定后,调用函数并返回结果. 使用clock装饰器: import time from clockdeco import clock @clock def snooze(seconds): time.sleep(seconds) @clock def factorial(n): return 1 if n < 2 else n*factorial(n-1) if _

随机推荐