关于Python中闭包和装饰器

装饰器

1.作为Python面试中必问到的关键点—装饰器,程序开发中用的好,开发如虎添翼; 主要运用在 不能对被修饰的函数源代码进行修改, 和调用方式进行更改的情况下, 为函数添加其他功能;

2装饰器本质：使用“@函数装饰器名称”修饰原函数，等同于创建与原函数名称相同的变量，关联内嵌函数；故调用原函数时执行内嵌函数。

3.装饰器主要的作用如下:
1、引入日志
2、函数执行时间统计
3、执行函数前预备处理
4、执行函数后清理功能
5、权限校验等场景
6、缓存

4.装饰器大致流程如下:

    1.执行外部函数, 原函数作为参数传递给到外层函数的形参

    2.定义一个内层函数, 并且内层函数使用外层函数的变量,并调用传递进来的原函数的引用

    3.外层函数的返回内层函数的引用,且调用内层函数

def 函数装饰器名称(func):
    def 内嵌函数(*args, **kwargs):
        需要添加的新功能
        return func(*args, **kwargs)
return wrapper

@ 函数装饰器名称
def 原函数名称(参数):
		函数体

原函数(参数)

5.被装饰器修饰的函数或者方法,可以是无参数的, 有参数的,不定参数的, 也可以是有返回值的, 也可以是无返回值的,也可以用作类装饰器(当然这个资源消耗较高,不建议使用), 装饰器大致的模板如下:

def set_func(func):
    print("开始准备装饰器...")
    def call_func(*args, **kwargs): # 这个地方的参数的可以是无参数,有参数,以及不定长参数
        print("执行装饰器内部方法...")
        return func(*args, **kwargs)# 这个地方的*代表的是拆包, 传递的元祖,字典内容到func方法中的,而不是元祖和字典两个参数

    return call_func


@set_func  # 相当于 test = set_func(test)
def test():
    print("test")


test()

#运行结果:
#开始准备装饰器...
#执行装饰器内部方法...
#test

6.多个装饰器修饰一个函数的情况, 是以就近原则的, 先调用靠近原函数的外部函数,后执行靠近函数的内部函数

经典面试题 装饰器本质

def set_func_1(func):  
    print("开始准备装饰器1...")  
    def call_func(*args, **kwargs):  
        print("执行装饰器内部方法1...")  
        return func(*args, **kwargs) 
    return call_func  


def set_func_2(func):  
    print("开始准备装饰器2...")  
    def call_func(*args, **kwargs):  
        print("执行装饰器内部方法2...")  
        return func(*args, **kwargs)  
    return call_func  

 
@set_func_1  

@set_func_2  

def test():  
    print("test")  

test()  

  
#运行结果:  

#开始准备装饰器2...  

#开始准备装饰器1...  

#执行装饰器内部方法1...  

#执行装饰器内部方法2...  

#test  

闭包

闭包的三要素:1. 函数的嵌套 ; 2.内层函数使用外层函数的变量 ;3.外层函数返回内层函数的引用

  定义：
def 外部函数名(参数):
		 外部变量
		def 内部函数名(参数):
			使用外部变量
		return 内部函数名
-- 调用：
	   变量 = 外部函数名(参数)
	   变量(参数)

1、举个栗子：

# 定义一个外部函数
def test(number):

    # 在函数内部再定义一个函数，并且这个函数用到了外边函数的变量，那么将这个函数以及用到的一些变量称之为闭包
    def test_in(number_in):
        print("in test_in 函数, number_in is %d" % number_in)
        return number+number_in
    # 其实这里返回的就是闭包的结果
    return test_in


# 给test函数赋值，这个20就是给参数number
ret = test(20)

# 注意这里的100其实给参数number_in
print(ret(100))

#注 意这里的200其实给参数number_in
print(ret(200))


运行结果如下:

in test_in 函数, number_in is 100
120

in test_in 函数, number_in is 200
220

2、修改闭包中外部函数的变量

在闭包内部需要使用nonlocal 关键字 来修改外部函数的变量
下面补充一下nonlocal关键字：(通过与global关键字进行对比)

第一，两者的功能不同。global关键字修饰变量后标识该变量是全局变量，对该变量进行修改就是修改全局变量，而nonlocal关键字修饰变量后标识该变量是上一级函数中的局部变量，如果上一级函数中不存在该局部变量，nonlocal位置会发生错误（最上层的函数使用nonlocal修饰变量必定会报错）。

第二，两者使用的范围不同。global关键字可以用在任何地方，包括最上层函数中和嵌套函数中，即使之前未定义该变量，global修饰后也可以直接使用，而nonlocal关键字只能用于嵌套函数中，并且外层函数中定义了相应的局部变量，否则会发生错误（见第一）。

def counter(start=0):
    def incr():
        nonlocal start
        start += 1
        return start
    return incr

c1 = counter(5)
print(c1())
print(c1())

c2 = counter(50)
print(c2())
print(c2())

运行结果是:
6
7
51
52

经典面试题

def func(a):
    def call_func(x):
        return a * x
    return call_func


flist = [func(a) for a in range(3)] # 闭包中的三个函数分别是独立的空间 ,变量a的值均不同
print(flist[0](1))
print(flist[1](1))
print(flist[2](1))
print("*" * 30)
flist = [lambda x: a * x for a in range(3)] # 匿名函数方式中变量a指向是一致的,导致a的值被覆盖,最后结果全部是2
print(flist[0](1)) 
print(flist[1](1))
print(flist[2](1))


# 运行结果如下:

0
1
2
******************************
2
2
2

闭包的缺点：外部变量一直存在于内存中，不会在调用结束后释放，占用内存。
第二次打印函数结果全为2的原因是 Python 闭包的延迟绑定。
这意味着内部函数被调用时，参数的值在闭包内进行查找。因此，当任何由 func()返回的函数被调用时，a的值将在附近的范围进行查找。那时，不管返回的函数是否被调用，for 循环已经完成，被赋予了最终的值 2