Python第十课(函数3)_python

概述Python第十课(函数3) >>>转到思维导图>>>转到中二青年闭包函数 1.定义在函数内部的函数 2.内部函数内部函数引用了外部函数名称空间作用域的名字只要满足以上两点都叫做闭包函数 def func(): name = jason‘ # 先在内部找name没有再往上层找有了就停止查找 def inner(): print(name) #

Python第十课(函数3) >>>转到思维导图>>>转到中二青年

闭包函数

1.定义在函数内部的函数

2.内部函数内部函数引用了外部函数名称空间作用域的名字

只要满足以上两点都叫做闭包函数

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

给函数传参的两种方式

1.直接传参

def index(name):    print(name)

2.闭包

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

装饰器

器：就是一个工具

装饰：就是给被装饰对象添加新的功能

开放封闭原则：

开放：对扩展开放

封闭：对修改封闭

装饰器(可调用对象)必须遵循的两个原则：

1.不改变被装饰对象的源代码

2.不改变被装饰对象(可调用对象)调用方法

可调用：callable

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

import timetime.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()

装饰器修复技术

1.返回原来的函数的函数名

2.返回原来的函数的注释

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

无参装饰器

from functools import wrapsdef 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 wrapschoice = 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()

多个装饰器

1. 装饰的时候从下往上执行

2. 执行的时候从上往下执行

def outter1(func1): #func1=wrapper2的内存地址    print(‘加载了outter1‘)    def wrapper1(*args,**kwargs):        print(‘执行了wrapper1‘)        res1=func1(*args,**kwargs)        return res1    return wrapper1def outter2(func2): #func2=wrapper3的内存地址    print(‘加载了outter2‘)    def wrapper2(*args,**kwargs):        print(‘执行了wrapper2‘)        res2=func2(*args,**kwargs)        return res2    return wrapper2def 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函数的执行顺序):自上而下