带参装饰器,迭代器,生成器,枚举对象

2023-01-31 00:01:53 对象 枚举 生成器

一,复习

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

闭包:被嵌套的函数
    -- 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.带参装饰器 | wraps(文档注释)  了了解

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

# 可迭代对象有哪些:str | list | tuple | set | dict | range() | enumerate() | file | 生成器对象

 

六,迭代器对象

# 迭代器对象:有__next__()方法的对象是迭代器对象,迭代器对象依赖__next__()方法进行取值

with open('1.txt', 'rb') as f:
    res = f.__next__()  # 文件中的第一行内容
    print(res)
    res = f.__next__()  # 文件中的第二行内容
    print(res)

# 迭代器对象有哪些:enumerate() | file | 生成器对象

# 注:迭代器对象调用__iter__()方法返回的还是迭代器对象(返回自身)

 

七,for循环迭代器

# 直接用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异常结束取值循环

 

八,生成器

# 生成器:自定义的迭代器对象
#     -- 就是用函数语法来声明生成器,用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)))

 

 

九,枚举对象

# 给可迭代器对象及迭代器对象添加迭代索引
s = 'abc' for v in enumerate(s): print(v) # (0 'a') | (1 'b') | (2 'c')

 

相关文章