闭包、装饰器

闭包：如果一个内部函数，对在外部作用域(但不是在全局作用域)的变量进行引用，那么内部函数就被认为是闭包(closure)。

　　闭包 = 内部函数 + 定义函数时的环境

def outer(x):
    def inner():  # 条件1 inner就是内部函数
        print(x)  # 条件2 外部环境的一个变量
    
    return inner  # 结论：内部函数inner就是一个闭包


# inner()  # 1 局部变量，全局无法调用

f = outer(8)  # 闭包就是一种能够调用内部函数的现象。
f()

开放封闭原则：对修改封闭，对扩展开放。

函数装饰器：

　　无参函数：

import time

def show_time(f):
    def inner():
        start = time.time()
        f()
        end = time.time()
        print('spend %s' % (end - start))
    return inner

@show_time  # foo=show_time(foo)
def foo():
    print('foo....')
    time.sleep(2)

foo()

 　　有参函数：

import time

def show_time(f):
    def inner(x, y):
        start = time.time()
        f(x, y)  # 执行原函数(foo)
        end = time.time()
        print('spend %s' % (end - start))
    return inner

@show_time  # foo=show_time(foo)
def foo(a, b):
    print(a + b)
    time.sleep(2)

# 之前调用foo时执行foo里的代码，加上装饰器后调用foo会执行inner中的代码，inner中的f就是foo，参数要一一对应。
foo(3, 5)

　　有参装饰器：

import time

def logger(flag=False):
    def show_time(f):
        def inner(x, y):
            start = time.time()
            f(x, y)  # 执行原函数(foo)
            end = time.time()
            print('spend %s' % (end - start))

            if flag:
                print('打印日志')
        return inner
    return show_time

@logger(True)  # 相当于@show_time，与上例的区别仅在于多了一个参数
def foo(a, b):
    print(a + b)
    time.sleep(2)

# 之前调用foo时执行foo里的代码，加上装饰器后调用foo会执行inner中的代码，inner中的f就是foo，参数要一一对应。
foo(3, 5)

　　嵌套装饰器：

def makebold(fn):
    print('bold')
    def wrapper2():
        return "<b>" + fn() + "</b>"    # fn=wapper1
        # print("<b>" + fn() + "</b>")  # fn=wapper1
    return wrapper2

def makeitalic(fn):
    print('italic')
    def wrapper1():
        return "<i>" + fn() + "</i>"  # fn=hello
        #  这里必须使用return，不能使用print，因为print("<b>" + None + "</b>")报错
        # print("<i>" + fn() + "</i>")
    return wrapper1

@makebold  # wapper1=makebold(wapper1) --> wapper2  步骤2
@makeitalic  # hello=makeitalic(hello) --> wapper1  步骤1
def hello():
    return "hello decorater"

s = hello()
print(s)
# italic
# bold
# <b><i>hello decorater</i></b>

# print("<b>" + None + "</b>")  # 报错

类装饰器：

import time

class Foo(object):
    def __init__(self, func):
        self._func = func

    def __call__(self):
        start_time = time.time()
        self._func()
        end_time = time.time()
        print('spend %s' % (end_time-start_time))

@Foo  #bar=Foo(bar)
def bar():
    print('bar')
    time.sleep(2)

bar()  # 调用__call__方法

　　使用装饰器极大地复用了代码，但有一个缺点就是原函数的元信息丢失了，比如docstring、__name__，参数列表等。

def foo():
    print("hello foo")

print(foo.__name__)
#####################

def logged(func):
    def wrapper(*args, **kwargs):
        print(func.__name__ + " was called")
        return func(*args, **kwargs)
    return wrapper

@logged  # cal=logged(cal) --> wapper
def cal(x):
   return x + x * x

print(cal.__name__)
########
# foo
# wrapper  # 原函数信息丢失

　　补救措施：

　　　　functools.waps，把原函数的元信息拷贝到装饰器函数中。

from functools import wraps

def logged(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print(func.__name__ + " was called")
        return func(*args, **kwargs)
    return wrapper

@logged  # cal=logged(cal) --> wapper
def cal(x):
   return x + x * x

print(cal.__name__)
# cal

参考：http://www.cnblogs.com/yuanchenqi/articles/5830025.html