第十七篇 Python函数之闭包与装饰器

一. 装饰器

装饰器：可以拆解来看，器本质就是函数，装饰就是修饰的意思，所以装饰器的功能就是为其他函数添加附加功能。

装饰器的两个原则：

1. 不修改被修饰函数的源代码

2. 不修改被修饰函数的调用方式

实现装饰器的知识储备：装饰器 = 高阶函数 + 函数嵌套 + 闭包

高阶函数

高阶函数的定义：

1. 函数接收的参数是一个函数名

2. 函数的返回值是一个函数名

3.满足上述条件任意一个，都可以称之为高阶函数

import  time

# 示例1： 函数接收的参数是一个函数名

# def foo():

#     print("Hello")

#

# def test(func):

#     print(func)

#     func()

#

# test(foo)

# 示例2：函数test接收的参数是一个函数名foo,可以直接为foo函数增加一个功能

# 需求：想统计foo运行的时间，结果这个高阶函数修改了函数的源代码

# def foo():

#     time.sleep(2)

#     print("Hello")

#

# def test(func):

#     print(func)

#     start_time = time.time()

#     func()

#     stop_time = time.time()

#     print('函数的运行时间是:%s '%(stop_time-start_time))  # 统计的是func()的运行时间，即foo的运行时间

#

# test(foo)

# 示例3：函数的返回值是一个函数名

def foo():

    print("from the foo")

def test(func):

    return func

# 实现了装饰器的不改变函数的调用方式这个功能

foo = test(foo)

foo()

# 示例4： 示例2+示例3就能实现一个半完整的装饰器

def foo():

    time.sleep(3)

    print('来自foo')

# 不修改foo源代码

# 不修改foo调用方式

# 没有修改被修饰函数的源代码，也没有修改被修饰函数的调用方式，但是也没有为被修饰函数添加新功能

def timer(func):

    start_time = time.time()

    func()

    stop_time = time.time()

    print('函数的运行时间是:%s '%(stop_time-start_time))  # 统计的是func()的运行时间，即foo的运行时间

    return func

foo = timer(foo)  # timer函数的返回值是foo，在把返回值又赋值给了foo，得到一个内存地址

foo()   #  有了内存地址，直接加个()就可以运行。

# 结果

# 来自foo

# 函数的运行时间是:3.001082420349121

# 来自foo      # 上面说的是半完整的装饰器，是因为这里多运行了一次foo，肯定不行那，这就导致这个装饰器就不合格了

函数嵌套

# 函数嵌套及作用域
# father()函数里嵌套了一层son()函数，son()函数里又嵌套了一层grandson()函数

def father(name):

    print('from father %s' %name)     # name变量的作用域，是传进来的DDD

    def son():                     # 函数也是变量

        name='abc'

        print('我的爸爸是%s' %name)    # 作用域是son函数自己定义的name变量

        def grandson():

            print('我的爷爷是%s' % name)    # grandson函数没有自己的name变量，需要往上一级一级找，找到了son函数，就是abc

        # 同调用son的道理一样，需要通过father调用son，通过son函数再调用grandson函数

        grandson()

    # 如果要调用son函数，不能跑到father的外面去调用，会报错；只能通过调用father来调用son函数

    # 此处是调用son函数

    son()

father('DDD')
son('abcx') # 报错   # son函数定义在father里，所以只能通过father调用son函数

闭包

上面理解了函数的层级嵌套，就很好理解闭包的概念。嵌套的函数换个名称叫闭包

包:就像一个盒子套着一个盒子，一层层往外套，每一次都是一个包

闭：就是封装，封装变量。每个包都有被封装的变量。

下面画图解释

闭包如何找变量？

还是先从自己的闭包里开始找变量，自己没有在往上一层包里找变量，如果还没有，可以一直往外找，可以一直找到最外层

装饰器基本实现

首先，

# 搭个装饰器的架子，满足高阶函数，满足函数嵌套

import time

def timer(func):

    def wrapper():

        # print(func)   # 嵌套函数也可以获取传入的参数，传入的参数也是个函数，作用域在起作用  这是个内存地址

        func()        # 有了内存地址，加（）就可以执行func函数

    return wrapper

def test():

    time.sleep(2)

    print("test函数运行完毕")

其次，

有个需求：不修改test函数的原代码，也不修改test函数的调用方式，而且为test函数增加一个统计运行时间的功能

实现该需求的流程分析及代码运行过程：

# 流程分析：

# 1. 把test函数传给timer,直接返回的是wrapper的地址，而没有运行wrapper函数

res = timer(test)

# 2. 上面返回的是wrapper函数的内存地址，所以就可以直接加()执行wrapper函数

res()   # 执行的是wrapper函数

# 3. 再看wrapper函数做了什么？

# wrapper 函数运行的是func函数，而func函数就是传入的test()函数，所以执行wrapper就可以执行test()函数

# 所以，这个时候就可以添加代码来统计test函数的运行时间了。

至此，

# 上面的代码就演化成为：

def timer(func):

    def wrapper():

        start_time = time.time()

        func()

        stop_time = time.time()

        print("test函数的运行时长是： %s" % (stop_time - start_time))

    return wrapper

def test():

    time.sleep(2)

    print("test函数运行完毕")

res = timer(test)

res()

# 运行结果

test函数运行完毕

test函数的运行时长是： 2.000473976135254

但是，这里有 个问题，需求是不修改test函数的调研方式，test函数的调用方式应该是test(),而这里的调用方式是res()

所以，解决修改了test函数调用方式这个问题的方法：

# 将timer(test)的值赋给变量test

test = timer(test)

# 然后再test()调用，这样就达到了没有修改test函数调用方式的目的

test()

#到这里，一个装饰器的架子和调用模型就初步成型了，但是还需要赋值给test变量这一步操作

# 所以，最后，

python为了实现这个不修改test函数调用方式，也省略赋值这行代码，而产生了一个装饰器的概念

# 上面的代码就进化为：

# 装饰器

def timer(func):

    def wrapper():

        start_time = time.time()

        func()

        stop_time = time.time()

        print("test函数的运行时长是： %s" % (stop_time - start_time))

    return wrapper

@timer   #在test函数的顶头加上 @timmer来修饰test函数，  就相当于 test=timmer(test) 这个赋值动作

def test():

    time.sleep(2)

    print("test函数运行完毕")

# 有了装饰器，就可以直接调用test函数

test()

# 终于啊，老天爷啊，历经千辛万苦，终于完美的满足了最开始的需求

为闭包加上返回值

还是接上面的基本装饰器来说

def timer(func):

    def wrapper():

        start_time = time.time()

        func()

        stop_time = time.time()

        print("test函数的运行时长是： %s" % (stop_time - start_time))

    return wrapper

# 需求：给test函数加一个返回值: “test函数返回好消息了”

@timer

def test():

    time.sleep(2)

    print("test函数运行完毕")

    return "test函数返回好消息了"

res=test()

print(res)

#结果

test函数运行完毕

test函数的运行时长是： 2.000929117202759

None      返回None了

# 为什么会这样呢？分析如下：

# 1. 运行test函数，因为有装饰器，实际上运行的是wrapper这个闭包，而wrapper函数却没有返回值，所以返回的是None，那么给wrapper函数加个返回值呢？

代码如下：

def timer(func):

    def wrapper():

        start_time = time.time()

        func()

        stop_time = time.time()

        print("test函数的运行时长是： %s" % (stop_time - start_time))

        return 123   # 给wrapper函数加的返回值

    return wrapper

@timer

def test():

    time.sleep(2)

    print("test函数运行完毕")

    return "test函数返回好消息了"

res = test()

print(res)

# 结果

test函数运行完毕

test函数的运行时长是： 2.0010011196136475

123    # 返回的是123，

# 上面运行返回的是123，而我们的需求是要返回“test函数返回好消息了”

# 接着开，wrapper函数运行的是func函数，而func函数就是传入的test函数，所以把 func（）赋值给变量 res呢？

# 代码如下：

def timer(func):

    def wrapper():

        start_time = time.time()

        res = func()    # 赋值给res

        stop_time = time.time()

        print("test函数的运行时长是： %s" % (stop_time - start_time))

        return res      # 返回res

    return wrapper

@timer

def test():

    time.sleep(2)

    print("test函数运行完毕")

    return "test函数返回好消息了"

res = test()

print(res)

# 结果

test函数运行完毕

test函数的运行时长是： 2.0009818077087402

test函数返回好消息了

# 至此，给装饰器加上返回值就实现了。

# 但是还有个问题，如果直接调用test呢？

test()

# 结果如下，为什么？暂时还不明白

test函数运行完毕

test函数的运行时长是： 2.0001914501190186

为闭包加上参数

# 需求：给test传入参数

import time

def timmer(func): #func=test1

    def wrapper():

        start_time=time.time()

        res=func()

        stop_time = time.time()

        print('运行时间是%s' %(stop_time-start_time))

        return res

    return wrapper

@timmer #test=timmer(test)

def test(name,age):

    time.sleep(3)

    print('test函数运行完毕,名字是【%s】 年龄是【%s】' %(name,age))

    return '这是test的返回值'

res=test('lixiao',age=18)  #就是在运行wrapper

print(res)

#结果：

报错

为什么呢？

因为运行test就是在运行wrapper，而test传入了参数，wrapper里却没有接受参数，所以就报错了。那怎么改呢？

1. 礼尚往来，你给我得接着呀，所有wrapper需要有参数接受test传来的值。

2. wrapper 接受到了传来的值，wrapper函数体内，运行的res=func()实际上就是test（），所以，wrapper接受的参数也要传给func()才行。

import time

def timmer(func): #func=test1

    def wrapper(*args,**kwargs):

        start_time=time.time()

        res=func(*args,**kwargs)

        stop_time = time.time()

        print('运行时间是%s' %(stop_time-start_time))

        return res

    return wrapper

@timmer #test=timmer(test)

def test(name,age):

    time.sleep(3)

    print('test函数运行完毕,名字是【%s】 年龄是【%s】' %(name,age))

    return '这是test的返回值'

#备注：

wrapper(*args,**kwargs)：表示的是可变长参数

# *args:  代表把所有的位置参数接成列表

# **kwargs: 代表可能用户传值的时候通过关键字传值，比如用户传的值是age =18, 或者{"age": 18}形式的， 就用**kwargs来接

# 所以，*args,**kwargs ：代表可变长参数，传多少参数，任意形式的都可以接受了

@timmer

def test1(name,age,gender):

    time.sleep(1)

    print('test1函数运行完毕,名字是【%s】 年龄是【%s】 性别【%s】' %(name,age,gender))

    return '这是test的返回值'

test1('alex', 18, gender='male')

闭包：补充解压序列（很有用）

# 需求：有个很长的列表，拿出第一个和最后一个值

l = [1,2,4,5,6,123,34,1,6]

方式1：索引的方式

print(l[0])

print(l[-1])

方式2：解压序列方式

l = [1,2,4,5,6,123,34,1,6]

a, *_, c = l

print(a)    #

print(*_)   # 2 4 5 6 123 34 1

print(c)    #

# a 代表取第一个值

# * 代表所有的值，下划线_表示不要了,当然下划线可以有任意字符替换， 如 *b, *d都可以

# c 代表最后一个值了

# 需求：a =1, b=2， 交换a,b的值

a = 1

b = 2

a,b = b,a

print(a)    #

print(b)    #

函数闭包为函数加上认证功能

def auth_func(func):

    def wrapper(*args, **kwargs):

        username = input('用户名： ').strip()

        password = input("密码： ").strip()

        if username =="sb" and password == "":   # 用户是写死了

            res = func(*args, **kwargs)

            return res    # 切记要有返回值那

        else:

            print("用户名或密码错误")

    return wrapper

@auth_func

def index():

    print("欢迎来到京东")

@auth_func

def home():

    print("欢迎回家")

@auth_func

def shopping_box(name):

    print("%s的购物车里有%s,%s,%s" % (name, '娃娃', '电脑','手机'))

index()

home()

shopping_box('韩梅梅')

函数闭包模拟session

上面为每个功能都加了验证功能，但是每次运行其他功能都需要重新登陆，这显然是不合理的，可以用session和cookie来解决，那怎么模拟解决这个问题呢？

还有一个问题，就是用户是写死的，而实战中，我们的用户不可能只有一个，而且写死，所以这里也是需要改造的。

#　用户一般都是存在数据库里，这里为了方便模拟，就把用户存储在一个列表里

user_list = [

    {'name': 'sb', 'passwd': ''},

    {'name': 'lhf', 'passwd': ''},

    {'name': 'wpq', 'passwd': ''},

    {'name': 'yh', 'passwd': ''},

]

current_dic = {'username':None, 'login':False}  # 模式当前登录状态是FALSE，未登录

def auth_func(func):

    def wrapper(*args, **kwargs):

        # 在运行wrapper之前, 先判断是否有用户登录

        if current_dic['username'] and current_dic['login']: # 这个代表的是由用户登录且是true，然后直接运行func()

            res= func(*args, **kwargs)

            return res

        # 如果上面的判断不为True,则输入用户名和密码

        username = input("用户名：")

        password = input("密  码：")

        # 输完后应该从user_list里提取信息

        for user in user_list:

            # 然后判断输入的用户名和密码与user_list里的是否一致

            if username == user['name'] and password == user['passwd']:

                # 如果有一致的, 要把当前状态改一下

                current_dic['username'] = username  # 记录状态的字典里用户名 = 用户输入的用户名

                current_dic['login'] = True         # 登陆状态改为true

                res = func(*args, **kwargs)

                return res    # 切记要有返回值那

        # 如果遍历了一遍,都没有匹配的

        else:

            print("用户名或密码错误")

    return wrapper

@auth_func

def index():

    print("欢迎来到京东")

@auth_func

def home():

    print("欢迎回家")

@auth_func

def shopping_box(name):

    print("%s的购物车里有%s,%s,%s" % (name, '娃娃', '电脑','手机'))

index()

home()

shopping_box('韩梅梅')

函数闭包带参数装饰器-----带参数的装饰器

user_list=[

    {'name':'alex','passwd':''},

    {'name':'linhaifeng','passwd':''},

    {'name':'wupeiqi','passwd':''},

    {'name':'yuanhao','passwd':''},

]

current_dic={'username':None,'login':False}

def auth(auth_type='filedb'):

    def auth_func(func):

        def wrapper(*args,**kwargs):

            print('认证类型是',auth_type)

            if auth_type == 'filedb':

                if current_dic['username'] and current_dic['login']:

                    res = func(*args, **kwargs)

                    return res

                username=input('用户名：').strip()

                passwd=input('密码：').strip()

                for user_dic in user_list:

                    if username == user_dic['name'] and passwd == user_dic['passwd']:

                        current_dic['username']=username

                        current_dic['login']=True

                        res = func(*args, **kwargs)

                        return res

                else:

                    print('用户名或者密码错误')

            elif auth_type == 'ldap':

                print('鬼才特么会玩')

                res = func(*args, **kwargs)

                return res

            else:

                print('鬼才知道你用的什么认证方式')

                res = func(*args, **kwargs)

                return res

        return wrapper

    return auth_func

@auth(auth_type='filedb') #auth_func=auth(auth_type='filedb')-->@auth_func 附加了一个auth_type  --->index=auth_func(index)

def index():

    print('欢迎来到京东主页')

@auth(auth_type='ldap')

def home(name):

    print('欢迎回家%s' %name)

#

@auth(auth_type='sssssss')

def shopping_car(name):

    print('%s的购物车里有［%s,%s,%s］' %(name,'奶茶','妹妹','娃娃'))

# print('before-->',current_dic)

index()

# print('after--->',current_dic)

home('产品经理')

shopping_car('产品经理')

巴特西

第十七篇 Python函数之闭包与装饰器

一. 装饰器

最新文章

热门文章