python重试装饰器

装饰器是程序开发中经常会用到的一个功能，用好了装饰器，开发效率如虎添翼，所以这也是Python面试中必问的问题，但对于好多小白来讲，这个功能 有点绕，自学时直接绕过去了，然后面试问到了就挂了，因为装饰器是程序开发的基础知识，这个都 不会，别跟人家说你会Python, 看了下面的文章，保证你学会装饰器。

1、先明白这段代码

####第一波####

deffoo():

print'foo'

foo#表示是函数

foo()#表示执行foo函数

####第二波####

deffoo():

print'foo'

foo=lambdax:x+1

foo()#执行下面的lambda表达式，而不再是原来的foo函数，因为函数foo被重新定义了

2、需求来了

初创公司有N个业务部门，1个基础平台部门，基础平台负责提供底层的功能，如：数据库操作、redis调用、监控API等功能。业务部门使用基础功能时，只需调用基础平台提供的功能即可。如下：

###############基础平台提供的功能如下###############

deff1():

print'f1'

deff2():

print'f2'

deff3():

print'f3'

deff4():

print'f4'

###############业务部门A调用基础平台提供的功能###############

f1()

f2()

f3()

f4()

###############业务部门B调用基础平台提供的功能###############

f1()

f2()

f3()

f4()

目前公司有条不紊的进行着，但是，以前基础平台的开发人员在写代码时候没有关注验证相关的问题，即：基础平台的提供的功能可以被任何人使用。现在需要对基础平台的所有功能进行重构，为平台提供的所有功能添加验证机制，即：执行功能前，先进行验证。

老大把工作交给 Low B，他是这么做的：

跟每个业务部门交涉，每个业务部门自己写代码，调用基础平台的功能之前先验证。诶，这样一来基础平台就不需要做任何修改了。

当天Low B 被开除了…

老大把工作交给 Low BB，他是这么做的：

###############基础平台提供的功能如下###############

deff1():

#验证1

#验证2

#验证3

print'f1'

deff2():

#验证1

#验证2

#验证3

print'f2'

deff3():

#验证1

#验证2

#验证3

print'f3'

deff4():

#验证1

#验证2

#验证3

print'f4'

###############业务部门不变###############

###业务部门A调用基础平台提供的功能###

f1()

f2()

f3()

f4()

###业务部门B调用基础平台提供的功能###

f1()

f2()

f3()

f4()

过了一周 Low BB 被开除了…

老大把工作交给 Low BBB，他是这么做的：

只对基础平台的代码进行重构，其他业务部门无需做任何修改

###############基础平台提供的功能如下###############

defcheck_login():

#验证1

#验证2

#验证3

pass

deff1():

check_login()

print'f1'

deff2():

check_login()

print'f2'

deff3():

check_login()

print'f3'

deff4():

check_login()

print'f4'

老大看了下Low BBB 的实现，嘴角漏出了一丝的欣慰的笑，语重心长的跟Low BBB聊了个天：

老大说：

写代码要遵循开发封闭原则，虽然在这个原则是用的面向对象开发，但是也适用于函数式编程，简单来说，它规定已经实现的功能代码不允许被修改，但可以被扩展，即：

• 封闭：已实现的功能代码块

• 开放：对扩展开发

如果将开放封闭原则应用在上述需求中，那么就不允许在函数 f1 、f2、f3、f4的内部进行修改代码，老板就给了Low BBB一个实现方案：

defw1(func):

definner():

#验证1

#验证2

#验证3

returnfunc()

returninner

@w1

deff1():

print'f1'

@w1

deff2():

print'f2'

@w1

deff3():

print'f3'

@w1

deff4():

print'f4'

对于上述代码，也是仅仅对基础平台的代码进行修改，就可以实现在其他人调用函数 f1 f2 f3 f4 之前都进行【验证】操作，并且其他业务部门无需做任何操作。

Low BBB心惊胆战的问了下，这段代码的内部执行原理是什么呢？

老大正要生气，突然Low BBB的手机掉到地上，恰恰屏保就是Low BBB的女友照片，老大一看一紧一抖，喜笑颜开，交定了Low BBB这个朋友。详细的开始讲解了：

单独以f1为例：

defw1(func):

definner():

#验证1

#验证2

#验证3

returnfunc()

returninner

@w1

deff1():

print'f1'

当写完这段代码后（函数未被执行、未被执行、未被执行），python解释器就会从上到下解释代码，步骤如下：

• def w1(func): ==>将w1函数加载到内存

• @w1

没错，从表面上看解释器仅仅会解释这两句代码，因为函数在没有被调用之前其内部代码不会被执行。

从表面上看解释器着实会执行这两句，但是 @w1 这一句代码里却有大文章，@函数名是python的一种语法糖。

如上例@w1内部会执行一下操作：

• 执行w1函数，并将 @w1 下面的函数作为w1函数的参数，即：@w1 等价于 w1(f1)
  所以，内部就会去执行：
  def inner:
  #验证
  return f1() # func是参数，此时 func 等于 f1
  return inner # 返回的 inner，inner代表的是函数，非执行函数
  其实就是将原来的 f1 函数塞进另外一个函数中

• 将执行完的 w1 函数返回值赋值给@w1下面的函数的函数名
  w1函数的返回值是：
  def inner:
  #验证
  return 原来f1() # 此处的 f1 表示原来的f1函数
  然后，将此返回值再重新赋值给 f1，即：
  新f1 =def inner:
  #验证
  return 原来f1()
  所以，以后业务部门想要执行 f1 函数时，就会执行 新f1 函数，在 新f1 函数内部先执行验证，再执行原来的f1函数，然后将 原来f1 函数的返回值 返回给了业务调用者。
  如此一来， 即执行了验证的功能，又执行了原来f1函数的内容，并将原f1函数返回值 返回给业务调用着

Low BBB 你明白了吗？要是没明白的话，我晚上去你家帮你解决吧！！！

先把上述流程看懂，之后还会继续更新…

3、问答时间

问题：被装饰的函数如果有参数呢？

#一个参数

defw1(func):

definner(arg):

#验证1

#验证2

#验证3

returnfunc(arg)

returninner

@w1

deff1(arg):

print'f1'

#两个参数

defw1(func):

definner(arg1,arg2):

#验证1

#验证2

#验证3

returnfunc(arg1,arg2)

returninner

@w1

deff1(arg1,arg2):

print'f1'

#三个参数

defw1(func):

definner(arg1,arg2,arg3):

#验证1

#验证2

#验证3

returnfunc(arg1,arg2,arg3)

returninner

@w1

deff1(arg1,arg2,arg3):

print'f1'

问题：可以装饰具有处理n个参数的函数的装饰器？

defw1(func):

definner(*args,**kwargs):

#验证1

#验证2

#验证3

returnfunc(*args,**kwargs)

returninner

@w1

deff1(arg1,arg2,arg3):

print'f1'

问题：一个函数可以被多个装饰器装饰吗？

defw1(func):

definner(*args,**kwargs):

#验证1

#验证2

#验证3

returnfunc(*args,**kwargs)

returninner

defw2(func):

definner(*args,**kwargs):

#验证1

#验证2

#验证3

returnfunc(*args,**kwargs)

returninner

@w1

@w2

deff1(arg1,arg2,arg3):

print'f1'

问题：还有什么更吊的装饰器吗？

#!/usr/bin/envpython

#coding:utf-8

defBefore(request,kargs):

print'before'

defAfter(request,kargs):

print'after'

defFilter(before_func,after_func):

defouter(main_func):

defwrapper(request,kargs):

before_result=before_func(request,kargs)

if(before_result!=None):

returnbefore_result;

main_result=main_func(request,kargs)

if(main_result!=None):

returnmain_result;

after_result=after_func(request,kargs)

if(after_result!=None):

returnafter_result;

returnwrapper

returnouter

@Filter(Before,After)

defIndex(request,kargs):

print'index'

⑸ Python笔记：Python装饰器

装饰器是通过装饰器函数修改原函数的一些功能而不需要修改原函数，在很多场景可以用到它，比如① 执行某个测试用例之前，判断是否需要登录或者执行某些特定操作；② 统计某个函数的执行时间；③ 判断输入合法性等。合理使用装饰器可以极大地提高程序的可读性以及运行效率。本文将介绍Python装饰器的使用方法。

python装饰器可以定义如下：

输出：

python解释器将test_decorator函数作为参数传递给my_decorator函数，并指向了内部函数 wrapper()，内部函数 wrapper() 又会调用原函数 test_decorator()，所以decorator()的执行会先打印'this is wrapper'，然后打印'hello world'， test_decorator()执行完成后，打印 'bye' ，*args和**kwargs，表示接受任意数量和类型的参数。

装饰器 my_decorator() 把真正需要执行的函数 test_decorator() 包裹在其中，并且改变了它的行为，但是原函数 test_decorator() 不变。

一般使用如下形式使用装饰器：

@my_decorator就相当于 decorator = my_decorator(test_decorator) 语句。

内置装饰器@functools.wrap可用于保留原函数的元信息（将原函数的元信息，拷贝到对应的装饰器函数里）。先来看看没有使用functools的情况：

输出：

从上面的输出可以看出test_decorator() 函数被装饰以后元信息被wrapper() 函数取代了，可以使用@functools.wrap装饰器保留原函数的元信息：

输出：

装饰器可以接受自定义参数。比如定义一个参数来设置装饰器内部函数的执行次数：

输出：

Python 支持多个装饰器嵌套：

装饰的过程：

顺序从里到外：

test_decorator('hello world') 执行顺序和装饰的过程相反。

输出：

类也可以作为装饰器，类装饰器主要依赖__call__()方法，是python中所有能被调用的对象具有的内置方法（python魔术方法），每当调用一个类的实例时，__call__()就会被执行一次。

下面的类装饰器实现统计函数执行次数：

输出：

下面介绍两种装饰器使用场景

统计函数执行所花费的时间

输出：

在使用某些web服务时，需要先判断用户是否登录，如果没有登录就跳转到登录页面或者提示用户登录：

--THE END--

⑹ 推荐 8 个炫酷的 Python 装饰器

1、 lru_cache
这个装饰器来自functools模块。该模块包含在标准库中，非常易于使用。它还包含比这个装饰器更酷的功能，但这个装饰器是非常受人喜欢的。此装饰器可用于使用缓存加速函数的连续运行。当然，这应该在使用时记住一些关于缓存的注意事项，但在通用使用情况下，大多数时候这个装饰器都是值得使用的。
2、JIT
JIT是即时编译的缩写。通常每当我们在Python中运行一些代码时，发生的第一件事就是编译。这种编译会产生一些开销，因为类型被分配了内存，并存储为未分配但已命名的别名，使用即时编译，我们在执行时才进行编译。
在很多方面，我们可以将其视为类似于并行计算的东西，其中Python解释器同时处理两件事以节省时间。Numba JTI编译器因将这一概念提到Python中而闻名，可以非常轻松地调用此装饰器，并立即提高代码的性能。Numba包提供了JIT装饰器，它使运行更密集的软件变得更加容易，而不必进入C。
3、do_twice
do_twice装饰器的功能与它的名字差不多。此装饰器可用于通过一次调用运行两次函数，对调试特别有用。它可以用于测量两个不同迭代的功能。
4、count_calls
count_calls装饰器可用于提供有关函数在软件中使用多少次的信息。与do_twice一样，对调试也特别有用。
5、dataclass
为了节省编写类的时间，推荐使用dataclass装饰器。这个装饰器可用于快速编写类中常见的标准方法，这些方法通常会在我们编写的类中找到。
6、singleton
singleton是一个单例装饰器。通常，单例装饰器是由用户自己编写的，实际上并不是导入的。
7、use_unit
在科学计算中经常派上用场的一种装饰器是use_unit装饰器。此装饰器可用于更改返回结果的表示单位。这对于那些不想在数据中添加度量单位但仍希望人们知道这些单位是什么的人很有用。这个装饰器可不是在任何模块中真正有用，但它是非常常见的，对科学应用程序非常有用。

⑺ 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中异常重试的解决方案详解

Python中异常重试的解决方案详解
大家在做数据抓取的时候，经常遇到由于网络问题导致的程序保存，先前只是记录了错误内容，并对错误内容进行后期处理。
原先的流程：
def crawl_page(url):
pass

def log_error(url):
pass

url = ""
try:
crawl_page(url)
except:
log_error(url)

改进后的流程：
attempts = 0
success = False
while attempts < 3 and not success:
try:
crawl_page(url)
success = True
except:
attempts += 1
if attempts == 3:
break

最近发现的新的解决方案：retrying

retrying是一个 Python的重试包，可以用来自动重试一些可能运行失败的程序段。retrying提供一个装饰器函数retry，被装饰的函数就会在运行失败的条件下重新执行，默认只要一直报错就会不断重试。
import random
from retrying import retry

@retry
def do_something_unreliable():
if random.randint(0, 10) > 1:
raise IOError("Broken sauce, everything is hosed!!!111one")
else:
return "Awesome sauce!"

print do_something_unreliable()

如果我们运行have_a_try函数，那么直到random.randint返回5，它才会执行结束，否则会一直重新执行。

retry还可以接受一些参数，这个从源码中Retrying类的初始化函数可以看到可选的参数：

stop_max_attempt_number：用来设定最大的尝试次数，超过该次数就停止重试
stop_max_delay：比如设置成10000，那么从被装饰的函数开始执行的时间点开始，到函数成功运行结束或者失败报错中止的时间点，只要这段时间超过10秒，函数就不会再执行了
wait_fixed：设置在两次retrying之间的停留时间
wait_random_min和wait_random_max：用随机的方式产生两次retrying之间的停留时间
wait_exponential_multiplier和wait_exponential_max：以指数的形式产生两次retrying之间的停留时间，产生的值为2^previous_attempt_number * wait_exponential_multiplier，previous_attempt_number是前面已经retry的次数，如果产生的这个值超过了wait_exponential_max的大小，那么之后两个retrying之间的停留值都为wait_exponential_max。这个设计迎合了exponential backoff算法，可以减轻阻塞的情况。
我们可以指定要在出现哪些异常的时候再去retry，这个要用retry_on_exception传入一个函数对象：
def retry_if_io_error(exception):
return isinstance(exception, IOError)

@retry(retry_on_exception=retry_if_io_error)
def read_a_file():
with open("file", "r") as f:
return f.read()

在执行read_a_file函数的过程中，如果报出异常，那么这个异常会以形参exception传入retry_if_io_error函数中，如果exception是IOError那么就进行retry，如果不是就停止运行并抛出异常。

我们还可以指定要在得到哪些结果的时候去retry，这个要用retry_on_result传入一个函数对象：

def retry_if_result_none(result):
return result is None

@retry(retry_on_result=retry_if_result_none)
def get_result():
return None

在执行get_result成功后，会将函数的返回值通过形参result的形式传入retry_if_result_none函数中，如果返回值是None那么就进行retry，否则就结束并返回函数值。

⑼ python装饰器使用

装饰器是从英文decorator翻译过来的，从字面上来看就是对某个东西进行修饰，增强被修饰物的功能，下面我们对装饰器做下简单介绍。

一、怎么编写装饰器

装饰器的实现很简单，本质是一个可调用对象，可以是函数、方法、对象等，它既可以装饰函数也可以装饰类和方法，为了简单说明问题，我们实现一个函数装饰器，如下代码：

有了这个装饰器，我们就可以打印出什么时候开始和结束调用函数，对于排查函数的调用链非常方便。

二、带参数的装饰器

上面的例子无论什么时候调用sum都会输出信息，如果我们需要按需输出信息怎么实现呢，这时就要用到带参数的装饰器了，如下代码：

对sum使用装饰器时没有参数，这时debug为0，所以调用sum时不会输出函数调用相关信息。

对multi使用装饰器时有参数，这时debug为1，所以调用multi时会输出函数调用相关信息。

三、函数名字问题

当我们打印被装饰后的函数名字时，不知道大家有没发现输出的不是函数本身的名字，如下代码会输出‘wrap’而不是‘sum’：

有时这种表现并不是我们想要的，我们希望被装饰后的函数名字还是函数本身，那要怎么实现呢？很简单，只需要引入functools.wraps即可，如下代码就会输出‘sum’了：

看完后是不是觉得python装饰器很简单，只要了解它的本质，怎么写都行，有好多种玩法呢。

⑽ 什么是Python装饰器

所谓装饰器就是把函数包装一下，为函数添加一些附加功能，装饰器就是一个函数，参数为被包装的函数，返回包装后的函数：你可以试下：

defd(fp):
def_d(*arg,**karg):
print"dosthbeforefp.."
r=fp(*arg,**karg)
print"dosthafterfp.."
returnr
return_d
@d
deff():
print"callf"
#上面使用@d来表示装饰器和下面是一个意思
#f=d(f)
f()#调用f