闭包

初识闭包
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
def key(key):
    num = key
    def encrypt(content):
        num2 = num + 'nb' + content
        print(num2)
    return encrypt
f = key('6')
f('8')
def call_me(name):
    def respond_to(info):
        return name + ": " + info
    return respond_to
ergou = call_me('ergou')
print(ergou('gun'))
# # 定义一个外部函数
# def func_out(num1):
#     # 定义一个内部函数
#     def func_inner(num2):
#         # 内部函数使用了外部函数的变量(num1)
#         result = num1 + num2
#         print("结果是:", result)
#     # 外部函数返回了内部函数，这里返回的内部函数就是闭包
#     return func_inner
#
# # 创建闭包实例
# f = func_out(1)
# # 执行闭包
# f(2)
# f(3)

修饰器

初识修饰器
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
import time
def get_time(fn):
    def iner():
        begin = time.time()
        fn()
        end = time.time()
        print(f'函数花费了{end - begin}')
        return end - begin
    return iner
@get_time  # @check 等价于 comment = check(comment)
def func1():
    for i in range(3):
        time.sleep(0.5)
        print(i + 1)
func1()
print(func1())
'''
装饰器本质上就是一个闭包函数，它可以对已有函数进行额外的功能扩展。
装饰器的语法格式:
# 装饰器
# def decorator(fn): # fn:被装饰的目标函数.
#     def inner():
#         ''执行函数之前''
#         fn() # 执行被装饰的目标函数
#         ''执行函数之后''
#     return inner
'''
带参数的修饰器
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 带有参数的装饰器
# 装饰器本身只能接收一个参数，而且必须为函数
def speak(str):
    def dec(fn):
        def prt():
            print('做事前开始BB' + str)
            fn()
            print('做事后开始BB' + str)
        return prt
    return dec
@speak('你在干啥')
def do_work():
    print('冲冲冲')
do_work()