'''

函数的嵌套定义：在函数内部定义另一个函数

闭包：被嵌套的函数

    -- 1.外层通过形参给内层函数传参

    -- 2.验证执行

开放封闭原则: 功能可以拓展，但源代码与调用方式都不可以改变

装饰器：装饰器名就是外层函数 @outer

@outer  # fn = outer(fn)

def fn(): pass

'''

def wrap(func):

    def inner(*args, **kwagrs):

        # res = func(*args, **kwagrs)

        res = outer.inner()

        return res

    return inner

def outer(func):

    def inner(*args, **kwagrs):

        pass

        res = func(*args, **kwagrs)

        pass # res

        return res

    return inner

@wrap   # fn = warp(fn) = wrap(outer.inner) = wrap.inner

@outer  # fn = outer(fn) = outer.inner

def fn(n1, n2, n3): pass

fn(1, 2, 3)

# 1.带参装饰器 | wrapper  了了解

# 2.迭代器  *****

# 可迭代对象

# 迭代器对象

# for迭代器

# 枚举对象

# 递归 ***

# 通常，装饰器为被装饰的函数添加新功能，需要外界的参数

#    -- outer参数固定一个，就是func

#    -- inner参数固定同被装饰的函数，也不能添加新参数

#    -- 可以借助函数的嵌套定义，外层给内层传参

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

@wrap('外部参数')

def fn(): pass

# 系统的wraps带参装饰器：改变inner的假指向，本质外界使用的还是inner，但是打印显示的是wraps中的函数

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

# 迭代器对象: 可以不用依赖索引取值的容器

# 可迭代对象：可以通过某种方法得到迭代器对象

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

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

# 可迭代对象：有__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)

# 迭代器对象有哪些：

# 直接用while True循环在迭代器对象中通过 __next__() 取值，终究会有取空的时候，取空再取值，报StopIteration异常

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

iterator = ls.__iter__()

while True:

    try:

        print(iterator.__next__())

    except StopIteration:

        # print('取空了')

        break

# for循环就是对while取迭代器对象的封装

for v in ls:

    print(v)

for v in ls.__iter__():  # 可迭代对象.__iter__() => 迭代器对象

    print(v)

iterator = ls.__iter__()

for v in iterator:  # 迭代器对象.__iter__() => 自身

    print(v)

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

# for v in obj: pass

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

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

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

# 给可迭代器对象及迭代器对象添加迭代索引

s = 'abc'

for v in enumerate(s):

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

# 生成器：自定义的迭代器对象

#     -- 就是用函数语法来声明生成器，用yield关键字取代return关键字来返回值，参数没有多少变化

# 总结：有yield关键字的函数，函数名() 不是调用函数，而是生成得到 生成器对象，生成器对象就是迭代器对象，可以通过 __next__() 进行取值

# 执行流程:

def fn():

    yield 1

    yield 3

    yield 5

obj = fn()

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

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

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

# 可以直接被for循环遍历

for v in fn():

    print v

# 案例一：创建生成器，从其取值，依次得到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)  # 会自动处理异常停止

# 案例三：

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)))