day14 带参装饰器、迭代器、生成器

"""

今日内容：

    1、带参装饰器及warps

    2、迭代器

    3、生成器

"""

"""

# 一、带参装饰器及warps系统装饰器

# 1、为什么需要带参装饰器？

    -- 昨天的内容已经讲了装饰器，但是讲的都是增加的函数不需要外界传人参数，如果装饰器也需要外界传入参数呢？

    -- 此时就需要带参装饰器

# 2、装饰器的推导过程

    -- 如果添加的功能也需要外界传入参数时，参数应该如何通过谁进行传递呢？

    -- 如果通过inner传入参数，因为inner中为可变长参数，所以会直接将参数传递给原函数，此方法不可行

    -- 如果通过 outter 进行传入，那么需要在func旁再增加参数，在调用outter时就需要将参数传递进去，此时就不能使用语法糖，破坏装饰器的整体结构

    -- 所以，最后的办法是根据闭包的方法将整个装饰器作为闭包，在外界增加一层函数，最后将整个装饰器作为返回值进行返回，就可以为装饰器传递参数了

def wrap(info):

    def outer(func):

        # info = 0

        def inner(*args, **kwargs):

            print('新：拓展的新功能，可能也需要外界的参数%s' % info)

            res = func(*args, **kwargs)

            return res

        return inner

    return outer

-- 此时，整个 warp 就是一个带参装饰器，其语法糖为 @wrap("新功能需要的参数")

@wrap('外部参数')

def fn(): pass

# 3、什么是wraps装饰器？

    -- 系统自带的装饰器，用来在用户查询被装饰函数的doc文档时，将被装饰函数的文档注释打印给用户

    -- 因为当我们使用装饰器为某个功能进行装饰时，最后的调用过程虽然看着还是原函数，但是我们已经为原函数进行了重新复制，此时再使用查询原函数的doc等内置功能时，访问的实际是装饰器

    -- @warps装饰器的作用就是将原函数的doc等内置功能传递给用户，彻底伪装好装饰器

# 4、如何使用warp装饰器？

from functools import wraps

def outer(func):

    @wraps(func)

    def inner(*args, **kwargs):

        res = func(*args, **kwargs)

        return res

    return inner

@outer

def fn(): pass

"""

"""

# 二、迭代器

# 1、什么是迭代器？

    -- 迭代器是一种可以不依赖于索引取值的容器

# 2、迭代器的优缺点：

    -- 迭代器优点：可以不用依赖索引取值

    -- 迭代器缺点：只能从前往后依次取值

# 3、迭代器对象与可迭代对象

    -- 可迭代对象：具有__iter__()方法的对象就叫做可迭代对象，可迭代对象可以通过__iter__()方法转换成迭代器对象

        ls = [4, 1, 5, 2, 3]

        res = ls.__iter__()  # => 可迭代对象

        print(res)  # <list_iterator object at 0x000002732B0C7470>

    -- 迭代器对象：具有__next__()方法的对象叫做迭代器对象，迭代器对象可以通过__next__()方法进行取值，一次只能取出一个值

        with open('1.txt', 'rb') as f:

        res = f.__next__()  # 文件中的第一行内容

        print(res)

        res = f.__next__()  # 文件中的第二行内容

        print(res)

# 4、for循环迭代器

    -- 迭代器取值时的问题

        -- 在我们从迭代器对象中取值时，可以使用__next__()从迭代器中取值，但是，每使用一次__next__()方法才会取出一个值，那么怎么把迭代器中的值全部取出来呢？

        -- 在使用__next__()进行取值时，如果取出所有的值后还有__next__()方法，就会抛出异常

    -- for循环迭代器

        -- 从迭代器中取值，可以依次取出迭代器中所有的值，

        -- for循环中封装了异常处理机制，会自动处理取去所有值后抛出的异常

        -- for循环会将 in 后面的可迭代对象或迭代器对象直接添加.__iter__()方法

    -- for循环迭代器的工作原理：

        for v in obj: pass

        -- 获取obj.__iter__()的结果，就是得到要操作的迭代器对象

        -- 迭代器对象通过__next__()方法进行取值，依次将当前循环的取值结果赋值给v

        -- 当取值抛异常，自动处理StopIteration异常结束取值循环

# 5、枚举器 （enumerate）

    -- 枚举器就是给迭代器中的取值结果加索引的，当使用枚举器进行取值时，每次取值时会自动为取的值加上取值索引。

        s = 'abc'

        for v in enumerate(s):

            print(v)  # (0 'a') | (1 'b') | (2 'c')

"""

"""

# 四、生成器

# 1、什么是生成器？

    -- 生成器就是可以自定义的迭代器

# 2、如何自定义生成器？

    -- 我们可以使用函数进行声明，再使用 yeild 返回值，这样在使用函数名()时就不是调用函数，而是生成迭代器对象

    -- 在有yield关键字时，再使用return关键字，return关键字不起任何作用

    -- 使用yeild关键字生成迭代器时，当使用__next__()进行取值时，每次只会返回一个yeild后的值，并卡在原地，不会执行后面的代码，当再次遇到__next__()时才会继续向下执行

    def fn():

        yield 1

        yield 3

        yield 5

    obj = fn()

    obj.__next__()  # 从开始往下执行，遇到第一个yield停止，拿到yield的返回值

    obj.__next__()  # 从上一次停止的yield往下执行，在再遇到的yield时停止，拿到当前停止的yield的返回值

    ...              # 以此类推，直到无法获得下一个yield，抛StopIteration异常

    -- 我们自定义的生成器可以使用for循环直接取值。

# 3、生成器案例

# 案例一：创建生成器，从其取值，依次得到1! 2! 3! ...，可无限取值生成器。

def jiecheng():

    ji = 1

    count = 1

    while True:

        ji *= count

        yield ji

        count += 1

obj = jiecheng()

print(obj.__next__())

print(obj.__next__())

print(obj.__next__())  # 可以无限取

# 案例二：

# 自定义结束条件生成器

def jiecheng_num(num):

    ji = 1

    for i in range(1, num + 1):

        ji *= i

        yield ji

    # ...

obj = jiecheng_num(3)

print(obj.__next__())

print(obj.__next__())

print(obj.__next__())

print(obj.__next__())  # 有异常了

for v in jiecheng_num(5):

    print(v)  # 会自动处理异常停止

# 案例三：

# 自制的range函数

def my_range(num):  # => [0, 1, 2, ..., num - 1]

    count = 0

    while count < num:

        yield count

        count += 1

for v in my_range(10):

    print(v, end=' ')

print(list(my_range(10)))

"""