Python 中的装饰器

装饰器作用：动态改变函数、方法、类的功能而不用修改被改变对象本身的代码。只需要定义一个装饰器函数，然后给要改变的函数头顶加个 @ 语句就可以了。

具体实现：将函数 A 作为参数传入装饰器函数，经过一番处理后再输出这个函数。
先模拟一下装饰器的实现。Python 的实现方式和这个是一致的，只不过用了一个 @ 的语法糖。

def decor(func):
    print('This is decor.')
    return func

def foo():
    print("I'm foo.")

foo = decor(foo)
foo()
# 输出
# This is decor.
# I'm foo.

可以清楚地看到，装饰器函数 decor 接受 foo 函数作为参数，并且返回这个函数本身。换成 foo = decor(foo) 这句换成语法糖是等效的：

@decor
def foo():
    print("I'm foo.")

但是这里的函数没有带参数，如果要带参数，需要在装饰器里面加一层 wrapper（也可以用其他名字，建议就用这个）。

def decor(func):
    def wrapper(*args, **kwargs):
        print('decor!')
        return func(*args, **kwargs)
    return wrapper

def foo(n):
    print(n)

foo = decor(foo)
foo(1)

总之，就是 wrapper 是一个可以接受任何参数的函数。然后返回的结果是能够接受参数的函数。但是实际上能接受的参数取决于 func 本身。例如:

int = decor(int)
int(b=2)

int 函数不接受 b 参数，会报 TypeError。
也可以把 wrapper 写成和 foo 一样的参数，但是这样不具有普遍性。如果另一个也需要加装饰器的函数接收的参数不同，那就不行了。

---

最后是给装饰器本身加参数：

def decor_with_para(times=0):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for i in args:
                print(i*times)
            return func(*args, **kwargs)
        return wrapper
    return decorator

@decor_with_para(times=2)
def zoo(n):
    print("I'm zoo.")

zoo(5)
# 输出
# 10
# I'm zoo.

需要在 wrapper 之外再套一个 decorator （这也是一个惯例命名）。现在来还原一下这个过程。

def decor_with_para(times=0):
    def decorator(func):
        def wrapper(*args, **kwargs):
            return func(*args, **kwargs)
        return wrapper
    return decorator

def zoo(n):
    print("I'm No." + n)

# 分步来看
decor_with_para(times=2) # 返回 decorator 函数，它需要一个函数作为参数
decor_with_para(times=2)(zoo) # 返回 wrapper 函数，它需要一个参数 n
decor_with_para(times=2)(zoo)('1') # 传入参数 n='1' 调用 wrapper 函数
# 输出
# I'm No.1

decor_with_para 就是一个普通的函数，需要一个 times 作为参数，然后返回一个叫 decorator 的函数。这个函数需要需要一个函数作为参数，于是传入了 zoo，然后返回一个叫 wrapper 的函数，这个函数也需要参数，并把参数传给 func。于是我给了参数 '1'。整个过程就是这么个过程。

---

来，现学现卖。举一个例子来说明装饰器的作用。
比如我要记录每个函数启动的时间戳，与其修改每个函数的内部逻辑，不如直接头顶加个装饰器方便。

import time 

def timer(func):
    def wrapper(n):
        print('Begins at', time.time())
        return func(n)
    return wrapper 

@timer
def func1(n):
    time.sleep(n)

@timer
def func2(n):
    time.sleep(n-1)

func1(2)
func2(3)

再来一个酷炫一点，重复调用同一个函数：

import os

def retry(times=1):
    def decorator(func):
        def wrapper(*args, **kwargs):
            success = 0
            for i in range(times):
                print('Trying {} time(s)...'.format(i+1))
                if func(*args, **kwargs):
                    success += 1
            return '{:.2f}%'.format(success/times*100)
        return wrapper
    return decorator

@retry(times=2)
def is_online(ip):
    return os.system('ping -n 1 {} > nul'.format(ip)) == 0

successful_rate = is_online('192.168.7.93')
print(successful_rate)

可以用一个 retry 装饰器来多次 ping 一个 ip，最后返回成功率。