可迭代对象

定义

在Python的任意对象中，只要它定义了可以返回一个迭代器的 __iter__ 魔法方法，或者定义了可以支持下标索引的 __getitem__ 方法，那么它就是一个可迭代对象，通俗的说就是可以通过 for 循环遍历了。Python 原生的列表，字符串，元祖，字典等都是可以迭代的，可以通过 dir() 函数查看，如以下查看字符串，可见其定义了 __getitem__ 方法

判断一个对象是否是可迭代对象

方法一：isinstance + Iterable

方法二：hasattr + __getitem__ 

from collections import Iterable
# 方法一
print(isinstance([], Iterable))  # 返回 True，说明是可迭代对象
# 方法二
print(hasattr({}, '__getitem__'))  # 返回 True，说明是可迭代对象

自定义可迭代对象

class Employee:
    def __init__(self, employee):
        self.employee = employee

emp = Employee(['zs', 'ls', 'ww'])

# 正常情况下会报错，emp 不是一个可迭代对象
# TypeError: 'Employee' object is not iterable
for i in emp:
    print(i)

 实现 __iter__ 和 __getitem__ 方法中的一个或者两个

class Employee:
    def __init__(self, employee):
        self.employee = employee

    def __getitem__(self, item):
        # item 是解释器帮我们维护的索引值
        # 在 for 循环中，自动从 0 开始计算
        print(item)
        return self.employee[item]

emp = Employee(['zs', 'ls', 'ww'])

# 正常情况下会报错，emp 不是一个可迭代对象
# TypeError: 'Employee' object is not iterable
for i in emp:
    print(i)

迭代器

迭代器对象

迭代器就是同时实现了 __next__ 和 __iter__ 方法（缺一不可）的对象。其中 __iter__ 方法返回迭代器自身， __next__ 方法不断返回迭代器中的下一个值，直到容器中没有更多的元素时，抛出 StopIteration 异常，以终止迭代 由定义可以知道，迭代器一定是可迭代对象，因为迭代器实现了 __iter__ 方法，满足了可迭代对象的定义。但是可迭代对象不一定是迭代器，因为不一定实现了 __next__ 方法。

判断一个对象是迭代器

from collections import Iterator
print(isinstance(counter, Iterator))  # True
print(isinstance([], Iterator))  # False

为什么有了可迭代对象，还要有迭代器？

因为迭代器采用了工厂模式，节约了内存空间。所谓的工厂模式，就是在需要的时候，才会去生产数据，而不是像可迭代对象那样一次性 全部把数据生产出来。可迭代对象如列表，字典等，会事先把所有的数据生产并保存起来，而迭代器则是在每次获取下一个值的时候 才会返回值，所以迭代器没有长度这一说法，没有长度这一属性，如果获取完了会抛出 StopIteration 异常来表示没有数据了

所以迭代器适用于那种无限序列，不会占用很大的内存空间

from itertools import count

# count 是一个迭代器
# 创建一个从 10 开始的无限序列
counter = count(start=10)
print(type(counter))  # <class 'itertools.count'>
print(dir(counter))  # 有 __iter__ 和 __next__ 方法

print(next(counter))  # 10
print(next(counter))  # 11

# 报错，没有长度属性
# TypeError: object of type 'itertools.count' has no len()
# print(len(counter))

可迭代对象转为迭代器

a = [1, 2, 3, 4]
print(type(a))  # <class 'list'>

a_iter = iter(a)
print(type(a_iter))  # <class 'list_iterator'>

迭代器的特点

a = [1, 2, 3, 4]
a_iter = iter(a)
# 每一次获取迭代器中的值之后，都是把该值从迭代器中拿出来，即迭代器中已经没有该值了，因为已经被拿出来了
# 所以遍历完一次迭代器之后，不能遍历第二次
# 因为遍历第一次的时候已经把值拿出来完了，第二次去遍历的时候迭代器中啥也没有了
# 即迭代器不走回头路，可迭代对象则没有这种特点
for i in a_iter:
    print(i)

for i in a_iter:
    print(i)

# 上面代码只会输出一次 1 2 3 4

# 前面说的，当遍历完迭代器的最后一个数据时，再获取数据抛出异常，
# 而 for 循环没有抛出的原因是
# for 循环内部也是用 next() 方法获取迭代器中的值，
# 当抛出异常后 for 循环会对异常进行处理，所以我们采用 for 循环遍历迭代器时不会有异常抛出

生成器

生成器其实是一种特殊的迭代器，但是这种迭代器更加优雅，因为不需要再像普通迭代器那样定义 __next__ 和 __iter__ 方法，只需要一个 yield 关键字，就会自动在内部帮我们实现这两个方法。所以，如果一个函数包含一个或多个 yield 关键字， 这个函数就会变为一个生成器。因为生成器是特殊的迭代器，所以它具备迭代器具备的特性

def demo():
    print('hello')
    yield 5
    print('world')

print(type(demo()))  # <class 'generator'>
print(dir(demo))  # 有 __iter__ 和 __next__ 方法

yield 关键字的作用

1、程序每次在代码中遇到 yield 关键字后，会返回结果，相当于 return 5，但是并没有真的退出程序，而是保留当前函数的运行状态

2、返回结果后，保留当前函数的运行状态，等待下一次调用，下次调用时，从上一次返回结果处开始执行 

第二个作用非常重要，这意味着程序控制权的转移是临时和自愿的，函数将来还会收回控制权（在下次调用生成器的时候收回）， 这也是 yield 和 return 最大的区别。return 意味着函数彻底交出控制权并结束运行，下一次调用将固定从函数的第一行代码开始执行。

def demo():
    print('hello')
    yield 5
    print('world')

# 此时运行demo()，相当于调用函数，但是并不像普通函数那样马上执行，可以看控制台没有输出
# 此处只是生成一个生成器对象
c = demo()

# 利用 next 方法调用生成器
# 第一次调用，打印 hello ，并返回 5
print(next(c))
# 第二次调用，打印 world ，并抛出异常 StopIteration（迭代器特性）
# 因为已经没有语句可以执行了，相当于数据已经取完了
print(next(c))

通过 send 向生成器传递数据

send 方法作用：

1、像 next 方法一样去调用生成器（调用生成器的两种方法：next 方法和 send 方法）

2、send 方法在调用生成器时，可以同时给生成器传递数据到生成器内部 

def demo():
    print('hello')
    # 注意，此处不是把 yield 5 赋值给变量 t
    # yield 5 是返回给调用者的值，即返回给 next(c)，
    # 所以执行 print(next(c)) 语句时会在输出 hello 后输出 5
    # 而变量 t 是接收下一次调用（c.send('test')）时 send 方法传入的 test
    # 即 t = 'test'
    t = yield 5
    print('world')
    print(t)

c = demo()
# 第一次调用生成器，得到 t = yield 5 等号左边的表达式结果，即得到 5
print(next(c))
# 第二次调用，从 t = yield 5 语句开始执行，通过 send 方法把 test 传递给 t = yield 5 等号右边的变量 t
# 然后接着执行函数中两个打印语句，输出 world 和 test
# 打印之后就会抛出异常 StopIteration，因为已经没有要执行的语句了
c.send('test')

生成器的预激活机制

def demo():
    print('hello')
    t = yield 5
    print('world')
    print(t)

c = demo()
# next(c) 就是生成器的预激活机制，即第一次调用
# 第一次调用也可以通过 send 方法，但是参数必须为 None
# 因为生成器没有办法在没有激活的情况下接收一个参数
# print(next(c))  # 预激活方式一
c.send(None)  # 预激活方式二
c.send('test')

查看生成器的运行过程

将下面代码的每一行打上断点（如图），进入debug模式可以清晰的看到代码的运行过程。

def countdown(n):
    print('counting down from ', n)  # 只在第一次调用生成器的时候输出，此时 n = 10
    while n >= 0:
        # 记住，这里不是将 yield n 赋值给变量 newvalue
        # newvalue 是用来接收 send 方法传递过来的参数的
        # yield n 是用来将 n 返回给调用者（next 方法或 send 方法）的
        newvalue = yield n
        # 判断是否用 send 方法传递参数，如果调用 next 方法，则传递过来的是 None
        if newvalue is not None:
            n = newvalue
        else:
            n -= 1

# 获得生成器对象 c，把 10 传递给 n
c = countdown(10)

for i in c:
    # 第一次调用生成器
    # 第一次执行 for i in c 语句时，内部第一次调用 next(c)
    # 执行 print('counting down from ', n) 语句，此时 n=10
    # 然后进入 while n >= 0 循环，执行 newvalue = yield n 等号右边的 yield n，即返回 n=10 给i
    # 所以第一次for循环 i=10，输出 10
    
    # 第三次调用生成器
    # 第二次执行 for i in c 语句时，内部第二次调用 next(c)，此时已经第三次调用生成器，第二次是用 send 方法调用的
    # 接着第二次调用生成器的地方开始执行，即从 newvalue = yield n 开始执行，next 方法没有给生成器传递参数
    # 所以 newvalue 为 None，则执行 else 语句：n -= 1，所以 n = 2
    # 进入 while n >= 0 ，然后返回newvalue = yield n 等号右边的 yield n，即返回 n=2
    # 所以第二次for循环 i=2，输出 2

    # 第四次调用生成器
    # 第三次执行 for i in c 语句时，内部第三次调用 next(c)
    # 接着第三次调用生成器的地方开始执行，即从 newvalue = yield n 开始执行，next 方法没有给生成器传递参数
    # 所以 newvalue 为 None，则执行 else 语句：n -= 1，所以 n = 1
    # 进入 while n >= 0 ，然后返回newvalue = yield n 等号右边的 yield n，即返回 n=1
    # 所以第三次for循环 i=1，输出 1

    # 第五次调用生成器
    # 第四次执行 for i in c 语句时，内部第四次调用 next(c)
    # 接着第四次调用生成器的地方开始执行，即从 newvalue = yield n 开始执行，next 方法没有给生成器传递参数
    # 所以 newvalue 为 None，则执行 else 语句：n -= 1，所以 n = 0
    # 进入 while n >= 0 ，然后返回newvalue = yield n 等号右边的 yield n，即返回 n=0
    # 所以第四次for循环 i=0，输出 0

    # 第六次调用生成器，最后一次
    # 第五次执行 for i in c 语句时，内部第五次调用 next(c)
    # 接着第五次调用生成器的地方开始执行，即从 newvalue = yield n 开始执行，next 方法没有给生成器传递参数
    # 所以 newvalue 为 None，则执行 else 语句：n -= 1，所以 n = -1
    # 不能进入 while n >= 0 ，那么生成器运行到最后结束，抛出一个异常 StopIteration
    # 抛出的异常被for循环内部处理，所以运行到此结束，for循环也结束

    print(i)  # 分别输出 10 2 1 0

    # 第一次进入 for 循环时 i = 10，所以进入 if 判断
    if i == 10:
        # 第二次调用生成器
        # 调用 send 方法调用生成器，接着第一次调用的地方继续执行
        # 把参数传递给 newvalue = yield n 中的 newvalue，此时 newvalue=3
        # newvalue 不为 None，进入判断 if newvalue is not None，将 n 设置为 newvalue （n = newvalue）
        # 此时 n = 3，进入 while n >= 0 ，然后返回newvalue = yield n 等号右边的 yield n，即返回 n=3
        # 然后进行第二次 for 循环
        print('send: ', c.send(3))  # 打印 send:  3

获得生成器的第二种方式

除了通过 yield 关键字得到生成器外，还可以通过小括号的形式得到，如下

"""
生成器表达式
    和列表推导式的区别：
        列表推导式会一下子将所有的数据生产出来，并放到列表中
        生成器表达式一次只生产一个数据
    获得生成器的两种方式：
        1、将普通函数里的 return 替换成 yield ，这样调用函数时会得到一个生成器
        2、利用生成器表达式
"""

# 可以通过元祖表达式（小括号）得到生成器
a = (i for i in range(5))
# 列表推导式得到的是一个列表
b = [i for i in range(5)]

# a 是生成器
print(type(a))  # <class 'generator'>
# b 是列表
print(type(b))  # <class 'list'>


# 利用推导式获得生成器的方式称为生成器表达式
t = (i * 2 for i in range(5))
print(t)  # <generator object <genexpr> at 0x000001F466254620>
print(next(t))  # 0
print(next(t))  # 2
# 把剩下的数据处理，目前只剩下 2 3 4
for i in t:
    print(i)  # 4 6 8

生成器实现斐波那契数列 

# 用生成器实现斐波那契数列
def fib():
    num1, num2 = 0, 1
    while True:
        yield num1
        num1, num2 = num2, num1 + num2


f = fib()
# 因为 fib 函数里是死循环，所以只要调用 next(f) 就可以一直得到 斐波那契数列的值
print(next(f))  # 0
print(next(f))  # 1
print(next(f))  # 1
print(next(f))  # 2
print(next(f))  # 3
print(next(f))  # 5