迭代器和生成器的学习笔记

迭代器       

Python 迭代器是一种对象，它实现了迭代协议，包括 __iter__() 和 __next__() 方法。迭代器可以让你在数据集中逐个访问元素，而无需关心数据布局的底层实现。与列表或其他集合相比，迭代器可以节流内存，因为它们一次只生成一个元素。
迭代器的基本特点

• 懒加载：迭代器不会一次性将所有数据加载到内存中，而是根据需要生成元素。
  
• 状态保持：迭代器在迭代过程中会保持其状态，可以从上次停止的地方继承迭代。
  
• 可以遍历：迭代器是可遍历的，可以使用 for 循环等布局来举行遍历。
  

 下面的代码可以看出迭代器在节流内存方面的作用。

1. import sys
2. import random
4. # 生成 1-100的随机数的集合，共1000个元素
5. numbers = [random.randint(1, 100) for _ in range(1000)]
6. iterator = iter(numbers)
8. # 打印对象的内存大小
9. print(sys.getsizeof(numbers))   # 9016
10. print(sys.getsizeof(iterator))  # 48

复制代码

 迭代器的经典demo：

1. # 创建一个简单的迭代器
2. class MyIterator:
3.     def __init__(self, limit):
4.         self.limit = limit
5.         self.current = 0
7.     def __iter__(self):
8.         return self
10.     def __next__(self):
11.         if self.current < self.limit:
12.             self.current += 1
13.             return self.current
14.         else:
15.             raise StopIteration
17. # 使用迭代器
18. for num in MyIterator(5):
19.     print(num)

复制代码

 迭代器在读取大文件的经典应用：

1. with open('users.csv', 'r') as file:
2.     for line in file:
3.         print(line.strip())

复制代码

         逐行读取文件内容，而不需要将整个文件加载到内存中。这种方法节流了内存资源，特别是在处置惩罚非常大的文件时。
生成器

生成器是一种特别类型的迭代器，它允许你在函数中暂停执行并在以后继承。 
使用 yield 的基本概念

• 生成器函数：当一个函数包含yield语句时，它不再是一个普通的函数，而是一个生成器函数。当调用这个函数时，它不会立即执行，而是返回一个生成器对象。
  
• 状态保存：每次调用生成器的__next__()方法（大概使用next()函数）时，生成器函数会从上次执行的位置继承执行，直到碰到下一个yield语句。在此时，函数的执行状态（包括局部变量）会被保存。
  
• 迭代：生成器可以被用于迭代，像普通的列表或其他可迭代对象一样。使用for循环可以逐个获取生成器产生的值。
  

1. # 定义一个生成器函数
2. def read_users():
3.     with open('users.csv', 'r') as file:
4.         for line in file:
5.             yield line.strip()
8. r1 = read_users()  # 定义一个生成器对象
9. r2 = read_users()  # 定义另一个生成器对象
10. print(next(r1))
11. print(next(r1))
12. print(next(r1))
13. print(next(r1))
14. print(next(r2))
15. print(next(r2))
16. print(next(r2))
17. print(next(r2))

复制代码

局部变量保存的demo

1. list1 = ['a', 'b', 'c', 'd', 'e', 'f']
4. def iterator():
5.     i = 0
6.     for x in list1:
7.         yield do_something(i, x)
8.         i += 1
11. def do_something(i, x):
12.     print(i, x)
15. r1 = iterator()  # 定义一个生成器对象
16. r2 = iterator()  # 定义另一个生成器对象
17. next(r1)
18. next(r1)
19. next(r1)
20. next(r1)
21. next(r2)
22. next(r2)
23. next(r2)
24. next(r2)
25. next(r2)
26. 运行结果：
27. 0 a
28. 1 b
29. 2 c
30. 3 d
31. 0 a
32. 1 b
33. 2 c
34. 3 d
35. 4 e

复制代码

更深入理解yield的“暂停”

函数每次碰到yield就暂停，它并不在意yield时来自于循环、迭代大概是在函数体内重复定义的，这意味着一个函数中可以有不止一个yield，并且每次运行到yield时，函数就暂停运行，并保存中间效果和变量，直到下一次next()后继承运行。

1. list1 = ['a', 'b', 'c', 'd', 'e', 'f']
4. def iterator():
5.     for x in list1:
6.         yield print(x)
7.         yield print(x)
8.         yield print(x)
9.         yield print(x)
12. r1 = iterator()  # 定义一个生成器对象
13. next(r1)
14. next(r1)
15. next(r1)
16. next(r1)
17. next(r1)
18. next(r1)
20. # 运行结果：
21. # a
22. # a
23. # a
24. # a
25. # b
26. # b

复制代码

可以将yield理解为一个中断标记

        可以将yield理解为一个中断标记，当生成器碰到 yield 语句时，它会暂停执行，并返回 yield 背面跟随的值大概函数。假如yield背面没有跟随内容，那么它就仅仅是一次暂停标记而已。

1. list1 = ['a', 'b', 'c', 'd', 'e', 'f']
4. def iterator():
5.     i = 0
6.     for x in list1:
7.         print('loop', i)
8.         yield
9.         i += 1
10.         print(x)
13. r1 = iterator()  # 定义一个生成器对象
14. next(r1)
15. next(r1)
16. next(r1)
17. # 执行结果：
18. # loop 0
19. # a
20. # loop 1
21. # b
22. # loop 2

复制代码

 yield的灵活运用

既然函数每次碰到yield就暂停，它并不在意yield时来自于循环、迭代大概是在函数体内重复定义的，而且可以将yield理解为一个中断标记，那么我们也就可以生成一个不循环的函数，通过yield达到步进执行的效果。

1. list1 = ['a', 'b', 'c', 'd', 'e', 'f']
4. def iterator():
5.     i = 0
6.     print('breakpoint', i)
7.     yield
8.     i += 1
9.     print('breakpoint', i)
10.     yield
11.     i += 1
12.     print('breakpoint', i)
13.     yield
14.     i += 1
15.     print('breakpoint', i)
16.     yield
17.     i += 1
18.     print('breakpoint', i)
21. r1 = iterator()  # 定义一个生成器对象
22. next(r1)
23. next(r1)
24. next(r1)
25. # 执行结果：
26. # breakpoint 0
27. # breakpoint 1
28. # breakpoint 2

复制代码

留意可暂停和可迭代次数

要包管调用的次数不要大于可迭代次数大概可暂停次数，否则就会报错。

1. def iterator():
2.     i = 0
3.     print('breakpoint', i)
4.     i += 1
5.     yield
6.     print('breakpoint', i)
7.     i += 1
8.     yield
11. r1 = iterator()  # 定义一个生成器对象
12. next(r1)
13. next(r1)
14. next(r1)

复制代码

上面的例子，定义了两个yield，但是next（）调用了三次，所以出错。 

1. list1 = [1, 2, 3]
4. def iterator():
5.     for i in list1:  # 遍历列表
6.         yield print(i)
9. r1 = iterator()  # 定义一个生成器对象
10. next(r1)
11. next(r1)
12. next(r1)
13. next(r1)

复制代码

这个，由于调用次数大于了列表的元素数量，也会出错。
采取措施，避免步伐崩溃

1、使用try

1. def iterator():
2.     i = 0
3.     print('breakpoint', i)
4.     i += 1
5.     yield
6.     print('breakpoint', i)
7.     i += 1
8.     yield
11. r1 = iterator()  # 定义一个生成器对象
14. def next_do():
15.     try:
16.         next(r1)
17.     except StopIteration:
18.         print("No more items to yield")
21. next_do()
22. next_do()
23. next_do()
24. next_do()

复制代码

1. list1 = [1, 2, 3]
4. def iterator():
5.     for i in list1:  # 遍历列表
6.         yield print(i)
9. r1 = iterator()  # 定义一个生成器对象
12. def next_do():
13.     try:
14.         next(r1)
15.     except StopIteration:
16.         print("No more items to yield")
19. next_do()
20. next_do()
21. next_do()
22. next_do()
23. next_do()
25. # 运行结果：
26. # 1
27. # 2
28. # 3
29. # No more items to yield
30. # No more items to yield

复制代码

2、指定next()的默认返回值参数，假如指定了该参数，并且迭代器没有更多的值可返回，则返回该参数的值，而不是引发 StopIteration 非常。

1. def iterator():
2.     i = 0
3.     print('breakpoint', i)
4.     i += 1
5.     yield
6.     print('breakpoint', i)
7.     i += 1
8.     yield
11. def next_do():
12.     if next(r1, 'END'):  # 指定next()的默认返回值，可以是任意非None值
13.         print('No more items to yield')
16. r1 = iterator()  # 定义一个生成器对象
18. next_do()
19. next_do()
20. next_do()
21. next_do()
22. next_do()
24. # 运行结果：
25. # breakpoint 0
26. # breakpoint 1
27. # No more items to yield
28. # No more items to yield
29. # No more items to yield

复制代码

send()的用法

1. def generator_with_send():
2.     received = yield  # yield 语句会暂停生成器，等待 send() 方法的调用并返回 yield 语句后面的值
3.     yield received  # 输出接收到的值
6. gen = generator_with_send()
8. next(gen)  # 启动生成器
9. print(gen.send('this is send1'))  # 通过 send() 方法向生成器发送数据

复制代码

 多次发送

1. def generator_with_send():
2.     received = yield  # 第一次调用 `send` 时暂停在此处
3.     yield received  # 输出第一次接收到的值
4.     received = yield  # 再次暂停，准备接收下一个值
5.     yield received  # 输出第二次接收到的值
6.     received = yield  # 再次暂停，准备接收下一个值
7.     yield received  # 输出第三次接收到的值
10. gen = generator_with_send()
12. next(gen)  # 启动生成器
13. print(gen.send('this is send1'))  # 发送数据
14. next(gen)  # 继续执行，准备接收下一个值
15. print(gen.send('this is send2'))  # 发送数据
16. next(gen)  # 继续执行，准备接收下一个值
17. print(gen.send('this is send3'))  # 发送数据
20. # 输出结果为：
21. # this is send1
22. # this is send2
23. # this is send3

复制代码

OR:

1. def generator_with_send():
2.     received = yield  # 第一次调用 `send` 时暂停在此处
4.     received = yield received  # 每次重新接收 send() 发送的值
5.     received = yield received  # 每次重新接收 send() 发送的值
6.     received = yield received  # 每次重新接收 send() 发送的值
9. gen = generator_with_send()
11. next(gen)  # 启动生成器
12. print(gen.send('this is send1'))  # 第一次发送 'this is send1'
13. print(gen.send('this is send2'))  # 第二次发送 'this is send2'
14. print(gen.send('this is send3'))  # 第三次发送 'this is send3'

复制代码

 
 OR:

1. def generator_with_send():
2.     received = yield  # 第一次调用 `send` 时暂停在此处
3.     while True:
4.         received = yield received  # 每次重新接收 send() 发送的值
7. gen = generator_with_send()
9. next(gen)  # 启动生成器
10. print(gen.send('this is send1'))  # 第一次发送 'this is send1'
11. print(gen.send('this is send2'))  # 第二次发送 'this is send2'
12. print(gen.send('this is send3'))  # 第三次发送 'this is send3'

复制代码

close()的用法

        close()方法用于关闭生成器，关闭后，假如实验迭代或规复执行生成器，会引发 StopIteration 非常。
        在生成器中，close() 方法会触发 GeneratorExit 非常，通过捕获这个非常，在生成器中举行必要的清理工作（比如释放资源、关闭文件等）。

1. def my_generator():
2.     try:
3.         while True:
4.             value = yield
5.             print(f"Received: {value}")
6.     except GeneratorExit:
7.         print("Generator is being closed.")
9. gen = my_generator()
11. # 启动生成器
12. next(gen)
14. # 发送一些值
15. gen.send('Hello')
16. gen.send('World')
18. # 关闭生成器
19. gen.close()
21. # 再次尝试发送值会引发 StopIteration 异常
22. try:
23.     gen.send('This will not work')
24. except StopIteration:
25.     print("Generator is closed and cannot receive values.")

复制代码

 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。