Python之挖掘迭代器、生成器、装饰器三代祖坟

一、迭代器

1、迭代器协议 有next方法 一直直到StopIteration终止 （只能往前走不能后退）

2.可迭代对象 遵行迭代器协议的对象就称之为可迭代对象 转换成可迭代对象：iter方法

Python中字符串 列表 元组 字典 集合 文件都不是可迭代对象，但是可以转换成可迭代对象iter

l = [1, 2, 3]
iter_l = l.__iter__()
print(iter_l.__next__())
print(iter_l.__next__())
print(iter_l.__next__())
print(iter_l.__next__())
print(next(iter_l))

二、Python中for循环强大的机制

for运行机制就是
1.iter 2.next 3.捕捉StopIteration
为什么要有for循环
如果说字符串 列表 元组有序的while也可以实现，但是对于无序的类型呢？只有通过for循环当然有序同样能够进行操作

三、生成器(可迭代对象)

1.特征　

　1.自动实现迭代器协议 不再调用iter方法
　2.表现形式 函数式yield 生成器表达式(类似列表推导式)

def test():
    yield 1
    yield 2
    yield 3


g = test()
print(g)
print(g.__next__())
print(g.__next__())
print(g.__next__())

2.三元表达式、列表解析

name = 'eric'
res = 'sb' if name == 'eric' else 'shuai'
print(res)

l = [i for i in range(10)]
print(l)

 l = [i for i in range(10) if i > 5] 2 print(l) 

 生成器 1.比列表解析节省内存牛皮好啊2.函数式的生成器阔以保存函数运行状态

l = (i for i in range(10)) 
print(l.__next__())
print(l.__next__())
print(l.__next__())
print(next(l))

print(sum(i*2 for i in range(101)))

四、yield关键字

yield相当于return 控制函数的返回值

x = yield的另外一个特性 接收send传过来的值,赋值给x

def test():
    print('开始啦')
    first = yield 1  # return 1 first=None
    print('第一次', first)
    yield 2
    print('第二次')


t = test()
res = t.__next__()
print(res)
res = t.send(None)  # send触发生成器下一步运行
print(res)

五、基于生成器模拟生产者消费者模型

import time


def consumer(name):
    print('我是%s,我开始准备开始吃包子' % name)
    while True:
        baozi = yield
        time.sleep(1)
        print('%s 很开心的把%s吃掉了' % (name, baozi))


def producer():
    c1 = consumer('eric')
    c1.__next__()
    for i in range(1, 11):
        time.sleep(1)
        c1.send('屎馅包子%s' % i)


producer()

      杂货

# 函数传递参数时 是引用
# name = 'eric'
#
#
# def show():
#     print(id(name))
#
#
# print(id(name))
# show()

六、装饰器

本质就是函数，为其它函数添加新的功能

把握两原则：不修改被修饰函数的源代码 不修改被修饰函数的调用方式

装饰器=高阶函数+函数嵌套+闭包

　　1、高阶函数：传入参数函数名： 为被修饰函数增加功能但是改变了调用方式
　　返回值函数名：不修改函数的调用的方式
　　把上边两个方式结合起来就实现装饰器了

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import time


def foo():
    time.sleep(1)
    print('from foo')


def timer(func):
    """
    传入参数函数名
    :param func:
    :return:
    """
    start_time = time.time()
    func()
    stop_time = time.time()
    print('函数的运行时间%s' %(stop_time-start_time))


timer(foo)   # 违背函数调用方式

def timer(func):
    """
    from foo
    函数运行的时间1.0009970664978027
    from foo  这样确实能够统计出foo运行的时间，调用方式也没改变 但是多执行一次foo函数
    :param func:
    :return:
    """
    start_time = time.time()
    func()
    stop_time = time.time()
    print('函数运行的时间%s' %(stop_time-start_time))
    return func


foo = timer(foo)
foo()

　　2、函数嵌套

def father(name):
    # print('from father %s' %name)

    def son():
        # print('我的爸爸是%s' %name)

        def grandson():
            print('我的爷爷是%s' %name)
        grandson()
    son()


father('Mr.Wei')

　　3、闭包：作用域的一种表现

类的装饰器实现

#!/usr/bin/env python
# -*- coding:utf-8 -*-


def deco(obj):
    print(obj)
    obj.x = 1
    obj.y = 2
    return obj


@deco  # Foo = deco(Foo)
class Foo:
    pass


@deco
def test():
    print('test')


print(Foo.__dict__)
print(test.__dict__)  # 这里也可以说明Python中一切皆对象说明
"""
<class '__main__.Foo'>
<function test at 0x00000235EBFD4A60>
{'__module__': '__main__', '__dict__': <attribute '__dict__' of 'Foo' objects>, '__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__doc__': None, 'x': 1, 'y': 2}
{'x': 1, 'y': 2}
"""

类的装饰器完善版本

#!/usr/bin/env python
# -*- coding:utf-8 -*-


def Typed(**kwargs):
    def deco(obj):
        for k, v in kwargs.items():
            setattr(obj, k, v)
        return obj
    return deco


@Typed(x=1, y=2)   # Typed(x=1, y=2)---->deco   @deco--->Foo = deco(Foo)
class Foo:
    pass


@Typed(name='eric')
class Bar:
    pass


print(Foo.__dict__)
print(Bar.__dict__)

函数的装饰器实现

def timer(func):  # func=test
    def wrapper(*args, **kwargs):
        start_time = time.time()
        res = func(*args, **kwargs)  # 在运行test()
        stop_time = time.time()
        print('运行的时间%s' %(stop_time-start_time))
        return res
    return wrapper


@timer   # test = timer(test)
def test():
    time.sleep(1)
    print('test函数运行完毕')


# test = timer(test)  # 返回的是wrapper地址
# test()              # 执行的wrapper函数
print(test())

# @timer就相当于做了test = timer(test)这件事情