简介

• 变量作用域
• 闭包
• 装饰器

变量作用域

        如下例子，b是全局变量，a是局部变量

b=8
def test(a):
    print(a,b)
    # b+=1
test(1)
输出结果：
1 8

        对以上结果，自然符合逻辑无问题，但是当在print(a,b)后面对b操作时，会报错，如下：

b=8

def test(a):
    print(a)
    print(b)
    b=9
test(1)
输出结果：
1
Traceback (most recent call last):
  File "c:/Users/DELL/Desktop/ssj/search/descrip.py", line 9, in <module>
    test(1)
  File "c:/Users/DELL/Desktop/ssj/search/descrip.py", line 6, in test
    print(b)
UnboundLocalError: local variable 'b' referenced before assignment

        这是因为，python编译函数定义时，判断b是局部变量，因为在函数体中给b赋值了，但是当获取局部b时，发现b没有绑定值，所以print（b）才会报错。python不要求声明变量，假设在函数体对变量赋值，那他就是局部变量。获取不到存在的局部变量时，也不会获取全局变量，所以报错。

闭包

        闭包是函数内部定义函数，如下形式：

def deco():
    l=[]
    def test(a):
        l.append(a)
    return test

上述2,3,4行一起称为闭包，l称为自由变量，闭包是一种函数，它会保留定义函数时存在的自由变量的绑定，调用函数时，虽然定义作用域不可用了，但是仍可以使用那些绑定。
如下例子：

def make_averager():
    count = 0
    total = 0
    def averager(new_value):
        count += 1
        total += new_value
        return total / count
    return averager

r = make_averager()
print(r(10))
输出结果：
Traceback (most recent call last):
  File "c:/Users/DELL/Desktop/ssj/search/descrip.py", line 15, in <module>
    print(r(10))
  File "c:/Users/DELL/Desktop/ssj/search/descrip.py", line 9, in averager
    count += 1
UnboundLocalError: local variable 'count' referenced before assignment

        显然，使用闭包时，变量是不可变类型时会报错。这是因为count += 1实际上是给count赋值，这会把count当成局部变量的，这样count就不是自由变量了，不会保存在闭包中。当变量是可变类型时，如list，当操作l.append()时，没有对l进行赋值，不会当成局部变量。但是对于不可变类型，只能读取，不能更新，如可以print(x)，但是不能对x赋值或者更新，当然，不可变类型的更新也是特殊的赋值。
        变量是不可变类型时，这个时候可以使用nonlocal声明，nonlocal是将变量标记为自由变量，可以保存到闭包中：

def make_averager():
    count = 0
    total = 0
    def averager(new_value):
        nonlocal count, total
        count += 1
        total += new_value
        return total / count
    return averager

r = make_averager()
print(r(10))
print(r(14))
输出结果：
10.0
12.0

装饰器

        python的装饰器是通过闭包实现的，
        对于python来讲，装饰器是一个可调用对象，他的参数是一个函数。如下简单示例：

def deco(f):
    def warp(*args,**kv):
        f(*args,**kv)
        print("----")
    return warp

@deco
def test(a,b):
    print(a,b)

test(3,b=5)
print(test.__name__)
输出结果：
3 5
----

warp
        实际上，被装饰器修饰后的函数相当于被替换了，下面写法与上面等效：

from functools import wraps

def deco(f):
    def warp(*args,**kv):
        f(*args,**kv)
        print("----")
    return warp

def test(a,b):
    print(a,b)

test = deco(test)
test(3,5)

        上述装饰器有个缺点，遗失了__name__和__doc__属性，可以使用标准库functools中的内置装饰器wraps把相关的属性复制过来：

from functools import wraps

def deco(f):
    @wraps(f)
    def warp(*args,**kv):
        f(*args,**kv)
        print("----")
    return warp

@deco
def test(a,b):
    print(a,b)

test(3,b=5)
print(test.__name__)
输出结果：
3 5
----
test

        functools中还有一个非常重要的装饰器lru_cache，可以用于记录，可以把耗时的函数结果保存起来，避免重复计算。最常用于递归中，因为一般递归函数会有很多重复的计算，十分耗时，而lru_cache装饰器的备忘功能，可以有效避免重复运算，是递归优化的一项重要举措。
带参数的装饰器：

from functools import wraps

def reg(act=None):
    def deco(f):
        @wraps(f)
        def warp(*args,**kv):
            f(*args,**kv)
            print("----")
            print(act)
        return warp
    return deco

@reg(act="asd")
def test(a,b):
    print(a,b)

test(3,b=5)
输出结果：
3 5
----
asd

装饰器有两个明显特性：

• 一：装饰器把函数替换成了另一个函数
• 二：装饰器在加载模块时立即执行

如下例子可以证明装饰器在模块被加载时执行：

l = []

def deco(f):
    def warp(*args,**kv):
        f(*args,**kv)
        print("----")
    l.append(f)
    return warp
@deco
def test(a):
    print(a)
@deco
def test1(a):
    print(a)

def test2(a):
    print(a)

print(l)
输出结果：
[<function test at 0x0000022CD8AD19D8>, <function test1 at 0x0000022CD8C3A6A8>]