通过生成器节约内存 列表生成式 迭代器 可迭代对象 惰性计算 yield
实践：
1、
n= 0 b= 1
n= 1 b= 1
n= 2 b= 2
n= 3 b= 3
n= 4 b= 5
n= 5 b= 8
n= 6 b= 13
n= 7 b= 21
n= 8 b= 34
列表生成式
# 列表生成式
[i ** 2 for i in range(1, 11)]
# 加入判断条件
[i ** 2 for i in range(1, 11) if i % 3 == 0]
# 加入循环
[i + j for i in 'abcd' for j in 'xyz']
[i + j + k for i in 'abcd' for j in 'xyz' for k in '12345']
# 获取字典dict k-v
[k + '=>' + str(v) for k, v in {'a': 123, 'b': 456}.items()]
# if-else
[i ** 2 if i%2==0 else i+100 for i in range(1, 11)]
import re
l = ['a', 'b1']
ll = [i if re.search('\d', i) is None else i[0:re.search('\d', i).endpos - 1] for i in l]
9. 类 — Python 3.11.3 文档 https://docs.python.org/zh-cn/3/tutorial/classes.html
9.9. 生成器¶
生成器 是一个用于创建迭代器的简单而强大的工具。 它们的写法类似于标准的函数，但当它们要返回数据时会使用 yield 语句。 每次在生成器上调用 next() 时，它会从上次离开的位置恢复执行（它会记住上次执行语句时的所有数据值）。 一个显示如何非常容易地创建生成器的示例如下:
def reverse(data):
for index in range(len(data)-1, -1, -1):
yield data[index]
>>> for char in reverse('golf'):
... print(char)
...
f
l
o
g
可以用生成器来完成的操作同样可以用前一节所描述的基于类的迭代器来完成。 但生成器的写法更为紧凑，因为它会自动创建 __iter__() 和 __next__() 方法。
另一个关键特性在于局部变量和执行状态会在每次调用之间自动保存。 这使得该函数相比使用 self.index 和 self.data 这种实例变量的方式更易编写且更为清晰。
除了会自动创建方法和保存程序状态，当生成器终结时，它们还会自动引发 StopIteration。 这些特性结合在一起，使得创建迭代器能与编写常规函数一样容易。
9.10. 生成器表达式
某些简单的生成器可以写成简洁的表达式代码，所用语法类似列表推导式，但外层为圆括号而非方括号。 这种表达式被设计用于生成器将立即被外层函数所使用的情况。 生成器表达式相比完整的生成器更紧凑但较不灵活，相比等效的列表推导式则更为节省内存。
示例:
>>> sum(i*i for i in range(10)) # sum of squares
285
>>> xvec = [10, 20, 30]
>>> yvec = [7, 5, 3]
>>> sum(x*y for x,y in zip(xvec, yvec)) # dot product
260
>>> unique_words = set(word for line in page for word in line.split())
>>> valedictorian = max((student.gpa, student.name) for student in graduates)
>>> data = 'golf'
>>> list(data[i] for i in range(len(data)-1, -1, -1))
['f', 'l', 'o', 'g']
通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。
所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。
要创建一个generator，有很多种方法。第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator
# 生成器
g = (x ** 2 if x % 3 == 0 else x + 1000 for x in range(20))
# <generator object <genexpr> at 0x0000000003217A50> 生成器对象
next(g)
def odd():
print('step1')
yield 1
print('step2')
yield 3
print('step3')
yield 5
o = odd()
next(o)
next(o)
# 我们创建了一个generator后，基本上永远不会调用next()，而是通过for循环来迭代它，并且不需要关心StopIteration的错误。
for i in o:
print(1)
o1 = odd()
for i in o1:
print(1)
def fib(max):
n, a, b = 0, 0, 1
while n < max:
print(b)
a, b = b, a + b
n += 1
print('n=', n, ',b=', b)
return 'done'
fib(6)
# 推算规则转换成生成器
# fib函数实际上是定义了斐波拉契数列的推算规则，可以从第一个元素开始，推算出后续任意的元素，这种逻辑其实非常类似generator。
#
# 也就是说，上面的函数和generator仅一步之遥。
def fib_g(max):
n, a, b = 0, 0, 1
while n < max:
yield b
a, b = b, a + b
n += 1
return 'done'
f_g = fib_g(6)
for i in range(7):
r = next(f_g)
print('i=',i,'r=',r)
1
n= 1 ,b= 1
1
n= 2 ,b= 2
2
n= 3 ,b= 3
3
n= 4 ,b= 5
5
n= 5 ,b= 8
8
n= 6 ,b= 13
i= 0 r= 1
i= 1 r= 1
i= 2 r= 2
i= 3 r= 3
i= 4 r= 5
i= 5 r= 8
Traceback (most recent call last):
File "D:/testPy/列表生成式+生成器.py", line 75, in <module>
r = next(f_g)
StopIteration: done
练习题
杨辉三角定义如下：
1
/ \
1 1
/ \ / \
1 2 1
/ \ / \ / \
1 3 3 1
/ \ / \ / \ / \
1 4 6 4 1
/ \ / \ / \ / \ / \
1 5 10 10 5 1
把每一行看做一个list，试写一个generator，不断输出下一行的list
MAX = 100
def triangles():
yield [1]
yield [1, 1]
pre = [1, 1]
i = 0
while i < MAX:
l = []
for i in range(len(pre) - 1):
l.append(pre[i] + pre[i + 1])
l = [1] + l + [1]
yield l
pre = l
i += 1
t = triangles()
for i in range(10):
r = next(t)
print(r)
'''
区分
可迭代对象 Iterable
迭代器 Iterator
'''
from collections import Iterable,Iterator
isinstance([],Iterable)
isinstance({},Iterable)
isinstance('abc',Iterable)
isinstance((1,2,3),Iterable)
isinstance((x for x in range(10)),Iterable)
isinstance([],Iterator)
isinstance({},Iterator)
isinstance('abc',Iterator)
isinstance((1,2,3),Iterator)
isinstance((x for x in range(10)),Iterator)
isinstance(iter([]),Iterator)
isinstance(iter({}),Iterator)
isinstance(iter('abc'),Iterator)
isinstance(iter((1,2,3)),Iterator)
isinstance(iter((x for x in range(10))),Iterator)
'''
@
可以直接作用于for循环的数据类型有以下几种：
一类是集合数据类型，如list、tuple、dict、set、str等；
一类是generator，包括生成器和带yield的generator function。
这些可以直接作用于for循环的对象统称为可迭代对象：Iterable。
可以使用isinstance()判断一个对象是否是Iterable对象
@
而生成器不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到最后抛出StopIteration错误表示无法继续返回下一个值了。
可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。
可以使用isinstance()判断一个对象是否是Iterator对象
@
生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。
把list、dict、str等Iterable变成Iterator可以使用iter()函数
@
你可能会问，为什么list、dict、str等数据类型不是Iterator？
这是因为Python的Iterator对象表示的是一个数据流，Iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据，所以Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。
Iterator甚至可以表示一个无限大的数据流，例如全体自然数。而使用list是永远不可能存储全体自然数的。
'''
Python yield 使用浅析 https://www.ibm.com/developerworks/cn/opensource/os-cn-python-yield/index.html
另一个例子
另一个 yield 的例子来源于文件读取。如果直接对文件对象调用 read() 方法，会导致不可预测的内存占用。好的方法是利用固定长度的缓冲区来不断读取文件内容。通过 yield，我们不再需要编写读文件的迭代类，就可以轻松实现文件读取：
清单 9. 另一个 yield 的例子
|
1
2
3
4
5
6
7
8
9
|
def read_file(fpath): BLOCK_SIZE = 1024 with open(fpath, 'rb') as f: while True: block = f.read(BLOCK_SIZE) if block: yield block else: return |
以上仅仅简单介绍了 yield 的基本概念和用法，yield 在 Python 3 中还有更强大的用法，我们会在后续文章中讨论。
def _int_iter():
'''
生成器，生成从3开始的无限奇数序列
:return:
'''
n = 1
while True:
n = n + 2
yield n
def _not_divisible(n):
'''
定义筛选函数
:param n:
:return:
'''
return lambda x: x % n > 0
def primes():
# 先返回一个2
yield 2
# 初始序列
it = _int_iter()
while True:
n = next(it)
yield n
it = filter(_not_divisible(n), it)
g = primes()
for n in g:
if n < 100:
print(n)
else:
break
https://baike.baidu.com/item/埃拉托色尼筛选法
filter - 廖雪峰的官方网站 https://www.liaoxuefeng.com/wiki/1016959663602400/1017404530360000
