一 迭代器
1.1 认识迭代器
什么是迭代 什么是迭代器
迭代器
如何从列表、字典中取值的
index索引 ，key
for循环
凡是可以使用for循环取值的都是可迭代的
可迭代协议 ：内部含有__iter__方法的都是可迭代的
迭代器协议 ：内部含有__iter__方法和__next__方法的都是迭代器
一个生成器 只能取一次生成器在不找它要值的时候始终不执行当他执行的时候，要以执行时候的所有变量值为准
l = [1,2,3]
while True:
lst = l.__iter__() ## iter 方法自带一个next方法，所以第一次可以取值输出，并取到下一个值保存
print(next(lst))
l = [1,2,3]
lst = l.__iter__() ##当输出最后一个值的时候，仍旧执行next方法会报错
while True:
print(next(lst))
l = [1,2,3]
lst = l.__iter__()
while True:
try:
print(next(lst)) # 测试错误
except StopIteration: # 当遇到报错 StopIteration 的时候，执行break，停止执行next方法。
break
什么是迭代器 迭代器 = iter(可迭代的)，自带一个__next__方法
可迭代 最大优势是 节省内存
我们可以从range学习
from collections import Iterable,Iterator #可迭代的 迭代器 print(range(100000000)) print(isinstance(range(100000000),Iterable)) # True 是可迭代的 print(isinstance(range(100000000),Iterator)) # False 不是迭代器
py2 range 不管range多少 会生成一个列表 这个列表将用来存储所有的值py3 range 不管range多少 都不会实际的生成任何一个值
迭代器的优势: 节省内存 取一个值就能进行接下来的计算 ，而不需要等到所有的值都计算出来才开始接下来的运算 —— 快迭代器的特性:惰性运算
二 生成器
生成器，Genenator
2.1 什么是生成器
自己写的迭代器，就是一个生成器
写迭代器的两种机制：
生成器函数和生成器表达式
# 凡是带有yield的函数就是一个生成器函数
def func():
print(‘****‘)
yield 1
print(‘^^^^‘)
yield 2 # 记录当前所在的位置，等待下一次next来触发函数的状态
生成器函数的调用不会触发代码的执行，而是会返回一个生成器(迭代器)想要生成器函数执行，需要用next
g = func() # g = 函数执行之后生成的一个生成器
print(‘---‘,g) # 函数执行不输出任何内容
print(‘--‘,next(g)) # 调用一次next，会执行一次取值，到下一次遇到yield停止 print(‘--‘,next(g))
调用两次next返回的结果：
**** -- 1 ^^^^ -- 2
2.1.2使用生成器监听文件输入
import time
def listen_file():
with open(‘userinfo‘) as f:
while True:
line = f.readline() #使用readline监听文件，它不会自动结束
if line.strip():
yield line.strip()
time.sleep(0.1)
g = listen_file()
for line in g:
print(line)
# 使用mac的时候，需要用echo向文件追加内容测试。win手动输入 使用ctrl+s保存即可
2.1.3 send关键字
理解send
def func():
print(11111)
ret1 = yield 1
print(22222,‘ret1 :‘,ret1)
ret2 = yield 2
print(33333,‘ret2 :‘,ret2)
yield 3
g = func()
ret = next(g) # 第一次next，返回11111 和 yield 1 。并记录当前位置，等待下一个next来触发函数状态
print(ret)
print(g.send(‘alex‘)) # 在执行next的过程中 传递一个参数 给生成器函数的内部，同时接收yield的返回值。
print(g.send(‘金老板‘))
##接收send发送的参数的是上次次结束的yield。第一次执行next(g),后，返回yield 1。yield会记录当前所在位置，等待下一个next来触发函数的状态。当执行send(alex)的时候的时候，相当于又执行一个next，且yield 1首先执行，接收send的内容。
# send 不能在第一次next之前。第一次必须用next触发这个生成器，有一个激活的过程
send 不能用在生成器的第一步。必须先用next触发激活生成器
例子： 计算移动平均值
要求，每次给你一个数，都计算之前所有拿到的数的平均值。例如计算月度的天平均收入
def average():
sum_money = 0
day = 0
avg = 0
while True:
money = yield avg
sum_money += money
day += 1
avg = sum_money/day
g = average()
print(g.__next__()) #第一步 先触发生成器，之后才能send
print(g.send(20))
print(g.send(40))
print(g.send(60))
2.2 预激生成器
个人理解：生成器send的时候需要用next激活，才能使用send传值。这里用到的是装饰器来进行生成器函数的预激活
def init(func):
def inner(*args,**kwargs):
ret = func(*args,**kwargs)
next(ret) # 预激活
return ret # 需要返回生成器的结果给send
return inner
@init
def average():
sum_money = 0
day = 0
avg = 0
while True:
money = yield avg
sum_money += money
day += 1
avg = sum_money/day
#
g = average()
print(g.send(200))
print(g.send(300))
print(g.send(600))
2.3 生成器的使用
2.3.1 yield from
# yield from
def generator_func():
for i in range(5):
yield i
for j in ‘hello‘:
yield j
def generator_func():
yield from range(5)
yield from ‘hello‘
以上两种写法完全是完全相同的
2.3.2 迭代器只能生成一次
我们看下这两段代码
# 定义函数
# # yield from
def generator_func():
for i in range(5):
yield i
# 代码调用第一种方式
g = generator_func()
while True:
print(next(g))
#输出内容：
0
1
2
3
4
File "/Users/wph/PycharmProjects/learn/Day4/8.复习练习.py", line 194, in <module>
print(next(g))
StopIteration
# 代码调用第二种方式
while True:
print(next(generator_func()))
# 执行结果是一直输出 0
我们想一下，为什么会出现这样的情况呢？
来继续看下面的代码：
def generator_func():
for i in range(5):
yield i
g1 = generator_func()
g2 = generator_func()
print(g1,g2)
#输出结果 <generator object generator_func at 0x104c2b0a0> <generator object generator_func at 0x104c2b0f8> 可以看到 g1和g2的内存地址是不一样的。也就是说每次调用generator_func，都会生成一个全新的生成器。那么每次从里面取值，都是会从头开始的。
2.3.3 生成器函数定义
生成器函数 是我们python程序员实现迭代器的一种手段
主要特种是 在函数中 含有 yield
调用一个生成器函数 不会执行这个函数中的代码，知识会获得一个生成器（迭代器）
只有从生成器中取值的时候，才会执行函数内部的代码。且每获取一个数据才执行得到这个数据的代码
获取数据的方式包括 next send 循环 数据类型的强制转换
yield返回值的简便方法，如果本身就是一个可迭代的，且要把可迭代数据中的每一个元素都返回，可以用 yield from
使用send的时候，在生成器创造出来自后要进行预激，这一步可以使用装饰器完成。
生成器的特点：节省内存 惰性计算
生成器用来解决内存问题和程序功能之间的解耦
2.3.4 生成器表达式
先了解一下列表推导式：
# 列表推导式
new_lst = []
for i in range(10):
new_lst.append(i**2)
print(new_lst)
print([i**2 for i in range(10)])
# 求列表中的数对2取余
l = [1,2,3,-5,6,20,-7]
print([i%2 for i in range(10)])
# 取出列表中的奇数
l = [1,2,3,-5,6,20,-7]
print([num for num in l if num%2 == 1])
30以内所有能被3整除的数
print([i for i in range(30) if i%3 ==0])
30以内所有能被3整除的数的平方
print([i**2 for i in range(30) if i%3 ==0])
找到嵌套列表中名字含有两个‘e’的所有名字
names = [[‘Tom‘, ‘Billy‘, ‘Jefferson‘, ‘Andrew‘, ‘Wesley‘, ‘Steven‘, ‘Joe‘],
[‘Alice‘, ‘Jill‘, ‘Ana‘, ‘Wendy‘, ‘Jennifer‘, ‘Sherry‘, ‘Eva‘]]
print([name for name_lst in names for name in name_lst if name.count(‘e‘) == 2])
生成器表达式
l = [1,2,3,-5,6,20,-7] 30以内所有能被3整除的数 l = [i for i in range(30) if i%3 ==0] # 列表推导式 排序的时候 g = (i for i in range(30) if i%3 ==0) # 生成器表达式 庞大数据量的时候 使用生成器表达式 #与列表推导式相比，只是把[]换成了() print(l) #结果是一个列表 print(g) ## 结果只是拿到一个生成器 <generator object <genexpr> at 0x1043100a0> for i in g:print(i) # 从这个生成器中取值
总结：
1. 把列表解析(列表推导式)的[]换成()得到的就是生成器表达式
2. 列表解析与生成器表达式都是一种便利的编程方式，只不过生成器表达式更节省内存。
3. Python不但使用迭代器协议，让for循环更加通用。大部分内置函数，也是使用迭代器协议访问对象的。例如，sum函数是Python的内置函数，该函数使用迭代器协议访问对象，而生成器实现了迭代器协议，所有，我们可以直接这样计算一系列值的和
print(sum(x ** 2 for x in range(4)))
2.3.5 生成器面试题
# 面试题 请确认这段代码的打印内容
def demo():
for i in range(4):
yield i
g=demo()
g1=(i for i in g) ### 生成器表达式 不执行！
g2=(i for i in g1)
print(list(g1)) #执行生成器表达式 #结果 [0,1,2,3]
print(list(g2)) #结果 []
解析：因为g=demo()的使用调用生成器函数，g是一个生成器。g1 是一个生成器推导式，并不会执行。
当print从g1 中取值完成后，由于一个生成器只能取值一次。，g2取不到值了。
面试题2： 很蛋疼的，慢慢看吧 ，不信你能懂。。（重点在于 生成器是什么时候执行的）
# 判断下列代码输出内容
def add(n,i):
return n+i
def test():
for i in range(4):
yield i
g=test()
for n in [1,3,10]:
g=(add(n,i) for i in g)
print(list(g))
输出内容
10 11 12 13
2.3.5 生成器准则
一个生成器 只能取值一次。
生成器在不找他要值的时候，始终不执行
当他执行的时候，要以执行时的所有变量值为准
原文地址：https://www.cnblogs.com/wangph/p/8946609.html
时间： 2024-12-08 22:35:06