Python第十课(函数3)

def func():
    name = jason‘  # 先在内部找name没有再往上层找 有了就停止查找
    def inner():
        print(name)  # 现在内部找name没有再往上层找
    return inner
f = func()  # f获取到的是inner的内存地址
f()  # 相当于执行 inner()
# 函数在定义阶段名字的查找孙旭就已经固定死了，不会因为函数调用位置的变化而变化

def index(name):
    print(name)

def outter(name):
    # name = ‘jason‘
    def index():
        print(name)
    return index

def new():
    print(‘这是原始函数‘)
 
def outter(func):
    def inner():
        print(‘这是内部函数，这里可以加新功能‘)
        func()  # 这里的func是你想调用的最原始的函数的内存地址,加上()直接调用
        print(‘这是内部函数，这里可以加新功能‘)
    return inner  # 这里不加括号 返回的是inner函数的内存地址
new = outter(new)  # 括号内的new指向的是最原始的new函数的内存地址，前面的new获取的是outter函数的返回值，返回值我们自定义了返回 inner函数的内存地址
# 总结：前面的new获取的是inner的内存地址，后面括号内的new指向的就是最原始的new的内存地址
new()

import time
time.time()  获取时间戳(秒)    当前时间距离1970-1-1 00:00:00 所经过的秒数
time.sleep(seconds)  让程序暂定几秒钟

# 先写装饰器
def outter(func):
    def inner():
        print(‘这里可以加新功能‘)
        func()  # 这里的func是你想调用的最原始的函数的内存地址,加上()直接调用
        print(‘这里可以加新功能‘)
    return inner  # 这里不加括号 返回的是inner函数的内存地址
 
@outter  #  new = outter(new) 把装饰器赋值给最近的可调用对象，并将对象名传入。
def new():
    print(‘这是原始函数‘)
 
new()

from functools import wraps
def outter(func):
    @ wraps(func)  #  装饰器修复加在最内层函数正上方 
    def inner(*args,**kwargs):  # * **在形参中使用
        # 执行被装饰函数之前你可以做的操作
        res = func(*args,**kwargs)  # * 
        # 执行被装饰函数之后你可以做到操作
        return res
    return inner
@outter
def index(username,*args,**kwargs):
    """index注释"""
    pass
print(index)

from functools import wraps
def outter(func):
    @wraps(func)  # 加在最内层函数正上方
    def inner(*args,**kwargs):  # *和**在形参中使用
        print(‘这里可以加新功能‘)  # 执行被装饰函数之前你可以做的操作
        func(*args,**kwargs)  # 这里的func是你想调用的最原始的函数的内存地址,加上()直接调用， *和**在实参中使用
        print(‘这里可以加新功能‘)  # 执行被装饰函数之后你可以做到操作
    return inner  # 这里不加括号 返回的是inner函数的内存地址
@outter  #  new = outter(new) 把装饰器赋值给最近的可调用对象，并将对象名传入。
def new():
    print(‘这是原始函数‘)
new()

from functools import wraps
choice = input(‘>>>:‘)
def wrappers(data):
    def outter(func):
        @wraps(func)  # 加在最内层函数正上方
        def inner(*args,**kwargs):
            if data == ‘1‘:  # 如果用户输入‘1’那么执行index()
                # 执行被装饰函数之前你可以做的操作
                res = func(*args,**kwargs)  # * **在实参中使用    res接收原始函数的返回值
                # 执行被装饰函数之后你可以做到操作
                return res
            return 999
        return inner
    return outter
@wrappers(choice)  # index = wrappers(index)
def index()
    print(‘123‘)
    return  666  # 原始函数的返回值
index()

def outter1(func1): #func1=wrapper2的内存地址
    print(‘加载了outter1‘)
    def wrapper1(*args,**kwargs):
        print(‘执行了wrapper1‘)
        res1=func1(*args,**kwargs)
        return res1
    return wrapper1
def outter2(func2): #func2=wrapper3的内存地址
    print(‘加载了outter2‘)
    def wrapper2(*args,**kwargs):
        print(‘执行了wrapper2‘)
        res2=func2(*args,**kwargs)
        return res2
    return wrapper2
def outter3(func3): # func3=最原始的那个index的内存地址
    print(‘加载了outter3‘)
    def wrapper3(*args,**kwargs):
        print(‘执行了wrapper3‘)
        res3=func3(*args,**kwargs)
        return res3
    return wrapper3
@outter1 # outter1(wrapper2的内存地址)======>index=wrapper1的内存地址
@outter2 # outter2(wrapper3的内存地址)======>wrapper2的内存地址
@outter3 # outter3(最原始的那个index的内存地址)===>wrapper3的内存地址
def index():
    print(‘from index‘)
print(‘======================================================‘)
index()
# 1. 加载顺序(outter函数的调用顺序):自下而上
# 2. 执行顺序(wrapper函数的执行顺序):自上而下