装饰器进阶和迭代器

装饰器进阶和迭代器

昨日补充

可变类型，直接在函数内部调用

不可变类型，需要在函数内部调用，要使用global

叠加装饰器：

每一个新的功能都应该写一个新的装饰器

需求：

为被装饰对象，添加统计时间与登录认证的功能

# 登录认证

import time


def re_login():
    with open('a.txt', 'r', encoding='utf-8') as rf:
        data = rf.read()
        data1 = data.strip('
').split('|')
        data2 = ''.join(data1)
        data3 = data2.split('
')
    return data3

    # print(data3)


# 登录认证装饰器
def login(func):
    def inner1(*args, **kwargs):
        username = input('请输入用户名：').strip()
        password = input("请输入密码：").strip()

        res = re_login()

        if username + password in res:
            print('恭喜您，登录成功！')
            re = func(*args, **kwargs)
            return re

        else:
            print('对不起，登录失败！')
            re = func(*args, **kwargs)
            return re

    return inner1


# 统计时间装饰器
def time_record(func):
    def inner2(*args, **kwargs):
        print('开始统计！')
        start_time = time.time()
        res = func(*args, **kwargs)
        end_time = time.time()
        print(f'执行时间：{end_time - start_time}')
        return res

    return inner2


# @login  # inner1=inner(inner2)
# @time_record  # inner2

@time_record
@login
def func():
    print('开始下载电影！')
    time.sleep(5)
    print('下载电影结束！')


func()


开始统计！
请输入用户名：godlover
请输入密码：123456
恭喜您，登录成功！
开始下载电影！
下载电影结束！
执行时间：11.740200519561768

什么是叠加装饰器：

在同一个被装饰对象中，添加多个装饰器，并执行

@装饰1

@装饰2

def 被装饰对象（）：

​ pass

ps：装饰器在调用被装饰对象时才添加功能

装饰顺序：从下至上

执行顺序：从上至下

编写装饰器，为多个函数加上认证的功能（用户的账号密码来源于文件），要求登录成功一次，后续的函数都无需再输入用户名和密码


info_dict1 = {
    'name_info': None
}


def re_login():
    username = input('请输入用户名：').strip()
    password = input('请输入密码：').strip()
    with open('a.txt', encoding='utf-8') as f:
        for line in f:
            # print(line)
            name, pwd = line.strip('
').split('|')
            if username == name and password == pwd:
                print('登录成功！')
                info_dict1['name_info'] = name
            else:
                print('登录失败！')


def login(func):
    def inner(*args, **kwargs):
        if info_dict1.get('name_info'):
            print('免密登录成功！')
            res = func(*args, **kwargs)
            return res
        else:
            re_login()

    return inner


@login
def func1():
    print(1)


@login
def func2():
    print(2)


@login
def func3():
    print(3)


func1()
func2()
func3()




请输入用户名：godlover
请输入密码：123456
登录成功！
登录失败！
免密登录成功！
2
免密登录成功！
3

叠加装饰器的理解
内部的具体运行方式


def wrapper1(func):
    def inner1(*args, **kwargs):
        print('1-----start')
        # 被装饰对象在被调用时，如果还有其他装饰器，则会先执行其他装饰器中的inner
        res = func(*args, **kwargs)
        print('1-----end')
        print(res)
        return res

    print(1)
    return inner1


def wrapper2(func):
    def inner2(*args, **kwargs):
        print('2-----start')
        res = func(*args, **kwargs)
        print('2-----end')
        print(res)
        return res

    print(2)

    return inner2


def wrapper3(func):
    def inner3(*args, **kwargs):
        print('3-----start')
        res = func(*args, **kwargs)
        print('3-----end')
        print(res)
        return res


    print(3)

    return inner3


@wrapper1  # 3
@wrapper2  # 2
@wrapper3  # 1
def func():
    print('from func')
    return 1


func()


3
2
1
1-----start
2-----start
3-----start
from func
3-----end
1
2-----end
1
1-----end
1

ps:

无论inner中出现任何判断，都要返回fun（*args,**kwargs）的结果

当被装饰器对象还有其他装饰器时跳过直接执行inner

无参装饰器：

装饰在被装饰对象时，没有传参数的装饰器

@wrapper

有参装饰器：

@wrapper('参数')

用途：

在某些时候我们需要给用户的权限进行分类

# 调用时@wrapper('参数1')
def user_auth(user_role):
    def wrapper(func):
        def inner(*args, **kwargs):
            if user_role == 'SVIP':
                print(1)
                res = func(*args, **kwargs)
                return res
            elif user_role == '普通用户':
                print(2)
                res = func(*args, **kwargs)
                return res

        return inner

    return wrapper


# @user_auth('SVIP')  # 相当于@和后面的分开，先执行函数user_auth,返回wrapper，再将@和wrapper结合起来，返回inner
# def func():
#     print('from func')
#
#
# func()

@user_auth('普通用户')
def func():
    print('from func')


func()



2
from func

wraps:是一种修复工具，修复地是被装饰对象的空间

例如查看函数内部的注释：

from functools import wraps


def wrapper(func):
    @wraps(func)  # 是一个修复工具，用来修复被装饰对象的空间
    def inner(*args, **kwargs):
        '''
        这里是inner的注释
        :param args:
        :param kwargs:
        :return:
        '''
        res = func(*args, **kwargs)
        return res

    return inner


@wrapper
def func():
    '''
    这里是func的注释
    :return:
    '''
    print('from func')


print(func.__doc__)



   这里是func的注释
    :return:

迭代器

迭代器的工具

迭代：指的是重复迭代，每一个迭代的结果都是基于上一次的结果而来的

迭代器：指的是迭代取值的工具

可迭代对象：所有的序列类型：str，list，dict，tuple，set，f

什么是可迭代对象：

凡是内部有_ iter _()方法的都是可迭代对象

什么是迭代器对象：

通过可迭代对象._ iter _()方法的返回值就是迭代器对象

如何迭代取值：

迭代器对象._ next _()

ps：迭代器中的值取完时，会报错StopIteration

list =['jason','sean','egon','tank']
iter_list1 = list._iter_()
while True:
    #try：捕获异常
    try:
        print(iter_list1._next_())#报错
    except StopIteration:
        break
        

迭代器的优缺点：

优点：

1.不依赖于索引，迭代取值

2.节省内存空间

缺点：

1.取指定的某个值比较麻烦，每次取值都要从第一个值开始，无法通过索引取值

2.不能够通过len()计算长度

总结

可迭代对象 vs 迭代器对象

获取可迭代对象：

定义序列类型

特点：

凡是内置有_ iter _()方法的都是可迭代对象

获取迭代器对象：

过可迭代对象._ iter _()方法的返回值就是迭代器对象

特点：

内置有_ next _()方法

for 循环的原理

in自动将可迭代对象调用_iter_（）方法变成迭代器对象

for i in 可迭代对象：
#迭代器对象调用_next_()方法取值
print(I)
里面也调用捕获异常机制

迭代器对象的本质是一个可迭代对象

文件本质既是可迭代对象又是迭代器对象

文件计较特殊：文件读取出来的时候就是一个迭代器对象

最后注意：

可迭代器对象不一定是迭代器对象（文件既是可迭代对象，也是迭代器对象，但是其他可迭代器不是迭代器对象）

但是迭代器对象一定是可迭代对象