python迭代器

学习笔记

一、什么是迭代

迭代是访问序列类型元素的一种方式

nums = [1,2,3,4,5,6,7,8,9,0]

# 可以通过for循环将nums列表中的每个元素依次获取
for num in nums:
	print(num)
	
# -----------------

str1 = 'hello,my name is jack'
for i in str1:
	print(i)

可以对`list`、`tuple`、`str`等类型的数据使用`for...in...`的循环语法从其中依次拿到数据进行使用
我们把这样的过程称为遍历，也叫'迭代'

二、可迭代对象

是否所有的数据类型都可以放到`for...in...`的语句中，然后让`for...in...`每次从中取出一条数据供我们使用呢？

num = 40025
for i in num:
	print(i)	# 报错

我们可以通俗的认为：只要是可以通过`for...in...`的形式进行遍历的，那么这个数据类型就是可以迭代的

例如，下面的是可以迭代的数据类型
列表（list）、元组（tuple）、字典（dict）、字符串（str）

而下面的则是不可以迭代的数据
整形（int）、浮点型（float）


只要是通过`isinstance`来判断出是`Iterable`类的实例，即`isinstance`的结果是`True`
那么就表示，这个数据类型是可以迭代的数据类型

三、迭代器

迭代器是一个可以记住遍历的位置的对象，迭代器对象从第一个元素开始访问
直到所有的元素被访问结束。迭代器只能往前不会后退。

可迭代对象的本质

可迭代对象进行迭代的过程，发现每一次迭代(即在	for....in....中每循环一次)
都会返回对象中的下一条数据，一直向后读取数据直到迭代了所有的数据后结束

那么在这个过程中就应该有一个“人”去记录每次访问到了第几条数据，
以便每次迭代都可以返回下一条数据。我们把这个能帮助我们进行数据迭代的“人”称为迭代器(Iterator)

可迭代对象的本质就是可以向我们提供这样一个这样的中间人，即迭代器帮助我们对其进行迭代遍历使用

`list`、`tuple`等都是可迭代对象，我们可以通过`iter()`函数获取这些可迭代对象的迭代器。
然后我们可以对获取到的迭代器不断使用`next()`函数来获取下一条数据。

获取可选迭代对象的迭代器

# 获取可选迭代对象的迭代器
from collections.abc import Iterable

nums = [11,22,33,44]
print(type(nums))

nums_iter = iter(nums)
print(type(nums_iter))

print('nums',isinstance(nums,Iterator))
print('nums_iter',isinstance(nums_iter,Iterator))

# <class 'list'>
# <class 'list_iterator'>
# nums False
# nums_iter True

获取迭代器的数据

通过`iter()`能够得到一个可迭代对象的 迭代器，
可以通过`next()`函数多次提取迭代器中的数据，

from collections.abc import Iterator

nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
nums_iter = iter(nums)

print(isinstance(nums, Iterator))
print(isinstance(nums_iter, Iterator))

num1 = next(nums_iter)
print(num1)
num2 = next(nums_iter)
print(num2)
num3 = next(nums_iter)
print(num3)
# False
# True
# 1
# 2
# 3

Stopiteration异常

数据迭代完后继续使用next()方法会报错

from collections.abc import Iterator


nums = [11, 22, 33, 44]
nums_iter = iter(nums)

print("nums", isinstance(nums, Iterator))
print("nums_iter", isinstance(nums_iter, Iterator))


num1 = next(nums_iter)
print(num1)

num2 = next(nums_iter)
print(num2)

num3 = next(nums_iter)
print(num3)

num4 = next(nums_iter)
print(num4)

num5 = next(nums_iter)  # 这里会产生异常
print(num5)

为什么会产生异常，其实就是一种告知迭代结束的标志而已

添加`try...except...`即可解决刚刚遇到的问题

try:
    num5 = next(nums_iter)
    print(num5)
except StopIteration as e:
    print(f'迭代结束: {e}')

4.自定义迭代器

> __iter__方法
> __next__方法

__iter__方法

只要在类中定义`__iter__`方法，那么这个类创建出来的对象一定是可迭代对象

通俗的说：一个具备了`__iter__`方法的对象就是一个可以迭代的对象

测试代码一没有__iter__方法

from collections.abc import Iterable
class MyList(object):
    def __init__(self):
        self.container = []

    def add(self, item):
        self.container.append(item)


mylist = MyList()
mylist.add(11)
mylist.add(22)
mylist.add(33)

print("mylist是否是可以迭代对象", isinstance(mylist, Iterable))

for temp in mylist:
    print(temp)

# mylist是否是可以迭代对象 False
# Traceback (most recent call last):
#  File "/home/ubuntu/Desktop/stu_code/测试代码.py", # line 19, in <module>
#    for temp in mylist:
# TypeError: 'MyList' object is not iterable

测试代码二有__iter__方法

from collections.abc import Iterable


class MyList(object):
    def __init__(self):
        self.container = []

    def add(self, item):
        self.container.append(item)

    def __iter__(self):
        pass

mylist = MyList()
mylist.add(11)
mylist.add(22)
mylist.add(33)

print("mylist是否是可以迭代对象", isinstance(mylist, Iterable))

for temp in mylist:
    print(temp)

其实，当我们调用`iter()`函数提取一个可迭代对象的 迭代器时，实际上会自动调用这个对象的`__iter__`方法，并且这个方法返回迭代器

__next__方法

实际上，在使用`next()`函数的时候，调用的就是迭代器对象的`__next__`方法（Python3中是对象的`__next__`方法，Python2中是对象的`next()`方法）。

所以，我们要想构造一个迭代器，就要实现它的`__next__`方法。

但这还不够，python要求迭代器本身也是可迭代的，所以我们还要为迭代器实现`__iter__`方法，而`__iter__`方法要返回一个迭代器，迭代器自身正是一个迭代器，所以迭代器的`__iter__`方法返回自身即可。

一个实现了`__iter__`方法和`__next__`方法的对象，就是迭代器

如何判断一个对象是否是迭代器

可以使用 isinstance() 判断一个对象是否是 Iterator 对象

class MyList(object):
    """自定义的一个可迭代对象"""
    def __init__(self):
        self.items = []

    def add(self, val):
        self.items.append(val)

    def __iter__(self):
        myiterator = MyIterator(self)
        return myiterator


class MyIterator(object):
    """自定义的供上面可迭代对象使用的一个迭代器"""
    def __init__(self, mylist):
        self.mylist = mylist
        # current用来记录当前访问到的位置
        self.current = 0

    def __next__(self):
        if self.current < len(self.mylist.items):
            item = self.mylist.items[self.current]
            self.current += 1
            return item
        else:
            raise StopIteration

    def __iter__(self):
        return self


if __name__ == '__main__':
    mylist = MyList()
    mylist.add(1)
    mylist.add(2)
    mylist.add(3)
    mylist.add(4)
    mylist.add(5)
    for num in mylist:
        print(num)
  # 1 2 3 4 5

可迭代对象通过`__iter__`方法向我们返回一个迭代器，我们在迭代一个可迭代对象的时候，实际上就是先获取该对象提供的一个迭代器，然后通过这个迭代器来依次获取对象中的每一个数据。

for…in…循环的本质

1. 先调用`iter()`函数，它会自动调用可迭代对象中的`__iter__`方法，此方法返回这个可迭代对象的 迭代器对象
2. 对获取到的迭代器不断调用`next()`函数，它会自动调用迭代器中的`__next__`方法来获取下一个值
3. 当遇到`StopIteration`异常后循环结束

简单总结

- 凡是可作用于`for `循环的对象都是` Iterable` 类型
- 凡是可作用于 `next()` 函数的对象都是` Iterator` 类型
- 序列数据类型如` list` 、`dict`、`str`等是 `Iterable `但不是`Iterator`，不过可以通过 `iter() `函数获得一个 `Iterator `对象