Python进阶之[非局部变量，闭包，装饰器]

阅读Tacotron2源码 之 Python进阶

1. Non-Local Variable with Nested Function
2. Closure in Python
3. Decorator

---

---

---

1. Non-Local Variable with Nested Function

    在Python中，除了全局变量(Global Variable)和局部变量(Local Variable)之外，还有一种变量叫Non-Local Variable。

    Non-Local Variable的存在来源于python允许Nested Function的存在。C/C++中，结构体(类)里面再定义结构体(类)可以做到，但是函数里面再定义函数则不被允许。Python可以实现嵌套函数的原因在于Everything in Python is Object，写嵌套函数的初心无非是外层函数想要利用内层函数的返回值。

    无关紧要，python三种变量都是相对的概念，全局变量好理解，就不写了，主要是Local Variable和Non-Local Variable如何区别。直接看一组代码就能明白：

# Version 1
def outer():
    y = 40
    def inner():
        nonlocal y
        print("before modified :", y)
        y = 50
        print("after modified  :", y)
    inner()
    print("outer:", y)
outer()

>>>before modified : 40
>>>after modified  : 50
>>>outer: 50

    这是一个典型的Nested Funtion(嵌套函数)，inner()函数嵌套在outer()函数的内部。对于outer()函数来说，y就是它的Local Variable；对于inner()函数来说，有了nonlocal关键字，y就是它的Non-Local Variable。

    此时，你可能会认为Non-Local Variable是用nonlocal关键字定义的，其实不然，没有这个关键字，它也是Non-Local Variable。请看下面一组代码：

# Version 2
def outer():
    y = 40
    def inner():
        # nonlocal y
        print("before modified :", y)
        # y = 50
        # print("after modified  :", y)
    inner()
    print("outer:", y)
outer()
>>>before modified : 40
>>>outer: 40

    仔细观察，我只是注释了部分的代码，此时inner()函数访问(调用)了变量y，此时对于inner()函数来说，y仍然是它的Non-Local Variable。

    那么现在一个明显的问题就是，既然Non-Local Variable不依赖于nonlocal关键字来定义，那这个关键字存在的意义是什么？继续看下面的代码：

# Version 3
def outer():
    y = 40
    def inner():
        # nonlocal y
        print("before modified :", y)
        y = 50
        print("after modified  :", y)
    inner()
    print("outer:", y)
outer()
>>>Error

    上面Version 3代码只是注释掉了Version 1中的关键字部分，然而运行却是报错的。然后你在看看Version 2和Version 3的区别，就会发现，Version 3试图在没有关键字nonlocal的声明前提下去修改Non-Local Variable，所以它报错了。

总结一下

    Non-Local Variable依赖于嵌套函数中存在，并且有两种定义方式——显式定义和隐式定义。显示定义要用nonlocal关键字声明，此时内部函数不仅可以访问还可以修改Non-Local Variable；隐式定义无须声明，但是此时内部函数只有访问而没有修改Non-Local Variable的权利。

---

2. Python Closure

    Closure(闭包)，这个概念与上面的Non-Local Variable一样，它依赖于Nested Function而存在。一句话说什么是Closure：

外部函数返回内部函数的嵌套函数，就叫闭包。

    观察上面代码，发现外部函数outer()只是调用了内部函数inner()，而并没有将其return出来，所以这个嵌套函数不是闭包。下面是一个闭包的例子：

def print_msg(msg):
    def printer():
        print(msg)
    return printer

another = print_msg("Hello")
another()
>>>"Hello"

    因为Everything in Python is Object，所以函数的返回值是另一个函数完全没问题。

    闭包的概念就是这么简洁，用法在下面：

del print_msg
another()
>>>Hello


print_msg("Hello")
>>>Traceback (most recent call last):
>>>...
>>>NameError: name 'print_msg' is not defined

    也很好懂，我们已经把外部函数print_msg()杀死了，但是内部函数printer()却活了下来，因为在杀死print_msg()之前，another = print_msg("Hello")，相当于another()继承了内部函数的地址，所以它仍然存在着。

总结一下：

什么时候需要用到Closure？

1. 必须要写嵌套函数的时候
2. 嵌套函数的内部函数需要访问非局部变量的时候
3. 外部函数需要将内部函数作为返回值

其实我感觉说了跟没说一样。。。目前觉得闭包就是用在下面要说的装饰器中。

---

3. Decorator

    Decorator来源于现实需求，现有的代码功能有短缺，需要添加新功能，但是我想在不大刀改动原有代码的前提下，添加新功能并且新写完的代码具有向后兼容性。

    直接用例子说明：

# Version 1
# 阶乘函数
def count(number):
    mul = 1
    for item in range(1, number):
        mul *= item
    print(mul)

def cost(func, number):
    start = time.time()
    func(number)
    end = time.time()
    cost_time = end - start
    return cost_time
    
time = cost(count, 6)
print(time)
>>>6
>>>1s

    上面代码的需求是要计算阶乘函数耗费的时间，一个很直观的想法就是把阶乘函数作为参数传给cost()函数，这样运行cost()函数即可。这个做法可以但是并不完美，下面看看装饰器怎么做：

# Version 2
# 这是一个Closure
def cost(func):
    def _measure_time(*args, **kwargs):
        start = time.time()
        func(*args, **kwargs)
        elapse = time.time() - start
        print("takes {} seconds.".format(elapse))
    return _measure_time

@cost
def count(number):
    mul = 1
    for item in range(number):
        mul *= item
    print(mul)

count(4)
>>>6
>>>takes 1 seconds.

    Version 2就是一个装饰器，它没有改动原始的阶乘函数，只是新写了一个闭包cost，并且在阶乘函数头上添加了@cost，使用的时候，发现只运行count()函数，还输出了消耗的时间，这就叫代码的向后兼容性。

    再仔细看一下闭包的写法，用到了两种参数*args, **kwargs，这样，无论要装饰或者称为包起来的函数func()需要什么类型的参数,闭包都可以兼容。

    再提一句，Decorator可以叠加，如下：

def star(func):
    def inner(*args, **kwargs):
        print("*" * 30)
        func(*args, **kwargs)
        print("*" * 30)
    return inner

def percent(func):
    def inner(*args, **kwargs):
        print("%" * 30)
        func(*args, **kwargs)
        print("%" * 30)
    return inner

@star
@percent
def printer(msg):
    print(msg)
printer("Hello")

>>>
******************************
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Hello
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
******************************

    观察输出，又可以对闭包和装饰器有一个直观的理解。

总结一下：

    装饰器就是在代码中很少改动的前提条件下，添加新功能，并且新写完的代码具有向后兼容性。

转载于:https://www.cnblogs.com/machine-lyc/p/11247462.html