迭代器、生成器、for循环的本质

迭代器（iter)

可迭代对象：比如：列表、元组、字典、集合、range、字符串

(list, tuple,dict, set, str)
from collections import Iterable
result = isinstance(range(5), Iterable) # True

自定义可迭代对象

在类里面提供一个iter创建的对象是可迭代对象，可迭代对象是需要迭代器完成数据迭代的

自定义迭代器对象

（在类里面定义iter和next方法创建的对象就是迭代器对象）

from collections import Iterable, Iterator


# 自定义可迭代对象：在类里面定义__iter__方法创建的对象就是可迭代对象
class MyList(object):
    def __init__(self):
        self.my_list = list()

    def append_item(self, item):
        self.my_list.append(item)

    def __iter__(self):
        # 可迭代对象的本质：遍历可迭代对象时其实获取的是可迭代对象的迭代器，然后通过迭代器获取对象中的数据
        my_iterator = MyIterator(self.my_list)
        return my_iterator


# 自定义迭代器对象：在类里面定义__iter__和__next__方法创建的对象就是迭代器对象
class MyIterator(object):
    def __init__(self, my_list):
        self.my_list = my_list
        # 记录当前获取数据的下标
        self.current_index = 0
        # 判断当前对象是否是迭代器
        result = isinstance(self, Iterator)
        print(result)

    def __iter__(self):
        'The __iter__() method returns the iterator object itself'
        return self

    def __next__(self):
        'The __next__() method must return the next item in the sequence'
        if self.current_index < len(self.my_list):
            self.current_index += 1
            return self.my_list[self.current_index - 1]
        else:
            # 数据取完了，需要抛出一个停止迭代的异常
            raise StopIteration


my_list = MyList()
my_list.append_item(1)
my_list.append_item(2)
result = isinstance(my_list, Iterable)
print(result)

for value in my_list:
    print(value)

迭代器的应用场景

我们发现迭代器最核心的功能就是可以通过next()函数的调用来返回下一个数据值。如果每次返回的数据值不是在一个已有的数据集合中读取的，而是通过程序按照一定的规律计算生成的，那么也就意味着可以不用再依赖一个已有的数据集合，也就是说不用再将所有要迭代的数据都一次性缓存下来供后续依次读取，这样可以节省大量的存储（内存）空间。
迭代器也不像递归一样有上限，迭代器可以一直迭代
查看和修改递归上限

import sys
print(sys.getrecursionlimit())
sys.setrecursionlimit(2000)
print(sys.getrecursionlimit())

使用迭代器实现Fibonacci数列

class Fibonacci(object):
    def __init__(self, num):
        self.num = num

    def __iter__(self):
        self.index = 0
        self.first_num = 0
        self.second_num = 1
        return self

    def __next__(self):
        if self.index < self.num:
            result = self.first_num
            self.first_num, self.second_num = self.second_num, self.first_num + self.second_num
            self.index += 1
            return result
        else:
            raise StopIteration


fib = Fibonacci(10)
for i in fib:
    print(i)

for循环的本质

遍历的是可迭代对象

for item in Iterable 循环的本质就是先通过iter()函数获取可迭代对象Iterable的迭代器，然后对获取到的迭代器不断调用next()方法来获取下一个值并将其赋值给item，当遇到StopIteration的异常后循环结束。
遍历的是迭代器

for item in Iterator 循环的迭代器，不断调用next()方法来获取下一个值并将其赋值给item，当遇到StopIteration的异常后循环结束。

生成器

生成器是一类特殊的迭代器,它不需要再像上面的类一样写iter()和next()方法了,使用更加方便,它依然可以使用next函数和for循环取值

创建生成器方法

1.简单生成器

my_generator = (i * 2 for i in range(5))

2、在def函数里面看到有yield关键字那么就是生成器

def fabonacci(n):
    a, b = 0, 1
    current_index = 0
    while current_index < n:
        result = a
        current_index += 1
        a, b = b, a + b
        yield result


f = fabonacci(10)
for i in f:
    print(i)

生成器使用return关键字

def fibonacci(num):
    a = 0
    b = 1
    # 记录生成fibonacci数字的下标
    current_index = 0
    print("--11---")
    while current_index < num:
        result = a
        a, b = b, a + b
        current_index += 1
        print("--22---")
        # 代码执行到yield会暂停，然后把结果返回出去，下次启动生成器会在暂停的位置继续往下执行
        yield result
        print("--33---")
        return "嘻嘻"

fib = fibonacci(5)
value = next(fib)
print(value)
# 提示： 生成器里面使用return关键字语法上没有问题，但是代码执行到return语句会停止迭代，抛出停止迭代异常
# 在python3里面可以使用return关键字，python2不支持

# return 和 yield的区别
# yield: 每次启动生成器都会返回一个值，多次启动可以返回多个值，也就是yield可以返回多个值
# return: 只能返回一次值，代码执行到return语句就停止迭代

try:
    value = next(fib)
    print(value)
except StopIteration as e:
    # 获取return的返回值
    print(e.value)

每次启动生成器都会返回一个值，多次启动可以返回多个值，也就是yield可以返回多个值

:如果第一次启动生成器使用send方法，那么参数只能传入None,一般第一次启动生成器使用next函数

def gen():
    i = 0
    while i < 5:
        temp = yield i
        print(temp)
        i += 1


f = gen()
f.send(None)
f.send("yang")