概述
一、递归和迭代
递归：是数理逻辑和计算机科学用到的一种定义方式，使用被定义对象的自身来为其下定义（简单说就是自我复制的定义或者说自己调用自己的函数）
迭代：重复反馈过程的活动,其目的通常是为了接近并到达所需的目标或结果。每一次对过程的重复被称为一次“迭代”,而每一次迭代得到的结果会被用来作为下一次迭代的初始值（反反复复地执行某一步骤、程序或者事件）
二、什么是迭代器协议
1）迭代器协议：指对象必须提供一个next方法，执行该方法要么返回迭代中的下一个项，要么就引起StopIteration异常，以终止迭代（只能往后走不能往前退）
2）可迭代对象：实现了迭代器协议的对象（如何实现：对象内部定义一个__iter__()方法）
3）协议是一种约定，可迭代对象实现了迭代器协议，Python的内部工具（如 for循环，sum，min,max函数等）使用迭代器协议访问对象
三、Python中强大的for循环机制
for循环的本质：循环所有对象，全都是使用迭代器协议。
很多人会想，for循环的本质就是遵循迭代器协议去访问对象，那么for循环的对象肯定都是迭代器了啊，没错，那既然这样，for循环可以遍历（字符串，列表，元组，字典，集合，文件对象），那这些类型的数据肯定都是可迭代对象啊？但是，为什么定义一个列表l=[1,2,3,4]没有l.next()方法，这不是自相矛盾吗？
(字符串，列表，元组，字典，集合，文件对象）这些都不是可迭代对象，只不过在for循环式，调用了他们内部的__iter__方法，把他们变成了可迭代对象
然后for循环调用可迭代对象的__next__方法去取值，而且for循环会捕捉StopIteration异常，以终止迭代
l=['a','b','c']
#一:下标访问方式
print(l[0])
print(l[1])
print(l[2])
# print(l[3])#超出边界报错:IndexError
#二:遵循迭代器协议访问方式
diedai_l=l.__iter__() #遵循迭代器协议，生成可迭代对象
print(diedai_l.__next__())
print(diedai_l.__next__())
print(diedai_l.__next__())
# print(diedai_l.__next__())#超出边界报错:StopIteration
#三:for循环访问方式
#for循环l本质就是遵循迭代器协议的访问方式,先调用diedai_l=l.__iter__()方法,或者直接diedai_l=iter(l),然后依次执行diedai_l.next(),直到for循环捕捉到StopIteration终止循环
#for循环所有对象的本质都是一样的原理
for i in l:#diedai_l=l.__iter__()
print(i) #i=diedai_l.next()
#四:用while去模拟for循环做的事情
diedai_l=l.__iter__()
while True:
try:
print(diedai_l.__next__())
except StopIteration:
print('迭代完毕了,循环终止了')
break四、为何要有for循环
基于上面讲的列表的三种访问方式，有了下标的访问方式，我可以这样遍历一个列表啊
l=[1,2,3]
index=0
while index < len(l):
print(l[index])
index+=1
既然可以通过下标访问，为什么还要for循坏了？
没错，序列类型字符串，列表，元组都有下标，你用上述的方式访问，perfect！但是你可曾想过非序列类型像字典，集合，文件对象的感受，所以嘛，年轻人，for循环就是基于迭代器协议提供了一个统一的可以遍历所有对象的方法，即在遍历之前，先调用对象的__iter__方法将其转换成一个迭代器，然后使用迭代器协议去实现循环访问，这样所有的对象就都可以通过for循环来遍历了，而且你看到的效果也确实如此，这就是无所不能的for循环，觉悟吧，年轻人
五、 生成器初探
1、 生成器概念
可以理解为一种数据类型，这种数据类型自动实现了迭代器协议（其他的数据类型需要调用自己内置的__iter__方法），所以生成器就是可迭代对象
2、生成器分类及在python中的表现形式：（Python有两种不同的方式提供生成器）
1）生成器函数：常规函数定义，但是，使用yield语句而不是return语句返回结果。yield语句一次返回一个结果，在每个结果中间，挂起函数的状态，以便下次重它离开的地方继续执行
2）生成器表达式：类似于列表推导，但是，生成器返回按需产生结果的一个对象，而不是一次构建一个结果列表
为何使用生成器之生成器的优点
Python使用生成器对延迟操作提供了支持。所谓延迟操作，是指在需要的时候才产生结果，而不是立即产生结果。这也是生成器的主要好处。
六、生成器小结：
1.是可迭代对象
2.实现了延迟计算,省内存啊
3.生成器本质和可迭代对象的数据类型一样，都是实现了迭代器协议，只不过生成器附加了一个延迟计算省内存的好处，其余的可迭代对象可没有这点好处，记住喽！！！
列表循环：
l=['a','b','c','d','e']
i =0
while i<len(l):
print(l[i])
i+=1
for i in range(len(l)):
print(l[i])集合和字典不是序列，没有下标，不能通过索引取值，这就用到了迭代器的原因之一。
可迭代对象：只要对象本身有__iter__方法，那它就是可迭代的。 # 只有内置了iter方法就是可迭代的对象。
d={'a':1,'b':2,'c':3}
d.__iter__()执行对象下的__iter__方法，得到的结果就是迭代器
i=d.__iter__()
d={'a':1,'b':2,'c':3}
i=iter(d)
while True:
try:
print(next(i))
except StopIteration: # StopIteration 不能叫做错误，是一个结束信号。
break
l=['a','b','c','d','e','f'] #列表也可以使用迭代器
i=iter(l) #i=l.__iter__()
while True:
try:
print(next(i))
except StopIteration:
break
# for 循环
d={'a':1,'b':2,'c':3}
d.__iter__
for k in d: #d.__iter__()
print(k)
s={1,2,3,4}
for i in s:
print(i)补充：try 监控 except捕捉，捕捉错误信息得。
while 需要加异常处理，for默认都已经内置。
文件默认就是迭代器：
f=open('a.txt','r')
f.__next__
f.__iter__
print(f)
print(f.__iter__())
for line in f: #f.__iter__()
print(line)
i=f.__iter__()
while True:
try:
print(next(i))
except StopIteration:
break为什么要用迭代器：
优点：
- 迭代器提供了一种不依赖于索引的取值方式，这样就可以遍历那些没有索引的可迭代对象了（字典，集合，文件）
- 迭代器与列表比较，迭代器是惰性计算的，更节省内存
缺点：
- 无法获取迭代器的长度，使用不如列表索引取值灵活
- 一次性的，只能往后取值，不能倒着取值
l=[1,2,3]
print(len(l))
i=iter(l)
print(next(i))
print(next(i))
print(next(i))
for x in i:
print(x)查看是不是字符串类型：
>>> type('aaa') is str
True
>>> isinstance('aaa',str)
True
>>>
#判断是不是字符串类型查看可迭代对象与迭代器对象：
from collections import Iterable,Iterator
s='hello'
l=[1,2,3]
t=(1,2,3)
d={'a':1}
set1={1,2,3,4}
f=open('a.txt')
# 都是可迭代的
s.__iter__()
l.__iter__()
t.__iter__()
d.__iter__()
set1.__iter__()
f.__iter__()
print(isinstance(s,Iterable))
print(isinstance(l,Iterable))
print(isinstance(t,Iterable))
print(isinstance(d,Iterable))
print(isinstance(set1,Iterable))
print(isinstance(f,Iterable))
# 查看是否是迭代器
print(isinstance(s,Iterator))
print(isinstance(l,Iterator))
print(isinstance(t,Iterator))
print(isinstance(d,Iterator))
print(isinstance(set1,Iterator))
print(isinstance(f,Iterator))七 、生成器函数
e.send与next(e)的区别：
- 如果函数内yield是表达式形式，那么必须先next(e)
- 二者的共同之处是都可以让函数在上次暂停的位置继续运行，不一样的地方在于send在触发下一次代码的执行时，会顺便给yield传一个值
母鸡下蛋的传说代码：
def lay_eggs(num):
egg_list=[]
for egg in range(num):
egg_list.append('蛋%s' %egg)
return egg_list
yikuangdan=lay_eggs(10) #我们拿到的是蛋
print(yikuangdan)
def lay_eggs(num):
for egg in range(num):
res='蛋%s' %egg
yield res
print('下完一个蛋')
laomuji=lay_eggs(10)#我们拿到的是一只母鸡
print(laomuji)
print(laomuji.__next__())
print(laomuji.__next__())
print(laomuji.__next__())
egg_l=list(laomuji)
print(egg_l)生成器与return有何区别？
| 1 2 |
|
yield到底干了什么事情：
| 1 |
|
from collections import Iterator
#生成器就是一个函数，这个函数内包含有yield这个关键字
def test():
print('one')
yield 1 #return 1
print('two')
yield 2 #return 2
print('three')
yield 3 #return 2
print('four')
yield 4 #return 2
print('five')
yield 5 #return 2
g=test()
print(g)
print(isinstance(g,Iterator))
g.__iter__()
# g.__next__()
# res=next(g)
# print(res)
# res=next(g)
# print(res)
# res=next(g)
# print(res)
# res=next(g)
# print(res)
for i in g:
print(i)next触发函数的运行。函数变成迭代器，有执行效果，同时可以向外拉值。next一下函数执行一下。
def countdown(n):
print('start coutdown')
while n > 0:
yield n #1
n-=1
print('done')
g=countdown(5)
# print(g)
# print(next(g))
# print(next(g))
# print(next(g))
# print(next(g))
# print(next(g))
# print(next(g))
for i in g: #iter(g)
print(i)
while True:
try:
print(next(g))
except StopIteration:
break
def func():
n=0
while True:
yield n
n+=1
f=func()
print(next(f))应用1：
import time
def tail(file_path):
with open(file_path,'r') as f:
f.seek(0,2)
while True:
line=f.readline()
if not line:
time.sleep(0.3)
continue
else:
# print(line)
yield line
tail('/tmp/a.txt')加颜色：
g=tail('/tmp/a.txt')
for line in g:
if 'error' in line:
print(' 33[45m%s 33[0m' %line)应用2：
#/usr/bin/env python
import time
#定义阶段：定义俩生成器函数
def tail(file_path):
with open(file_path,'r') as f:
f.seek(0,2)
while True:
line=f.readline()
if not line:
time.sleep(0.3)
# print('====>')
continue
else:
#print(line,end='')
yield line
def grep(pattern,lines):
for line in lines:
if pattern in line:
yield line
#调用阶段：得到俩生成器对象
g1=tail('/tmp/a.txt')
g2=grep('error',g1)
#next触发执行g2生成器函数
for i in g2:
print(i)协程函数：
#如果在一个函数内部yield的使用方式是表达式形式的话，如x=yield，那么该函数成为协程函数
def eater(name):
print('%s start to eat food' %name)
food_list=[]
while True:
food=yield food_list
print('%s get %s ,to start eat' %(name,food))
food_list.append(food)
print('done')
e=eater('钢蛋')
print(e)
print(next(e))
print(e.send('包子'))
print(e.send('韭菜馅包子'))
print(e.send('大蒜包子'))
七、 生成器表达式和列表解析
#三元表达式
name = "apple"
x = "ruanxingzi" if name =="apple" else "gushihan"
print(x)egg_list=['鸡蛋%s' %i for i in range(10)] #列表解析
laomuji=('鸡蛋%s' %i for i in range(10))#生成器表达式
print(laomuji)
print(next(laomuji)) #next本质就是调用__next__
print(laomuji.__next__())
print(next(laomuji))总结：
1.把列表解析的[]换成()得到的就是生成器表达式
2.列表解析与生成器表达式都是一种便利的编程方式，只不过生成器表达式更节省内存
3.Python不但使用迭代器协议让for循环变得更加通用。大部分内置函数，也是使用迭代器协议访问对象的。例如， sum函数是Python的内置函数，该函数使用迭代器协议访问对象，而生成器实现了迭代器协议，所以，我们可以直接这样计算一系列值的和：
sum(x ** 2 for x in xrange(4))而不用多此一举的先构造一个列表：
sum([x ** 2 for x in xrange(4)]) 八 、生成器总结
综上已经对生成器有了一定的认识，下面我们以生成器函数为例进行总结
- 语法上和函数类似：生成器函数和常规函数几乎是一样的。它们都是使用def语句进行定义，差别在于，生成器使用yield语句返回一个值，而常规函数使用return语句返回一个值
- 自动实现迭代器协议：对于生成器，Python会自动实现迭代器协议，以便应用到迭代背景中（如for循环，sum函数）。由于生成器自动实现了迭代器协议，所以，我们可以调用它的next方法，并且，在没有值可以返回的时候，生成器自动产生StopIteration异常
- 状态挂起：生成器使用yield语句返回一个值。yield语句挂起该生成器函数的状态，保留足够的信息，以便之后从它离开的地方继续执行
优点一：生成器的好处是延迟计算，一次返回一个结果。也就是说，它不会一次生成所有的结果，这对于大数据量处理，将会非常有用。
1 #列表解析
2 sum([i for i in range(100000000)])#内存占用大,机器容易卡死
3
4 #生成器表达式
5 sum(i for i in range(100000000))#几乎不占内存优点二：生成器还能有效提高代码可读性
不使用迭代器
#求一段文字中，每个单词出现的位置
def index_words(text):
result = []
if text:
result.append(0)
for index, letter in enumerate(text, 1):
if letter == ' ':
result.append(index)
return result
print(index_words('hello alex da sb'))
使用迭代器
#求一段文字中每个单词出现的位置
def index_words(text):
if text:
yield 0
for index, letter in enumerate(text, 1):
if letter == ' ':
yield index
g=index_words('hello alex da sb')
print(g)
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())#报错
这里，至少有两个充分的理由说明 ，使用生成器比不使用生成器代码更加清晰：
- 使用生成器以后，代码行数更少。大家要记住，如果想把代码写的Pythonic，在保证代码可读性的前提下，代码行数越少越好
- 不使用生成器的时候，对于每次结果，我们首先看到的是result.append(index)，其次，才是index。也就是说，我们每次看到的是一个列表的append操作，只是append的是我们想要的结果。使用生成器的时候，直接yield index，少了列表append操作的干扰，我们一眼就能够看出，代码是要返回index。
这个例子充分说明了，合理使用生成器，能够有效提高代码可读性。只要大家完全接受了生成器的概念，理解了yield语句和return语句一样，也是返回一个值。那么，就能够理解为什么使用生成器比不使用生成器要好，能够理解使用生成器真的可以让代码变得清晰易懂。
注意事项：生成器只能遍历一次（母鸡一生只能下一定数量的蛋，下完了就死掉了）
人口信息.txt文件内容
{'name':'北京','population':10}
{'name':'南京','population':100000}
{'name':'山东','population':10000}
{'name':'山西','population':19999}
def get_provice_population(filename):
with open(filename) as f:
for line in f:
p=eval(line)
yield p['population']
gen=get_provice_population('人口信息.txt')
all_population=sum(gen)
for p in gen:
print(p/all_population)
执行上面这段代码，将不会有任何输出，这是因为，生成器只能遍历一次。在我们执行sum语句的时候，就遍历了我们的生成器，当我们再次遍历我们的生成器的时候，将不会有任何记录。所以，上面的代码不会有任何输出。
因此，生成器的唯一注意事项就是：生成器只能遍历一次。
最后
以上就是冷艳歌曲为你收集整理的Python 迭代器和生成器的全部内容，希望文章能够帮你解决Python 迭代器和生成器所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
发表评论 取消回复