• day14带参装饰器,迭代器,可迭代对象 , 迭代器对象 ,for迭代器 , 枚举对象


    复习

    '''
    函数的嵌套定义:在函数内部定义另一个函数
    
    闭包:被嵌套的函数
        -- 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)
    
    # 迭代器对象有哪些:

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

    枚举对象

    # 给可迭代器对象及迭代器对象添加迭代索引
    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)))
  • 相关阅读:
    MVC: Connection String
    Web API: Security: Authentication and Authority
    Web API: Security: Basic Authentication
    Web API: Client: HttpClient Message Handlers
    Web API: Client: Call a Web API from a .net client
    C#: Delegate and Event
    IIS Media Service: Channel 小结
    WCF: Retry when service is in fault state.
    Windows Azure: Service Bus Relay
    i2c 过程详解(转)
  • 原文地址:https://www.cnblogs.com/george-007/p/10790246.html
Copyright © 2020-2023  润新知