函数的作用域

name = "jack"  # 全局作用域

def run():
    name = "rose"  # 局部作用域
    def inner():
        print(name)
    return inner
    
v1 = run()
v1()

v2 = run()
v2()
1
2
3
4
5
6
7
8
9
10
11
12
13

当执行v1()时，inner()中的name会在自己的作用域中查找，因此name为rose。
同理，执行v2()时，也会在自己的作用域中查找，因此name为rose。

闭包

闭包，简而言之就是将数据封装在一个包（区域）中，使用时再去里面取。（本质上 闭包是基于函数嵌套搞出来一个中特殊嵌套）
闭包应用场景1：封装数据防止污染全局。

def func(age):
    name = "jack"

    def f1():
        print(name, age)

    def f2():
        print(name, age)

    def f3():
        print(name, age)

    f1()
    f2()
    f3()

func(20)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

闭包应用场景2：封装数据封到一个包里，使用时在取。

def task(arg):
    def inner():
        print(arg)
    return inner

v1 = task(11)
v2 = task(22)
v3 = task(33)
v1() # 自己的作用域中arg=11
v2() # 自己的作用域中arg=22
v3() # 自己的作用域中arg=33
1
2
3
4
5
6
7
8
9
10
11

装饰器

def outer(origin):
    def inner(*args, **kwargs):
        print("before 110")
        res = origin(*args, **kwargs)  # 调用原来的func函数
        print("after")
        return res

    return inner


@outer  # func1 = outer(func1)
def func1(a1):
    print("我是func1函数")
    value = (11, 22, 33, 44)
    return value


@outer  # func2 = outer(func2)
def func2(a1, a2):
    print("我是func2函数")
    value = (11, 22, 33, 44)
    return value


@outer  # func3 = outer(func3)
def func3(a1):
    print("我是func3函数")
    value = (11, 22, 33, 44)
    return value


func1(1) # 每个函数可以有自己的对应的参数
func2(11, a2=22)
func3(999)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

实现原理：基于@语法和函数闭包，将原函数封装在闭包中，然后将函数赋值为一个新的函数（内层函数），执行函数时再在内层函数中执行闭包中的原函数。

可以在不改变原函数内部代码 和 调用方式的前提下，实现在函数执行和执行扩展功能。

适用场景：多个函数系统统一在执行前后自定义一些功能。

def outer(origin):
    def inner(*args, **kwargs):
		# 执行前
        res = origin(*args, **kwargs)  # 调用原来的func函数
        # 执行后
        return res
    return inner


@outer
def func():
    pass

func()
1
2
3
4
5
6
7
8
9
10
11
12
13
14

functools

上面的装饰器，一般情况下是没有问题的。

但是如果有下面的需求，就有可能出现问题：

def handler():
    pass

handler()
print(handler.__name__) # handler
1
2
3
4
5

def auth(func):
    def inner(*args, **kwargs):
        return func(*args, **kwargs)
    return inner

@auth
def handler():
    pass

handler()
print(handler.__name__) # inner
1
2
3
4
5
6
7
8
9
10
11

可以发现装饰器实际上就是将原函数更改为其他的函数，然后再此函数中再去调用原函数。

如果我们想获取函数的函数名，可以使用functools来实现。

import functools


def auth(func):
    @functools.wraps(func)
    def inner(*args, **kwargs):
        """这里是inner的注释"""
        res = func(*args, **kwargs)  # 执行原函数
        return res

    return inner
1
2
3
4
5
6
7
8
9
10
11