本章主要学习，python的装饰方法，你可以认为就是方法切面，就是执行目标方法之前或之后都可以执行其他函数。

1、locals()

• 打印本地变量

# 先定义一个简单函数返回1
def func():
    return 1

print(func())

s = 'Global Variable'

# 定义函数，然后打印本地变量
def check_for_locals():
    a = 1
    b = 2
    print(locals())

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

2、globals()

• 打印全局变量，就是整个py文件方法和属性

# 打印全局变量和方法
print(globals())

print(globals().keys())

# 打印内部变量， {'a': 1, 'b': 2}
check_for_locals()

1
2
3
4
5
6
7
8

3、函数引用

• 不带() 表示函数引用，加上()表示调用该方法
• 删除，函数引用可以删除，del 函数引用，但是这个删除不会影响到，原来赋值函数引用变量引用，说明本质方法没有删除。

# 方法可以赋值，方法可以删除
def hello(name = 'Jose'):
    return 'Hello ' +name

print(hello())

# 将hello 方法赋值给greet
greet = hello
print(greet)
print(greet())

# 删除hello方法， greet()方法还可以使用，也就是说，这个对象不会删除
# del hello
hello()

greet()

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

4、函数嵌入函数

• 函数中还可以嵌入函数
• 既然我可以获得函数引用，我们是不是可以根据不同情况返回不同函数引用，执行不同方法调用呢， 是不是实现方法的多态，不需要在类上完成这个功能

def hello(name='Jose'):
    print('The hello() function has been executed')

    def greet():
        return '\t this is inside the greet() function'

    def welcome():
        return  '\t This is inside the welcome() function'

    print(greet())
    print(welcome())
    print('Now we are back inside the hello() function')
# 调用hello， greet， welcome
hello()


 # 我们改进一下，根据name不同返回不同的函数引用

def hello(name='Jose'):

    def greet():
        return '\t This is inside the greet() function'

    def welcome():
        return "\t This is inside the welcome() function"

    if name == 'Jose':
        return greet
    else:
        return welcome
# 可以直接返回函数, 可以根据入参选择不同方法
x = hello()
print(x())

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
35

5、函数引用可以作为函数入参

• 这样很容易实现装饰模式，在执行真正的方法之前做一些前置操作

# 函数作为入参

def hello():
    return 'Hi Jose!'

def other(func):
    print("Other code would go here")
    print(func())

#Other code would go here
#Hi Jose!
other(hello)

# 创建一个装饰类
def new_decorator(func):

    def wrap_func():
        print("Code would be here, before executing the func")
        func()
        print("Code here will execute after the func()")
    return wrap_func

def func_needs_decorator():
    print("This function s in need of a Decorator")
# 直接调用方法
func_needs_decorator()


# 组装一个装饰类函数
func_needs_decorator = new_decorator(func_needs_decorator)
func_needs_decorator()

#其实可以更简单使用注解的方式使用装饰
@new_decorator
def func_needs_decorator():
    print("This function is in need of a Decorator")

func_needs_decorator()

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
35
36
37
38
39

总结

1. locals() 和 globals()返回都是dictionary格式
2. 方法名不带() 表示函数引用，加上()表示调用该方法
3. 函数可以组装，也就是数学列函数一样
4. 支持动态装饰的注解，@函数名

参考文档

• https://github.com/Pierian-Data/Complete-Python-3-Bootcamp.git