您的位置:

python装饰器改变命运的简单介绍

本文目录一览:

python自动测试Pytest中Fixture装饰器

可以使用 pytest.fixture() 查看 fixture() 函数的源码和所需要的参数,同Fixture装饰器需要的参数一样。

说明:

使用Fixture装饰器来实现部分用例的前后置。

比如:我们在测试一个操作流程时,有的测试用例需要登陆,有的测试用例执行不需要用户登陆。

如果要直接使用 setup_function() 前置函数来实现,该文件中的所有用例执行前都需要进行用户登陆。

如下示例:

我们可以使用Fixture装饰器来实现部分用例的前后置,如下示例:

前面的示例,是在用例前加前置条件,相当于执行了 setup() 前置函数,既然有 setup() 前置函数那就会有 teardown() 后置函数,Fixture里面的 teardown() 后置函数用 yield 来唤醒。

示例:

yield 是当用例执行完之后,会执行 yield 后面的代码,但用例不能有 return 返回值。

addfinalizer 实现功能跟 yield 一样,但是用例可以 return 参数,传给后面用例。

示例1:

示例2:

示例3:

使用 yield 也可以返回数据。(这种方式好神奇)

上面例子是带返回值并且还要实现 teardown() 后置函数的Fixture写法。

这里就是单纯的说明带返回值的Fixture。

我们可以选择让Fixture返回我们需要的东西,如果Fixture需要配置一些数据,读个文件,或者连接一个数据库,那么你可以让Fixture返回这些数据或资源。

示例:

Fixture修饰的函数可以通过添加 params 参数来实现参数化。(实际工作中,不常用此方式)

request 代表Fixture的调用状态, request.param 作为返回值供测试使用。

示例:

参数是一个元组列表格式的数据。

总结: params 参数支持的格式。

@pytest.mark.usefixtures("fixturename") 装饰类也是一种调用Fixture的方式。

@pytest.mark.usefixtures("fixturename") 装饰类可以装饰模块、类、函数、方法。

usefixtures 与传 fixture 区别:

如果Fixture有返回值,则不能用 @pytest.mark.usefixtures("fixturename") 装饰器修饰用例。

如果Fixture没有返回值,用 @pytest.mark.usefixtures("fixturename") 装饰器和 @pytest.fixture() 装饰器作用一样。

示例:

python 带可变参数的装饰器怎么用

装饰器本身是用来是为一个函数是实现新的功能,并且不改变原函数的代码以及调用方式。

遇到这样一种问题:

众多函数调用了你写的装饰器,但客户有需求说,我想实现我可以随之控制装饰器是否生效。

那你就不可能在得到命令的时候去原函数头部去做删除和添加装饰器调用的命令。这是就可以用到带参数的装饰器,定义一个开关,调用装饰器的时候,把这个装饰器的开关参数给传递进去,这样当开关打开的时候装饰器生效,关闭的时候则只执行原函数的代码。

举例:开关参数为True的时候执行过程:

F = True          #step 1 装饰器的开关变量

def outer(flag):  #step 2

    def wrapper(func): #step 4

        def inner(*args,**kwargs): #stpe 6

            if flag:               #step 9

                print('before')   #step 10

                ret = func(*args,**kwargs)  #step 11  执行原函数

                print('after')             #step13

            else:

                ret = func(*args,**kwargs)

                print('123')

            return ret                     #step 14

        return inner    #step 7

    return wrapper     #step 5

@outer(F)   #先执行step 3 :outer(True)这个函数,然后step 6:@wrapper   #此处把开关参数传递给装饰器函数

def hahaha():

    pass    #step 12

hahaha()    # step 8    相当于inner()

开关参数为False的时候执行过程:

F = False          #stpe1 装饰器的开关变量

  def outer(flag):  #step 2

      def wrapper(func): #step 4

          def inner(*args,**kwargs): #stpe 6

              if flag:               #step 9

                  print('before')   

                  ret = func(*args,**kwargs)    

                  print('after')             

              else:

                 ret = func(*args,**kwargs)    #step 10  执行原函数

                 print('123')                 #step 12

             return ret                     #step 13

         return inner    #step 7

     return wrapper     #step 5

python装饰器有什么用

先来个形象比方

内裤可以用来遮羞,但是到了冬天它没法为我们防风御寒,聪明的人们发明了长裤,有了长裤后宝宝再也不冷了,装饰器就像我们这里说的长裤,在不影响内裤作用的前提下,给我们的身子提供了保暖的功效。

再回到我们的主题

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

先来看一个简单例子:

def foo():

print('i am foo')

现在有一个新的需求,希望可以记录下函数的执行日志,于是在代码中添加日志代码:

def foo():

print('i am foo')

logging.info("foo is running")

bar()、bar2()也有类似的需求,怎么做?再写一个logging在bar函数里?这样就造成大量雷同的代码,为了减少重复写代码,我们可以这样做,重新定义一个函数:专门处理日志 ,日志处理完之后再执行真正的业务代码

def use_logging(func):

logging.warn("%s is running" % func.__name__)

func()def bar():

print('i am bar')use_logging(bar)

逻辑上不难理解,

但是这样的话,我们每次都要将一个函数作为参数传递给use_logging函数。而且这种方式已经破坏了原有的代码逻辑结构,之前执行业务逻辑时,执行运行bar(),但是现在不得不改成use_logging(bar)。那么有没有更好的方式的呢?当然有,答案就是装饰器。

简单装饰器

def use_logging(func):

def wrapper(*args, **kwargs):

logging.warn("%s is running" % func.__name__)

return func(*args, **kwargs)

return wrapperdef bar():

print('i am bar')bar = use_logging(bar)bar()

函数use_logging就是装饰器,它把执行真正业务方法的func包裹在函数里面,看起来像bar被use_logging装饰了。在这个例子中,函数进入和退出时

,被称为一个横切面(Aspect),这种编程方式被称为面向切面的编程(Aspect-Oriented Programming)。

@符号是装饰器的语法糖,在定义函数的时候使用,避免再一次赋值操作

def use_logging(func):

def wrapper(*args, **kwargs):

logging.warn("%s is running" % func.__name__)

return func(*args)

return wrapper@use_loggingdef foo():

print("i am foo")@use_loggingdef bar():

print("i am bar")bar()

如上所示,这样我们就可以省去bar =

use_logging(bar)这一句了,直接调用bar()即可得到想要的结果。如果我们有其他的类似函数,我们可以继续调用装饰器来修饰函数,而不用重复修改函数或者增加新的封装。这样,我们就提高了程序的可重复利用性,并增加了程序的可读性。

装饰器在Python使用如此方便都要归因于Python的函数能像普通的对象一样能作为参数传递给其他函数,可以被赋值给其他变量,可以作为返回值,可以被定义在另外一个函数内。

带参数的装饰器

装饰器还有更大的灵活性,例如带参数的装饰器:在上面的装饰器调用中,比如@use_logging,该装饰器唯一的参数就是执行业务的函数。装饰器的语法允许我们在调用时,提供其它参数,比如@decorator(a)。这样,就为装饰器的编写和使用提供了更大的灵活性。

def use_logging(level):

def decorator(func):

def wrapper(*args, **kwargs):

if level == "warn":

logging.warn("%s is running" % func.__name__)

return func(*args)

return wrapper

return decorator@use_logging(level="warn")def foo(name='foo'):

print("i am %s" % name)foo()

上面的use_logging是允许带参数的装饰器。它实际上是对原有装饰器的一个函数封装,并返回一个装饰器。我们可以将它理解为一个含有参数的闭包。当我

们使用@use_logging(level="warn")调用的时候,Python能够发现这一层的封装,并把参数传递到装饰器的环境中。

类装饰器

再来看看类装饰器,相比函数装饰器,类装饰器具有灵活度大、高内聚、封装性等优点。使用类装饰器还可以依靠类内部的\_\_call\_\_方法,当使用 @ 形式将装饰器附加到函数上时,就会调用此方法。

class Foo(object):

def __init__(self, func):

self._func = func

def __call__(self):

print ('class decorator runing')

self._func()

print ('class decorator ending')

@Foo

def bar():

print ('bar')

bar()

functools.wraps

使用装饰器极大地复用了代码,但是他有一个缺点就是原函数的元信息不见了,比如函数的docstring、__name__、参数列表,先看例子:

装饰器

def logged(func):

def with_logging(*args, **kwargs):

print func.__name__ + " was called"

return func(*args, **kwargs)

return with_logging

函数

@loggeddef f(x):

"""does some math"""

return x + x * x

该函数完成等价于:

def f(x):

"""does some math"""

return x + x * xf = logged(f)

不难发现,函数f被with_logging取代了,当然它的docstring,__name__就是变成了with_logging函数的信息了。

print f.__name__    # prints 'with_logging'print f.__doc__     # prints None

这个问题就比较严重的,好在我们有functools.wraps,wraps本身也是一个装饰器,它能把原函数的元信息拷贝到装饰器函数中,这使得装饰器函数也有和原函数一样的元信息了。

from functools import wrapsdef logged(func):

@wraps(func)

def with_logging(*args, **kwargs):

print func.__name__ + " was called"

return func(*args, **kwargs)

return with_logging@loggeddef f(x):

"""does some math"""

return x + x * xprint f.__name__  # prints 'f'print f.__doc__   # prints 'does some math'

内置装饰器

@staticmathod、@classmethod、@property

装饰器的顺序

@a@b@cdef f ():

等效于

f = a(b(c(f)))

请教Python 使用装饰器实现单例模式的原理

简单来讲,可以不严谨地把Python的装饰器看做一个包装函数的函数。 比如,有一个函数: def func(): print 'func() run.' if '__main__' == __name__: func() 运行后将输出: func() run. 现在需要在函数运行前后打印一条日志