3-可迭代对象迭代器生成器的原理剖析

一、可迭代对象：有_ _iter_ _方法

二、迭代器：同时有 _ _iter_ _和 _ _next_ _方法

三、生成器：yield / (i for in in range(n))

四、字典、元祖、列表等可迭代对象

可以被迭代若干次

可以被转换成迭代器对象（使用iter方法）

一、可迭代对象

首先来看一下，python 2.7版本range的实现原理：

from typing import Iterable


def range_test(stop):
    start = 0
    result = []
    while start < stop:
        result.append(start)
        start += 1
    return result


if __name__ == '__main__':
    print(isinstance(range_test(10),Iterable))  # 判断返回结果是不是可迭代，True
    print(range_test(10))                     # output：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

这种方式，需要多少数据，全部存在list中，在数据量比较大的情况下，是非常耗内存的。

那么如何实现高性能(省内存)的呢？请看实现：

省内存：延迟生成数据，节省内存

from typing import Iterable


# Next含有__next__()方法，每次变量＋1，一次只占用一个数的内存
class Next(object):
    """Next class"""

    def __init__(self, stop, start=-1):
        self.start = start
        self.stop = stop

    def __next__(self):
        if self.start >= self.stop - 1:
            raise StopIteration
        self.start += 1
        return self.start


# 含有__iter__()方法，return调用Next
class MyRange:

    def __init__(self, stop):
        self.stop = stop

    def __iter__(self):
        return Next(self.stop)


if __name__ == '__main__':
    print(Next(10).__next__())  # 0


    print(isinstance(MyRange(10), Iterable))  # True  (因为MyRange有__iter__())
    print(isinstance(Next(10), Iterable))  # False (Next没有__iter__())

    for i in MyRange(10):  # for循环自动执行__iter__,__next__方法
        print(i)  # 0,1,2,3,4,5,6,7,8,9

    # 下面用while循环，解释下运行的原理。（for的原理，for是一种语法，会自动执行__next__()）
    num = MyRange(10).__iter__()
    i = 0
    while i < 10:
        print(num.__next__())  # 0,1,2,3,4,5,6,7,8,9
        i += 1

总结：

1.可迭代对象：对象必须要有_ _iter_ _()方法

（能被for迭代的对象都是可迭代对象）：这里给你们捋一捋思路，能够被for迭代是因为for会自动调用__iter__(),那有了__iter__,就符合可迭代对象的基本定义了。

常见的可迭代对象：list,str,tuple

我们也可以用dir()自省，来判断某个每个对象是不是可迭代对象。自省的结果中有_ _iter_ _（），说明是可迭代对象。

上面的例子可以用hasattr()验证,返回值是bool类型，可迭代对象是否有_ _iter_ _()：--------hasattr() 函数用于判断对象是否包含对应的属性。

 print(hasattr(list,"__iter__")) # True
 print(hasattr(str, "__iter__")) # True
 print(hasattr(tuple, "__iter__")) # True

2.for 用在迭代的场景，能用for,就不用while。不会越界，比较安全。（for 循环不会越界，while循环很容易越界，while通常用在自由执行循环的场景

二、迭代器

内置函数next():

首先来看下next()源码：

def next(iterator, default=None): # real signature unknown; restored from __doc__
    """
    next(iterator[, default])
    
    Return the next item from the iterator. If default is given and the iterator
    is exhausted, it is returned instead of raising StopIteration.
    """
    pass

看见没？想要使用next()函数，参数必须是个迭代器！！！

来看看list,能不能使用next()方法：

print(next([1,2]))
"""
    print(next([1,2]))
TypeError: 'list' object is not an iterator
"""

哎呀，报错了：list对象不是一个迭代器！！

因为next([1,2])实际上执行的是[1,2]._ _next_ _(). 但是list没有_ _next_ _()属性，就会报错（list不是一个迭代器）

print(hasattr(list,"__next__")) # False

那什么是迭代器？？

迭代器：

必须同时有 _ _iter_ _和 _ _next_ _方法，才是迭代器

核心：通过_ _next_ _方法记住迭代的位置，有没有迭代完毕。

举例：上面例子中的class Next,里面有_ _next_ _,是不是迭代器呢？

class Next(object):
    """Next class"""

    def __init__(self, stop, start=-1):
        self.start = start
        self.stop = stop

    def __next__(self):
        if self.start >= self.stop - 1:
            raise StopIteration
        self.start += 1
        return self.start


if __name__ == '__main__':
    print(isinstance(Next(2),Iterator))  #False 因为虽然含有__next__属性，但是没有__iter__属性，不是一个迭代器

栗子2：

class Fruit:
    """ class Fruit
    :param
    :raise Raise StopIteration if index out of len(friuts)
    """

    def __init__(self):
        self.fruit = ["apple","peach","banana","grape"]
        self.index = 0

    def __next__(self):
        if self.index >= len(self.fruit):
            raise StopIteration
        self.index += 1
        return self.fruit[self.index - 1]

if __name__ == '__main__':
    fruit = Fruit()
    for item in fruit:      #对fruit对象进行迭代，不是一个可迭代对象，因为没有_ _iter_ _
        print(item)
"""
    for item in fruit:
TypeError: 'Fruit' object is not iterable
"""

下面加上一个_ _iter_ _方法，再来看一下

class Fruit(object):
    """ class Fruit
    :param
    :raise Raise StopIteration if index out of len(friuts)
    """

    def __init__(self):
        self.fruit = ["apple", "peach", "banana", "grape"]
        self.index = 0

    def __iter__(self):
        return iter(self.fruit)

    def __next__(self):
        if self.index >= len(self.fruit):
            raise StopIteration
        self.index += 1
        return self.fruit[self.index - 1]


if __name__ == '__main__':
    ft = Fruit()
    for item in ft:
        print(item)
"""
apple
peach
banana
grape
"""

print(isinstance(ft,Iterator)) # True 是迭代器，同时含有__iter__ 和__next__

iter()方法-----iter() 函数用来把可迭代对象生成迭代器

上面的_ _iter_ _()方法的返回值要是一个“迭代器”---严格的说，返回值必须有_ _next_ _()方法，比如开始的例子，MyRange中的_ _iter__()的返回值，调用了Next，有_ _next_ _()方法。

总结：

①迭代器是一个特殊的可迭代对象，特殊在它还有_ _next_ _()方法

注意：上面的 _ _next_ _() 没有被for循环调用，for循环只是自动调用了_ _iter__()。因为自己写的__iter__()，不会去调用_ _next_ _()

那么怎么才能调用_ _next_ _()方法呢？

继承迭代器（直接继承迭代器（已经实现了_ _iter_ _），不需要自己写_ _iter__()方法了）

from typing import Iterator


class Fruit(Iterator):
    """ class Fruit
    :param
    :raise Raise StopIteration if index out of len(friuts)
    """

    def __init__(self):
        self.fruit = ["apple", "peach", "banana", "grape"]
        self.index = 0

    def __next__(self):
        print("这个是__next__ 方法")
        if self.index >= len(self.fruit):
            raise StopIteration
        self.index += 1
        return self.fruit[self.index - 1]


if __name__ == '__main__':
    ft = Fruit()
    for item in ft:
        print(item)
"""
这个是__next__ 方法
apple
这个是__next__ 方法
peach
这个是__next__ 方法
banana
这个是__next__ 方法
grape
这个是__next__ 方法
"""

for 迭代迭代器时，会自动调用_ _next_ _()方法。自己写的那个算个假迭代器，不会执行_ _next_ _().

在实际使用中，直接继承迭代器即可。

总结：

①迭代器的_ _next_ _(),记住迭代的位置

②一次占用一个数的内存，省内存

③for原理：for循环自动调用_ _iter_ _(),而 _ _iter_ _()会调用 _ _next_ _(). ----------------核心

三、生成器

因为迭代器手写比较麻烦，所以python提供了生成器对象。

生成器对象的目的就是获得迭代器对象。

生成器的目的：就是获得迭代器对象（高效）

1.如何创建一个生成器对象？----使用yield

yield关键字----特殊功能，为了生成器而提供的关键字。

即函数中使用yield，调用函数的时候，会先生成一个生成器（而不是直接运行函数）

❤生成器是特殊的迭代器，迭代器是特殊的可迭代对象。（生成器是可迭代对象）

def fun():
    print("在yield1前面")
    yield 1
    print("在yield1后面，yield2前面")
    yield 2


if __name__ == '__main__':
    # 验证是否是生成器
    print(fun())   # <generator object fun at 0x104d00150> 结果是一个生成器对象，但是没有运行函数
    print(hasattr(fun(),"__iter__"))  # True
    print(hasattr(fun(),"__next__"))  # True

    # 运行生成器，必须要调用__next__
    print(fun().__next__())  # 1 / 在yield1前面
    
    # 运行出全部结果,for自动调用__next__
    for i in fun():
        print(i)
"""
在yield1前面
1
在yield1后面，yield2前面
2
"""

①当python解释器看到函数中有yield的时候，不会立即去调用这个函数，而是先创建一个生成器对象。而这个生成器对象会记住函数的状态(存代码，记住函数的执行状态：是否执行？执行到哪里了？)。

②原理解释：在for循环中，运行到第一个yield时，就暂时退出了(类似return，但区别是return是永久跳出不会再回去了)。再次运行时（__next__记住位置），会从yield1后面开始运行。

③ 当执行next(生成器对象)时，会执行生成器对象的yield.

h = fun() # h是一个生成器对象

　　next(h),会执行g里面的yield

④直接调用函数，函数没有直接运行，而是先创建一个生成器对象？那什么时候才能运行yield呢？

❤调用_ _next_ _()方法是会运行yield。如上面例子中运行的for，for会自动调用_ _next_ _()。或者fun()._ _next_ _() ;

⑤生成器就是迭代器的抽象

⑥生成器的使用场景：协程

读写大文件

（一边下载video 一边播放。下载的内容用yield 返回，记录下载返回的数据状态）

⑦生成器省内存的原理：就是因为__next__

生成器是为了快速获得含有_ _next_ _()和_ _iter_ _()方法 ----就是为了获得迭代器。

summary：

1.可迭代对象（含有__iter__）

2.迭代器的特点：

记住遍历位置

迭代器只能被迭代一遍

同时含有__next__() 和__iter__（）

3.迭代器的应用场景：for循环

4.有了循环为啥还要迭代器？循环需要判断便利到哪里，但是迭代器不需要判断

5.什么对象可以转化为迭代器？可迭代对象，用iter()进行转化

6.生成器（特殊的迭代器）：

---简化迭代器创建过程，提供关键字yield

---函数中有yield，调用函数时，函数会先创建一个生成器对象，这个对象就是一个迭代器

---yield 记住执行的位置；保存状态、恢复状态

posted on 2020-11-26 18:12 ananmy 阅读(204) 评论(0) 编辑收藏举报

刷新页面返回顶部

导航

3-可迭代对象 迭代器 生成器的原理剖析

3-可迭代对象迭代器生成器的原理剖析