深层了解Python迭代器

迭代器

迭代更新是啥

迭代更新指的是一个反复的全过程，每一次反复都务必根据上一次的結果而再次，单纯性的反复并并不是迭代更新，如Python中的for循环便是一个很好的迭代更新事例。

for item in range(10):
    print(item)

迭代更新务必往前推动，不可以倒退，以下所显示：

# [0 , 1, 2, 3, 4, 5, 6, 7, 8, 9]
# ------------------------------>

下边这类方法就不属于迭代更新：

# [0 , 1, 2, 3, 4, 5, 6, 7, 8, 9]
# -------->
#     <----
#          --------------------->

迭代器协议书

在学习培训迭代器的全部知识要点中，迭代器协议书占有了十分关键的部位。

迭代器协议书中包括了两个最基本上的定义，分别是可迭代更新目标和迭代器目标。

• 可迭代更新目标（Iterable）：內部完成了__iter__()方式 的目标则被称作可迭代更新目标
• 迭代器目标（Iterator）：內部完成了__next__()方式 的目标则被称作迭代器目标

彼此之间的关联：

• 在Python中，迭代器目标一定归属于可迭代更新目标范围，也便说迭代器目标务必具备__iter__()方式 及其__next__()方式
• 在Python中，可迭代更新目标不一定归属于迭代器目标范围，换句话说可迭代更新目标只必须完成__iter__()方式 就可以

详细介绍两个涵数：

• iter(Object)涵数，它最底层会实行Object.__iter__()方式
• next(Object)涵数，它最底层会实行Object.__next__()方式

内嵌种类

根据collections.abc下的Iterable类和Iterator类开展判断，可迅速的判断出全部内嵌种类是不是一个可迭代更新目标或是迭代器目标：

>>> from collections.abc import Iterable
>>> from collections.abc import Iterator

>>> isinstance(list(), Iterable)
True
>>> isinstance(list(), Iterator)
False

历经检测，全部的器皿种类（list、tuple、str、dict、set、frozenset）均归属于可迭代更新目标，但不属于迭代器目标

分子种类（bool、int、float、None）等均不属于可迭代更新目标，更不属于迭代器目标。

还可以根据另一种方法开展认证，根据hasattr()涵数，查验类中是不是界定了某一个方式 ：

>>> hasattr(list,"__iter__")
True
>>> hasattr(list,"__next__")
False

for循环基本原理

当可迭代更新目标被for循环开展启用后，最底层实行步骤以下所显示：

1. 将全自动的实行iter()方式 ，该方式 內部会搜索可迭代更新目标的__iter__()方式 ，假如具备该方式 ，则回到一个该可迭代更新目标的专享迭代器目标，要是没有该方式 ，则抛出去TypeError object is not iterable的出现异常。

   Ps：每一次的for循环都是会回到一个全新升级的迭代器目标

2. 持续的启用迭代器目标的__next__()方式 ，而且回到迭代器目标中下一个数值数据，当解析xml进行全部迭代器后，引起Stopiteration出现异常停止迭代更新

   Ps：迭代器自身并不储存一切数值数据，储存的仅仅一个表针，该表针偏向可迭代更新目标中真真正正储存的数值数据，它偏向当今被解析xml到的数值数据数据库索引部位，下一次解析xml则向后推动这一部位

3. for循环全自动的捕获Stopiteration出现异常，而且终止迭代更新

   Ps:for循环最底层便是while循环系统完成的，只不过是加多了3个流程：

   第一步：实行可迭代更新目标的__iter()__方式 并储存回到的专享迭代器

   第二步：持续的实行迭代器的__next()__方式

   第三步：捕捉Stopiteration出现异常

大家手动式的完成一个for循环：

li1 = list(range(10))

iteratorObject = iter(li1)  # ❶
while 1:
    try:
        print(next(iteratorObject))  # ❷
    except StopIteration as e:  # ❸
        break

❶：实行可迭代更新目标的__iter__()方式 并储存回到的专享迭代器

❷：持续的实行迭代器的__next__()方式

❸：捕捉Stopiteration出现异常

线形可迭代更新目标与迭代器的完成

如果是一个线形器皿的可迭代更新目标，那麼它一定具备数据库索引值，我们可以让它的__iter__()方式 回到一个专享的迭代器目标。

随后专享迭代器目标中纪录此次迭代更新解析xml的数据库索引值，依据这一数据库索引值回到可迭代更新目标中的数值数据，当数据库索引值做到可迭代更新目标中数值数据总数量-1的情况下，抛出异常，此次迭代更新完毕：

class linearTypeContainer:
    def __init__(self, array):
        if isinstance(array, list) or isinstance(array, tuple):
            self.array = array
        else:
            raise TypeError("argument array must is linear container")

    def __iter__(self):
        return linearContainer_iterator(self.array)  # ❶


class linearContainer_iterator:
    def __init__(self, array):
        self.index = 0
        self.array = array
        self.len = len(self.array)

    def __next__(self):
        if self.index < self.len:
            retDataItem = self.array[self.index]
            self.index  = 1
            return retDataItem
        else:
            raise StopIteration

    def __iter__(self):  # ❷
        return self


container = linearTypeContainer([i for i in range(10)])
for i in container:
    print(i)
print(list(container))

❶：Python中的一切传参均为引入传送

故linearTypeContainer中的self.array和linearContainer_iterator的self.array全是一个目标，并不会附加开拓存储空间

这也就是为何可迭代更新目标建立的专享迭代器不容易耗费过多的存储空间缘故了。

❷：迭代器目标一定归属于可迭代更新目标范围，因此在这儿大家为迭代器目标linearContainer_iterator类也增加了__iter__()方式

那样做的益处取决于假如独立的拎出了这一迭代器目标，则它也会适用for循环的解析xml：

    def __iter__(self):  # ❷
        return self


containerIterator = linearTypeContainer([i for i in range(10)]).__iter__()


for item in containerIterator:
    print(item)
# 0
# 1
# 2
# 3
# 4
# 5
# 6
# 7
# 8
# 9

假如取消了linearContainer_iterator类的这一__iter__()方式 ，则不兼容for循环的解析xml：

...
    # def __iter__(self):  # ❷
    #     return self


containerIterator = linearTypeContainer([i for i in range(10)]).__iter__()


for item in containerIterator:
    print(item)

# TypeError: 'linearContainer_iterator' object is not iterable

离散系统可迭代更新目标与迭代器完成

如果是一个离散系统器皿的可迭代更新目标，能够先分辨它的种类，假如传到的器皿是一个词典，则将迭代更新的数值数据结合变换为元组，里边储存的所有是词典的key就可以。

假如传到的器皿是一个结合，则将迭代更新的数值数据结合变换为元组，再参考线形可迭代更新目标与迭代器的完成。

实际完成：

class mappingTypeContainer:
    def __init__(self, mapping):
        self.mapping = mapping
        self.mappingType = None

        if isinstance(mapping, dict):
            self.mappingType = "dict"

        elif isinstance(mapping, set) or isinstance(mapping, frozenset):
            self.mappingType = "set"

        else:
            raise TypeError("argument mapping must is mapping container")

    def keys(self):
        if self.mappingType == "set":
            raise TypeError("instance mapping type is set, no have method keys")
        else:
            return self.mapping

    def values(self):
        if self.mappingType == "set":
            raise TypeError("instance mapping type is set, no have method values")
        else:
            return self.mapping.values()

    def items(self):
        if self.mappingType == "set":
            raise TypeError("instance mapping type is set, no have method items")
        else:
            return self.mapping.items()

    def __str__(self):
        return str(self.mapping)

    def __iter__(self):
        return mappingContainer_iterator(tuple(self.mapping))


class mappingContainer_iterator:
    def __init__(self, array):
        self.index = 0
        self.array = array
        self.len = len(self.array)

    def __next__(self):
        if self.index < self.len:
            retDataItem = self.array[self.index]
            self.index  = 1
            return retDataItem
        else:
            raise StopIteration

    def __iter__(self):
        return self


container = mappingTypeContainer({str("k")   str(i): str("v")   str(i) for i in range(3)})

for item in container.items():
    print(item)

print(container)

# ('k0', 'v0')
# ('k1', 'v1')
# ('k2', 'v2')
# {'k0': 'v0', 'k1': 'v1', 'k2': 'v2'}


container = mappingTypeContainer({i for i in range(3)})

for item in container:
    print(item)

print(container)

# 0
# 1
# 2
# {0, 1, 2}

迭代器目标的特点

每一次for循环建立出的可迭代更新目标的专享迭代器全是一次性的，用完后就不起作用了：

# ❶
containerIterator = linearTypeContainer([i for i in range(3)]).__iter__()


for item in containerIterator:
    print(item)

# 0
# 1
# 2

for item in containerIterator:
    print(item)  # ❷
    print("?")

❶：立即取出一个迭代器目标

❷：在第2次循环系统中，迭代器目标中储存的数据库索引值早已较大 了，每一次启用iter()都是会抛出异常回到出去再被for解决，因此print()涵数压根不容易运作

迭代器目标并不储存可迭代更新目标中的真真正正迭代更新数据信息，只是仅储存长短和数据库索引，因此运行内存的占有并不是很多：

class linearContainer_iterator:
    def __init__(self, array):
        self.index = 0  # ❶
        self.array = array  # ❷
        self.len = len(self.array) # ❸
    ...

❶：占有附加的存储空间

❷：引入目标，并不开拓运行内存

❸：占有附加的存储空间

可塑性求值与尽早求值

迭代器目标中针对回到的数值数据，是开展即时运算的，这类即时运算的特点求值方法被称作可塑性求值，即你需要的情况下我算出去后再让你：

    def __next__(self):
        if self.index < self.len:
            retDataItem = self.array[self.index]
            self.index  = 1
            return retDataItem
        else:
            raise StopIteration

除了可塑性求值，也有一种尽早求值的计划方案，即便 你需要一个，因为我把全部的都给你。

如Python2中的range()、map()、filter()、dict.items()、dict.keys()、dict.values()，他们均回到的是一个单纯的目录，那样的设计方案是不科学的。

由于回到的目录会占有非常大的存储空间，而Python3中则统一提升为可塑性求值计划方案，即回到一个可迭代更新目标。

要人命的难题

①：Python中的全部内置器皿种类为什么不自身设成迭代器？

只是在for循环时案例出一个专享的迭代器？

立即在这种内置种类的最底层完成__next__()方式 不太好吗？

那样简直更为降低了运行内存的耗费，少界定了类和创建对象了类吗？

答：这简直一个要人命的难题，这个问题我也想过好长时间，最终是在stackoverflow提出问题而且得到了优良的解释才记下来的。

由于的确是能够完成的，以下所显示，只必须在再加上❶处编码就可以：

class linearTypeContainer:
    def __init__(self, array):
        if isinstance(array, list) or isinstance(array, tuple):
            self.array = array
        else:
            raise TypeError("argument array must is linear container")

        self.index = 0
        self.len = len(self.array)

    def __iter__(self):
        return self

    def __next__(self):
        if self.index < self.len:
            retDataItem = self.array[self.index]
            self.index  = 1
            return retDataItem
        else:
            self.index = 0  # ❶
            raise StopIteration

container = linearTypeContainer(list(range(5)))

for item in container:
    print(item)

for item in container:
    print(item)

for item in container:
    print(item)

可是那样做在某类特殊情况下能发生难题：

container = linearTypeContainer(list(range(5)))

for item in container:
    print(item)
    if container.index == 3:
        break

print("*"*20)

for item in container: 
    print(item)

# 0
# 1
# 2
# ********************
# 3
# 4

你能发觉假如第一次for循环到1半的情况下撤出，第二次for循环会然后依据第一次for循环开展再次。

可以处理一下吗？只必须再加上一个标志位就可以：

class linearTypeContainer:
    def __init__(self, array):
        if isinstance(array, list) or isinstance(array, tuple):
            self.array = array
        else:
            raise TypeError("argument array must is linear container")

        self.index = 0
        self.len = len(self.array)
        self.iter = False # ❶

    def __iter__(self):
        if self.iter: # ❷
            self.index = 0
        self.iter = True
        return self

    def __next__(self):
        if self.index < self.len:
            retDataItem = self.array[self.index]
            self.index  = 1
            return retDataItem
        else:
            self.index = 0
            raise StopIteration


container = linearTypeContainer(list(range(5)))

for item in container:
    print(item)
    if container.index == 3:
        break

print("*" * 20)

for item in container:
    print(item)

# 0
# 1
# 2
# ********************
# 0
# 1
# 2
# 3
# 4

❶：分辨是否一次新的启用

❷：如果是新的启用，则将index再次置为0就可以

那麼为什么Python不那样设计方案呢？大家应当大量的考虑到线程同步的状况下，好几个for循环应用同一个迭代器它是不是线程安全的，上边的实例中这一共享资源迭代器并并不是线程安全的，除此之外它也不兼容嵌套循环，以下所显示，那样会导致不断循环：

container = linearTypeContainer(list(range(5)))

for item in container:
    print(item)
    for j in container:
        print(j)

综上所述各个领域的考虑到，Python将内嵌的基本数据类型，都设定了在for循环时回到专享迭代器的作法，它是很好的设计方案，可是针对有一些内嵌的目标，则是将它自身制成了迭代器，如文档目标。

②：Python2中回到的尽早求值目标，就沒有一点益处吗？真的是消耗运行内存百无一用？

答：也不是，你能发觉Python3中全部回到的尽早求值目标，都不兼容数据库索引实际操作，可是Python2中回到的因为是目录，它可以适用数据库索引实际操作，在一些极其极端化的状况下这的确是个优点，可是Python3的可塑性求值目标必须这类优点吗？你手动式将它变换为list不香吗？那样给予给了你大量可操作性的另外提升了内存占用，不妨一试呢？

③：你可以完成一个回到可塑性求值的目标吗？

答：能啊！你看看，我完成一个Range吧，实际上便是传参部位和内置的不一样，可是它是线程安全的且适用嵌套循环的：

class Range:
    def __init__(self, stop, start=0, step=1):
        self.start = start
        self.stop = stop
        self.step = step
        self.current = None

    def __iter__(self):
        return Range_iterator(self.stop, self.start, self.step)


class Range_iterator:
    def __init__(self, stop, start, step):
        self.start = start
        self.stop = stop
        self.step = step
        self.current = self.start

    def __next__(self):
        if self.current < self.stop:
            retDataItem = self.current
            self.current  = self.step
            return retDataItem
        raise StopIteration


for i in Range(10):
    print(i)
    for j in Range(10):
        print(j)