python装饰器

wrapper，最近被问到这个问题，简单地会python其实挺尴尬的，因为之前有某一次，一个面试官跟我说，“python，我也可以会啊，只不过是要查文档而已”。确实，如果只会基本的数据结构（列表、字符串、字典、集合），OOP，以及常用的操作，绝大部分时候的开发都是用库的，即使是熟悉的人，也需要经常查文档的，那会跟不会的人，有什么区别呢（意思是，即使不会的人，也能很容易学起来）？

我自己也不是很深入了解python，平时也就用来处理文本，跑跑机器学习算法，甚至是把python shell直接拿来当计算器用==。妄自猜测了下面几个点，欢迎交流：

1. python的变量和变量空间，这个可能得从python是如何动态解析代码的方面进去看（陈会长学了半天后，很高兴地说，python里的所有变量其实都是一个指针来的，想想也确实是这样）
2. python的高级特性，比如装饰器，生成器，切片等等；
3. python里的多进程、多线程编程，还有协程（有空会介绍）
4. 具体开发环境下常用的库啦，用得溜，对整体理解得透，肯定是比挨个api查文档的人效率高很多的

综上所述，“会一点python”的朋友也不要灰心，喜欢就深入搞下去～

装饰器wrapper

最经典中文学习资料当属：廖雪峰的python教程啦。（建议看完廖的教程再看这篇博客）学一个东西，我觉得得把为什么要用这个东西，什么情况下用这个东西搞清楚，这个东西其原理的关键在哪，这才是学有所得吧？

学完总结一下，装饰器到底是什么呢？
有没有学过一个设计模式：装饰模式？
装饰器其实是python从语法上支持这种模式的一个实现！
没有？那也不要紧～
装饰器简单来说就是对于一个函数A，A的功能需要增强，或者需要多一些处理逻辑，重写一个函数吗？
如果这个功能是很普遍的呢（比如flask里最经典的路由修饰，将你的逻辑函数和一个路由链接起来）？
不必要的冗余是程序猿最不能忍的东西之一啊！！！
所以装饰器是比较好的选择！

比如下面三个经典的问题：

A. 请编写一个decorator，能在函数调用的前后打印出’begin call’和’end call’的日志。

这个问题的关键，是要理清楚——原函数是在什么时候被调用的？
看代码可以知道，是在wrapper中被调用了，那就好办了，在调用前后分别打印不就可以了吗？
不要把返回值给忘了呀！！！
那就先用个变量将返回值保存下来，调用完，打印出日志信息后，再返回刚刚保存的那个返回值，that’s all!

# coding: utf-8
import functools


# 一个装饰器函数：接受一个函数作为参数，返回一个“增强”过的函数
def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kw):
        print("before call")
        result = func(*args, **kw)
        print("after call\n")
        return result
    return wrapper


@log
def test(text):
    """After decoration, test = log(test)"""
    print(text)


test("This is a test for wrapper")

输出：

B. 如何实现一个有参数的装饰器？

有参数意味着什么呢？
就A中的例子来说，比如要实现这样子：

@log('info')
def test():
    """After decoration, test = log('info')(test)"""
    print("This is a test for wrapper")

其实很容易看出，就是多了一层而已，就是说——log(‘info’)是一个无参的装饰器，那么可以这样写：

# coding: utf-8
import functools


def log(info):
    # 一个装饰器函数：接受一个函数作为参数，返回一个“增强”过的函数，此时是decorator了
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            print("before call")
            print("There is a info: {0}".format(info))
            result = func(*args, **kw)
            print("after call\n")
            return result
        return wrapper
    # 注意返回值是一个无参的装饰器函数
    # 调用log(info)(func)即变为decorator(func)
    # decorator(func)返回一个“增强”过的函数wrapper
    return decorator


@log('info')
def test():
    """After decoration, test = log('info')(test)"""
    print("This is a test for wrapper")


test()

运行结果如下：

C. 要求如下图：

明白了wrapper的原理，就会知道，（有参数和无参数）这两个装饰方式是很不同的：
第一个装饰后，f = log(f)；
第二个装饰后，f = log(‘execute’)(f)。
那么怎么做到同时支持这两个呢？
找找二者的区别呗～
log的参数类型不一样：一个是函数，一个是字符串！！！
所以简单的做法就是：在log内部判断一下，不同的情况返回相应的装饰结果就好了，比如：

# coding: utf-8
import functools
import types


def log(text=None):
    if isinstance(text, types.FunctionType):
        # 如果参数text是函数类型，那么说明是调用@log的，此时应该手动将text转为func，然后text赋默认值
        func = text
        text = 'default text...'
        @functools.wraps(func)
        def wrapper(*args, **kw):
            print("before call")
            print("The decorator's arg is: {0}".format(text))
            result = func(*args, **kw)
            print("after call\n")
            return result
        return wrapper
    else:
        def decorator(func):
            @functools.wraps(func)
            def wrapper(*args, **kw):
                print("before call")
                print("The decorator's arg is: {0}".format(text))
                result = func(*args, **kw)
                print("after call\n")
                return result
            return wrapper
        return decorator


@log
def no():
    """no = log(no)"""
    print('No arg version func is being called')


@log('yes, yes')
def yes():
    """yes = log('yes, yes')(yes)"""
    print('With arg version func is being called')


no()
yes()

上面的代码里有注释，应该是比较清晰的，就是一个if判断，然后内容是综合了A和B的东西，一个有参数，一个无参数。

那么问题来了，处女座的朋友可能会发现，wrapper那部分的代码一般是一致的，这不就重复了吗？？？？能不能不要重复啊？？？
答案肯定是可以的，比如可以这样（下面分解变换动作，两步走）：

第一步，统一格式（将无参的那部分加多一层）

def log(text=None):
    if isinstance(text, types.FunctionType):
        # 如果参数text是函数类型，那么说明是调用@log的，此时应该手动将text转为func，然后text赋默认值
        func = text
        text = 'default text...'
        def decorator(func):
            @functools.wraps(func)
            def wrapper(*args, **kw):
                print("before call")
                print("The decorator's arg is: {0}".format(text))
                result = func(*args, **kw)
                print("after call\n")
                return result
            return wrapper
        return decorator(func)
    else:
        def decorator(func):
            @functools.wraps(func)
            def wrapper(*args, **kw):
                print("before call")
                print("The decorator's arg is: {0}".format(text))
                result = func(*args, **kw)
                print("after call\n")
                return result
            return wrapper
        return decorator

第二步，求同存异！！

def log(text=None):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            print("before call")
            print("The decorator's arg is: {0}".format(text))
            result = func(*args, **kw)
            print("after call\n")
            return result
        return wrapper
    if isinstance(text, types.FunctionType):
        # 如果参数text是函数类型，那么说明是调用@log的
        # 应该返回一个“增强”过的函数，log(func) -> decorator(func) -> wrapper
        func = text
        text = 'default text...'
        return decorator(func)
    else:
        # 否则应该返回一个装饰器，log('info')(func) -> decorator(func) -> wrapper
        return decorator

搞定，运行结果是：