Python学习迭代器（Iterator）

一、可迭代的对象（Iterable）
   1、定义：可以直接用在循环的数据类型，如list,tuple,dict,set,str，还有generator（生成器），
           和带yield的函数，这些直接可以用在循环的对象统称为可迭代对象(Iterable)

from collections import Iterable
print(isinstance([], Iterable))
print(isinstance((), Iterable))
print(isinstance({}, Iterable))
print(isinstance("abc", Iterable))
print(isinstance((x for x in range(10)), Iterable)) # 生成器也是可迭代对象
print(isinstance(10, Iterable)) # 数字不是可迭代对象

 二、迭代器（Iterator）

   1、定义：生成器不但可以用在循环中，还能用next()不断调用返回下一个值，直到爆出StopIteration异常，
   2、可迭代对象和迭代器和区别：迭代器和可迭代对象不是同个概念，区别在于是否有next函数（可以用dir(object)来查看此对象的所有支持的函数）。

print(isinstance((), Iterator))
print(isinstance({}, Iterator))
print(isinstance("abc", Iterator))
print(isinstance((x for x in range(10)), Iterator))  # 生成器是迭代器
print(isinstance(10, Iterator))  # 数字不是迭代器对象

 三、可迭代对象与迭代器之间的转换

   1、使用iter()函数将可迭代对象转换成迭代器。

list1 = iter([1,2,3,4,5])
print(list1.__next__())
print(list1.__next__())

   2、为什么像list,string,tuple这样的可迭代对象不是迭代器？
       因为这些数据结构是将已经存在的数据赋值他们，而迭代器是惰性计算的程序流，他甚至没有数据，所以可迭代对象只能表示有限的元素个数，而迭代器甚至可以表示整个自然数集合。

 四、python很多功能都有迭代器的影子，举一些内置迭代器的例子

   1、循环用到的range()，其实就是一个迭代器，比如range(10000)，不是生成一个10000个元素的集合，而内置了next函数，逐个生成。
   2、文件调用的时候file.redelines()，是返回一个列表，而 for line in file: 则是迭代器中逐行前进，也是内置了next函数

 五、小结：迭代器是一个概念，其实就是生成器的应用。

Python中的迭代器是一种对象，它可以迭代（遍历）一个可迭代对象（比如列表、元组或字符串）的元素。迭代器用于实现迭代器协议，即包含 __iter__() 方法和 __next__() 方法。

 迭代器的工作原理是每次调用 __next__() 方法时返回可迭代对象的下一个元素，当没有元素可迭代时，抛出 StopIteration 异常。

class MyIterator:
def __init__(self, iterable):
self.iterable = iterable
self.index = 0

def __iter__(self):
return self

def __next__(self):
if self.index < len(self.iterable):
result = self.iterable[self.index]
self.index +=1
return result
else:
raise StopIteration

# 创建一个可迭代对象
my_list = [1, 2, 3, 4, 5]

# 创建一个迭代器
my_iterator = MyIterator(my_list)

# 使用迭代器遍历元素
for item in my_iterator:
print(item)
值得注意的是，当迭代器耗尽后，如果再次使用迭代器来便利，将不会得到任何输出。
所以总的来说，迭代器是用于遍历可迭代对象的对象，它实现了迭代器协议，具有 __iter__() 和 __next__() 方法。

可迭代对象
我们看迭代器好像和平时我们使用的列表、字典等数据结构一样，都可以遍历，那么列表、字典等数据结构是迭代器吗？

不好意思，他们不是迭代器，而是可迭代对象（iterable）。

可迭代对象（iterable）是指具有迭代行为的对象。当我们希望能够按照一定方式遍历对象中的元素时，我们可以将该对象称为可迭代对象。换句话说，可迭代对象是一种提供迭代能力的容器。
可迭代对象的特点是实现了 __iter__() 方法，这个方法返回一个迭代器（iterator）。迭代器是能够按照一定顺序生成下一个元素的对象。

在 Python 中，许多数据结构都是可迭代对象，比如列表、元组、集合、字典等。我们可以使用for循环对这些对象进行遍历。

同时，也可以使用内置的 iter() 函数将可迭代对象转换为迭代器。迭代器是可迭代对象的一种特殊形式，实现了 __iter__() 和 __next__() 方法。迭代器可以使用 next() 函数来获取下一个元素，并且在没有元素可返回时引发 StopIteration 异常。

my_list = [1, 2, 3, 4, 5] # 列表是可迭代对象
for item in my_list:
print(item)

my_iterator = iter(my_list) # 使用iter()函数将列表这个可迭代对象转换为迭代器
print(next(my_iterator)) # 输出第一个元素
print(next(my_iterator)) # 输出第二个元素
在这个示例中，列表 my_list 是可迭代对象，它可以被 for 循环遍历。另外，我们还使用 iter() 函数将 my_list 转换为迭代器 my_iterator，并使用 next() 函数逐个访问其中的元素。

所以总的来说，可迭代对象是指具有迭行为的对象，它们实现了 __iter__() 方法。通过for循环或 iter() 函数，我们可以遍历这些对象的元素。

可迭代对象是指实现了 __iter__() 方法的对象，而迭代器是实现了 __iter__() 和 __next__() 方法的对象，这个可以说是它们比较明显的区别。

for循环机制
从上面我们指定，列表、元组、集合、字典等数据结构是可迭代对象，并不是迭代器。而可迭代对象只实现了__iter__()方法，并不具有迭代（也就是返回下一个元素）的功能。那么很多同学可能就比较奇怪了，我们平时使用for循环遍历这个数据结构的时候，内部是怎么遍历的呢？

实际上在 Python 中，for循环在内部自动会调用 __iter__() 函数将可迭代对象转换为迭代器。用for循环遍历可迭代对象的实现机制为：

for循环首先会调用 __iter__() 函数，该函数会将可迭代对象转换为一个迭代器对象（如果对象本身就是迭代器，则不作转换）。
接下来，for循环会调用迭代器对象的 __next__() 方法来获取下一个元素。如果迭代器对象没有下一个元素，会抛出 StopIteration 异常。
for循环会自动捕捉 StopIteration 异常，表示已经迭代完所有元素，循环将结束。
所以以下两个方法实际上是等价的。

my_string = "Hello"

for char in my_string:
print(char)
实际上完全等价于：

my_string = "Hello"
my_iterator = iter(my_string)

print(next(my_iterator)) # 输出：H
print(next(my_iterator)) # 输出：e
print(next(my_iterator)) # 输出：l
print(next(my_iterator)) # 输出：l
print(next(my_iterator)) # 输出：o
生成器
生成器（Generator）是一种特殊的迭代器，它可以在迭代过程中动态地生成值，而不是一次性地将所有元素放在内存中。生成器使用 yield 关键字来定义，当生成器的代码块执行到 yield 语句时，就会暂停执行并返回一个值，下次调用时会从上次暂停的位置继续执行。这样可以在需要的时候生成值，而不是一次性生成所有的值。

def my_generator():
yield 1
yield 2
yield 3

# 使用生成器
gen = my_generator()

print(next(gen)) # 输出：1
print(next(gen)) # 输出：2
print(next(gen)) # 输出：3
print(next(gen)) # 抛出 StopIteration 异常
在上面的示例中，我们定义了一个名为 my_generator 的生成器函数，它通过使用 yield 关键字来产生值。当我们调用生成器函数时，它返回一个生成器对象 gen。我们可以使用 next() 函数来逐个获取生成器的值。每次调用 next() 时，生成器函数会从上次暂停的位置继续执行，并返回 yield 语句的值。当生成器函数执行完毕或没有更多的值可生成时，调用 next() 会抛出 StopIteration 异常。

生成器的一个重要特点是它们可以节省内存，尤其在处理大量数据时非常有用。由于生成器是按需生成值，只有在需要时才会在迭代过程中生成值，不会一次性占用大量的内存。所在遍历大批量数据的时候，非常有用，因为如果将大批量的数据直接加载到内存中在遍历，肯定会消耗很多内存，而利用生成器就可以做到需要哪些遍历哪些。

如果用简单一句话来说就是，我既想大量的数据，又想让它占用空间少，实现鱼和熊掌的兼得，那么就用生成器！

def read_large_file(file_path):
with open(file_path, 'r') as file:
for line in file:
yield line.rstrip()

# 使用生成器遍历大文件
file_generator = read_large_file('large_file.txt')
print(file_generator) # 输出<generator object fibonacci_generator at 0x0000017362DCFED0>
print(type(file_generator)) # 输出<class 'generator'>
for line in file_generator:
# 处理每一行数据
print(line)
从上面可以看出，read_large_file() 函数是一个生成器函数，它按行从一个大文件中读取数据。通过使用 yield 关键字，在每次迭代时逐行生成文件的内容，并将其作为生成器的值返回。然后，我们可以使用 for 循环逐行处理大文件。可以看到，我们打印的file_generator类型是一个生成器。

当然，以上的例子并不一定需要采用生成器才能处理，我们直接在第4行进行处理也是可以的，生成器更多的只是提供一种思路，当你用常规方法不能解决问题的时候，可以试试用生成器。

生成器原理
生成器的原理基于迭代器（iterators）和生成器函数（generator functions）。

def even_numbers(n):
for i in range(1, n+1):
if i % 2 == 0:
yield i

# 创建生成器对象
even_generator = even_numbers(10)

# 打印生成的偶数
for number in even_generator:
print(number)
生成器函数
生成器通过生成器函数创建，生成器函数是一种特殊类型的函数，使用 yield 语句来生成值。像上面的例子even_numbers函数就是要给生成器函数，当调用生成器函数时，它返回一个生成器对象，而不是立即执行函数体内的代码，even_generator就是一个生成器对象。

而之前我们说过生成器是一种特殊类型的迭代器，它可以在迭代中生成值。迭代器是一个实现了 __iter__() 和 __next__() 方法的对象。__iter__() 方法返回迭代器本身，而for循环内部会自动调用 __next__() 方法用于获取下一个值。每次调用 __next__() 方法时，生成器会从上一次暂停的位置继续执行，直到遇到下一个 yield 语句，然后将 yield 后面的值返回给调用者。

逐个生成值
生成器在调用 __next__() 方法时逐个生成值，并且每次在生成一个值后会暂停执行。这种延迟生成的机制使得生成器能够处理大量数据或无限序列，而不需要一次性加载或计算所有值。

状态保存
生成器在暂停执行时会保存其状态，包括局部变量、指令指针等信息。下一次调用 __next__() 方法时，生成器会从上一次暂停的地方恢复执行，并继续执行剩余部分的代码。