Python中的迭代器、生成器、装饰器

1. 迭代器 

"""
    iterator
    迭代器协议： 对象必须提供一个next()方法，执行该方法要么返回迭代中的下一项，要么引起一个StopIteration异常，以终止迭代
    可迭代对象： 实现可迭代协议的对象。（对象内部定义一个__iter__()方法）
    访问方式：下标方式、迭代器协议、for循环
"""


li = [1, 2, 3, 4, 5]
iter_li = li.__iter__()  # 通过__iter__()方法生成可迭代对象
print(iter_li)  # <list_iterator object at 0x000002565B5BD748>
# print(li[0])
print(iter_li.__next__())  # 1
print(next(iter_li))  # 2

# for 循环访问遵循迭代器访问方式
# for i in li:
#     print(i)

2. 生成器

"""
    generator
    生成器函数： 定义函数，包换关键字 yield
    生成器表达式： 三元表达式
    send()
"""


# 生成器函数
def generator_func():
    yield 1
    yield 2
    yield 'louis'
    yield 'scar'
    yield 'rose'
    x = yield
    print('x=', x)
    y = yield
    print('y=', y)


gen = generator_func()
print(gen)  # <generator object generator_func at 0x000001A5464A2F48>
print(gen.__next__())
print(gen.__next__())
print(gen.__next__())
print(gen.__next__())
print(gen.__next__())
print(gen.__next__())  # None
# 改变x的值并触发 __next()__
res = gen.send('init_')
print(res)  # x= init_ None

# 生成器表达式
count1 = [x for x in range(10)]  # 列表表达式
print(count1)  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
count2 = (x for x in range(10) if x > 5)  # 生成器表达式
print(count2)  # <generator object <genexpr> at 0x000001E364E87840>
print(list(count2))  # [6, 7, 8, 9]


import time


# 生产者消费者模型
def consumer(name):
    print('消费者[%s]开始下单' % name)
    while True:
        num = yield
        time.sleep(0.5)
        print('%s 第[%s]杯奶茶' % (name, num))


def producer():
    c1 = consumer('louis')
    c2 = consumer('scar')
    next(c1)
    next(c2)
    for i in range(1, 10):
        c1.send(i)
        c2.send(i)


producer()

运行结果：
消费者[louis]开始下单
消费者[scar]开始下单
louis 第[1]杯奶茶
scar 第[1]杯奶茶
louis 第[2]杯奶茶
scar 第[2]杯奶茶
louis 第[3]杯奶茶
scar 第[3]杯奶茶
louis 第[4]杯奶茶
scar 第[4]杯奶茶
louis 第[5]杯奶茶
scar 第[5]杯奶茶
louis 第[6]杯奶茶
scar 第[6]杯奶茶
louis 第[7]杯奶茶
scar 第[7]杯奶茶
louis 第[8]杯奶茶
scar 第[8]杯奶茶
louis 第[9]杯奶茶
scar 第[9]杯奶茶

3 装饰器

　　a. 装饰器实现日志操作(带参以及不带参的装饰器函数)

"""
    装饰器：本质就是函数，功能就是为其它函数添加附加功能
    使用场景： 插入日志、性能测试、事务处理、缓存、权限校验等
    语法糖： @def_func(func)
    装饰器 = 高阶函数 + 函数嵌套 + 闭包
    高阶函数： 函数的接受的参数是一个函数，返回值也是一个函数
    函数嵌套： 在函数里面执行其它函数
    闭包： 主要看作用域范围
"""
import functools


def func_logging(arg):
    print(arg)
    if callable(arg):  # 如果装饰器不带参数
        # @functools.wraps(arg)
        def _deco(*args, **kwargs):
            print('%s is running' % arg.__name__)
            arg(*args, **kwargs)
        return _deco
    else:  # 如果装饰器带参数
        def _deco(func):
            @functools.wraps(func)
            def __deco(*args, **kwargs):
                if arg == 'warn':
                    print('warn %s is running' % func.__name__)
                return func(*args, **kwargs)
            return __deco
        return _deco


@func_logging  # test1 = func_logging(test)
def test1():
    print('this is test1')
    print(test1.__name__)


@func_logging('warn')  # 直接执行 func_logging() 返回装饰器函数 _deco()
def test2():
    print('this is test2')
    print(test2.__name__)


test1()
# <function test1 at 0x000002335B5A1EA0>
# test1 is running
# this is test1
# test1
# 函数名变为_deco而不是test1，这个情况在使用反射的特性的时候就会造成问题。因此引入了functools.wraps解决这个问题
test2()
# warn
# warn test2 is running
# this is test2
# test2

　　b. 性能测试

import time
import functools
# 性能测试
def timer(func):
    @functools.wraps(func)
    def warpper(*args, **kwargs):
        print('%s is start running' % func.__name__)
        start_time = time.time()
        func(*args, **kwargs)
        stop_time = time.time()
        print('%s is stop running, cost %s s' % (func.__name__, stop_time - start_time))
    return warpper


@timer
def test3():
    time.sleep(1.0)
    print(test3.__name__)


test3()
# test3 is start running
# test3
# test3 is stop running, cost 1.0015299320220947 s