其他分享
首页 > 其他分享> > 7.11函数(二)

7.11函数(二)

作者:互联网

一、闭包函数

1.什么是闭包函数:

(1)闭:定义在函数内部的函数

(2)包:内部函数引用了外部函数作用域的名字

2.给函数传值的两种方式

(1)传参

def index(name):
    print(name)
index('francis')  # 传参

(2)闭包

def outter(x,y):
    # x = 1 通过传参获得
    # y = 40 通过传参获得
    def my_max():
        if x > y:
            return x
        return y
    return my_max
res = outter(1,40)  # res就是my_max函数的内存地址
print(res())  # 调用函数my_max,会去函数outter中取参数,这就是内部函数引用了外部函数作用域的名字

二、装饰器

1.什么是装饰器:

装饰:给被装饰对象添加新的功能

器:就是一个工具

2.为什么要用装饰器

(1)装饰器遵循开放封闭的原则

开放:对扩展开放(能对原来的函数添加功能)

封闭:对修改封闭(不能修改原来的函数功能)

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

  1.不改变被装饰对象(原函数)的源代码

  2.不改变被装饰对象(原函数)的调用方式

3.补充知识:

import time  # 调用模块
print(time.time())  # 打印时间戳,打印的是当前时间距离1970-1-1 00:00:00相差的秒数(1970-1-1 00:00:00是Unix诞生元年)
time.sleep(3)  # 让cpu睡三秒,传参数,表示让你的程序暂停几秒
print('程序停了3秒')

三、装饰器简单版本

1.用函数实现让程序停3秒,再执行打印功能

import time
def index():
    time.sleep(3)
    print('程序停了3秒')
index()

2.如何实现:

统计执行index函数(上面的)共用了几秒,且不改变原函数的调用方式和源代码。

import time
def index():
    time.sleep(3)
    print('程序停了3秒')

def outter(func):  # func = index  就是最原始的index函数的内存地址
    def get_time():
        start = time.time()  # 统计时间戳
        func()  # func = index  加括号调用最原始的index函数(让程序停3秒的函数)
        end = time.time()  # 统计时间戳
        print('index运行了:%s'%(end-start))  # 两次统计时间戳,用了几秒
    return get_time  # 返回get_time函数的内存地址
index = outter(index)  # outter(index)执行之后返回的是get_time函数的内存地址
# 所以第一个index指向get_time函数的内存地址,第二个index是最原始的index函数内存地址(让程序停3秒的函数)
index()  # 就相当于get_time函数加上括号调用了

四、装饰器升级版

1.如何实现:

用一个装饰器装饰两个函数,其中一个不用传参,一个需要传参,且该装饰器的返回值就是原函数的返回值,原函数:

import time
def index():
    time.sleep(3)
    print('程序停了3秒')
    return 'index的返回值'
res = index()
print(res)

def login(name):
    time.sleep(1)
    print('%s是帅比'%name)
    return 'login的返回值'
res1 = login('francis')
print(res1)

2.实现:

import time
def index():
    time.sleep(3)
    print('程序停了3秒')
    return 'index的返回值'

def login(name):
    time.sleep(1)
    print('%s是帅比'%name)
    return 'login的返回值'

def outter(func):  # func = 最原始的index或者login函数的内存地址
    def get_time(*args, **kwargs):  # *和**在形参中的用法,接收多余的位置参数和关键字参数
        start = time.time()
        res = func(*args, **kwargs)  # 最原始的index或者login函数的内存地址,加括号调用,并接收原函数的返回值
        # *和**在实参中的用法,打散容器类型中的参数和字典中的参数
        end = time.time()
        print('%s函数运行了:%s'%(func,end-start))
        return res  # 返回原函数的返回值
    return get_time
index = outter(index)  # 第二个index是最原始的index函数的内存地址
res = index()
print(res)  # 原index函数的返回值

login = outter(login)  # 第二个login是最原始的login函数的内存地址
res1 = login('francis')
print(res1)  # 原login函数的返回值
View Code

实现了无参函数和有参函数都可以直接调用同一个装饰器(装饰器可以接收任意数量的参数)

五、装饰器语法糖

1.上述实现的装饰器中,如果想要装饰某个函数,需要代码比如:index = outter(index)、login = outter(login)来实现,很麻烦,这时候可以用到装饰器语法糖。

import time

def outter(func):  # func = 最原始的index或者login函数的内存地址
    def get_time(*args, **kwargs):  # *和**在形参中的用法,接收多余的位置参数和关键字参数
        start = time.time()
        res = func(*args, **kwargs)  # 最原始的index或者login函数的内存地址,加括号调用,并接收原函数的返回值
        # *和**在实参中的用法,打散容器类型中的参数和字典中的参数
        end = time.time()
        print('%s函数运行了:%s'%(func,end-start))
        return res  # 返回原函数的返回值
    return get_time

@outter  # index = outter(index)
def index():
    time.sleep(3)
    print('程序停了3秒')
    return 'index的返回值'

@outter  # login = outter(login)
def login(name):
    time.sleep(1)
    print('%s是帅比'%name)
    return 'login的返回值'

res = index()
print(res)  # 原index函数的返回值
res1 = login('francis')
print(res1)  # 原login函数的返回值
View Code

@outter会将紧挨着他的可调用对象当作他的参数传入直接执行,并接收返回值

2.书写规范:

语法糖在书写的时候应该与被装饰对象紧紧挨着,两者之间不要有空格

六、装饰器模板

def outter(func):
    def inner(*args,**kwargs):
        print('执行被装饰函数之前,你可以做的操作')
        res = func(*args,**kwargs)
        print('执行被装饰函数之后,你可以做的操作')
        return res
    return inner

1.如何实现一个认证装饰器:

执行函数index之前必须先输入用户名和密码,正确之后才能执行index,如果之后再执行函数login,则不需要再登录

import time
user_dic = {'is_login':None}  # 全局定义一个空字典,判断用户是否已登录过
def outter(func):
    def inner(*args,**kwargs):
        if user_dic['is_login']:  # 判断是否已登录
            res = func(*args, **kwargs)  # 登陆过直接执行原函数
            return res
        else:
            username = input('please input your username>>>:').strip()
            password = input('please input your password>>>:').strip()
            if username == 'francis' and password == '123':
                user_dic['is_login'] = True  # 登陆成功后,修改字典为True
                res = func(*args,**kwargs)
                return res
            else:
                print('username or password error')
    return inner

@outter  # index=outter(index)
def index(name):
    time.sleep(1)
    print('%s是帅比'%name)
    return 666

@outter  # login=outter(login)
def login():
    time.sleep(1)
    print('from login')
    return 999

print(index('francis'))
print(login())
View Code

七、多层装饰器

1.给index函数套多个装饰器,使index函数先执行认证功能再统计函数运行时间

import time
user_dic = {'is_login':None}  # 全局定义一个空字典,判断用户是否已登录过
def outter(func):
    def inner(*args,**kwargs):
        if user_dic['is_login']:  # 判断是否已登录
            res = func(*args, **kwargs)  # 登陆过直接执行原函数
            return res
        else:
            username = input('please input your username>>>:').strip()
            password = input('please input your password>>>:').strip()
            if username == 'francis' and password == '123':
                user_dic['is_login'] = True  # 登陆成功后,修改字典为True
                res = func(*args,**kwargs)
                return res
            else:
                print('username or password error')
    return inner

def outter1(func):  # func = 最原始的index或者login函数的内存地址
    def get_time(*args, **kwargs):  # *和**在形参中的用法,接收多余的位置参数和关键字参数
        start = time.time()
        res = func(*args, **kwargs)  # 最原始的index或者login函数的内存地址,加括号调用,并接收原函数的返回值
        # *和**在实参中的用法,打散容器类型中的参数和字典中的参数
        end = time.time()
        print('%s函数运行了:%s'%(func,end-start))
        return res  # 返回原函数的返回值
    return get_time

@outter  # index=outter(get_time)   index=inner函数的地址
@outter1  # get_time=outter1(index)   index是最原始的index的内存地址
def index():
    time.sleep(3)
    print('index')
    return 'from index'
index()
View Code

方法是在index函数上套两个装饰器语法糖

2.着重注意:

(1)装饰器在装饰函数的时候,执行顺序是是从下往上(紧贴函数到远离函数)

(2)装饰器在执行的时候,执行顺序是从上往下的(离被装饰的函数最远的装饰器最先执行,最后执行的是紧贴函数的装饰器)

八、装饰器修复技术

1.作用

(1)用户查看被 装饰了的函数 的函数名的时候,看到的就是 原函数 的内存地址

(2)用户查看被 装饰了的函数 的注释的时候,看到的就是 原函数 的注释

2.如何用

from functools import wraps
def outter(func):
    @wraps(func)  # 装饰器修复技术
    def inner(*args,**kwargs):
        '''
        这是inner函数
        :param args:
        :param kwargs:
        :return:
        '''
        print('执行被装饰函数之前 你可以执行的操作')
        res = func(*args,**kwargs)
        print('执行被装饰函数之后 你可以执行的操作')
        return res
    return inner

@outter  # index = outter(最原始的index的内存地址)
def index():
    '''
    这是index函数
    :return:
    '''
    pass
print(index)  # 查看函数的内存地址  返回的就是原函数index的
print(help(index))  # 查看函数的注释  返回的就是原函数index的
print(index.__name__)  # 查看函数名字符串形式  返回的就是index
View Code

(1)在装饰器外导入一个模块:from functools import wraps

(2)在装饰器里写入:@wraps(func),括号内的形参与装饰器内的一致

九、多层装饰器

1.习题:求index运行之后的打印结果

def outter1(func1):
    print('加载了outter1')
    def wrapper1(*args,**kwargs):
        print('执行了wrapper1')
        res1=func1(*args,**kwargs)
        return res1
    return wrapper1
def outter2(func2):
    print('加载了outter2')
    def wrapper2(*args,**kwargs):
        print('执行了wrapper2')
        res2=func2(*args,**kwargs)
        return res2
    return wrapper2
def outter3(func3):
    print('加载了outter3')
    def wrapper3(*args,**kwargs):
        print('执行了wrapper3')
        res3=func3(*args,**kwargs)
        return res3
    return wrapper3
@outter1  # index = outter1(wapper2)
@outter2  # wrapper2 = outter2(wrapper3)
@outter3  # wrapper3 = outter3(index)  最原始的index的内存地址
def index():
    print('from index')
index()
View Code

2.代码执行顺序:

标签:index,return,7.11,time,print,def,函数
来源: https://www.cnblogs.com/francis1/p/11178574.html