python基础-迭代器和生成器

一、递归和迭代

1、递归：（问路示例）

递归算法是一种直接或者间接地调用自身算法的过程。在计算机编写程序中，递归算法对解决一大类问题是十分有效的，它往往使算法的描述简洁而且易于理解。
2、迭代：简单理解为更新换代（ 儿子生孙子的故事）

二、迭代器协议

1.迭代器协议是指：对象必须提供一个next方法，执行该方法要么返回迭代中的下一项，要么就引起一个StopIteration异常，以终止迭代 （只能往后走不能往前退）

2.可迭代对象：实现了迭代器协议的对象（如何实现：对象内部定义一个__iter__()方法）

3.协议是一种约定，可迭代对象实现了迭代器协议，python的内部工具（如for循环，sum，min，max函数等)使用迭代器协议访问对象。

4、for循环的本质就是遵循迭代器协议去访问对象，那么for循环的对象肯定都是迭代器。

5、不可迭代对象：字符串，列表，元组，字典，集合，文件对象。只不过通过for循环，调用了他们内部的__iter__方法,把他们变成了可迭代对象。

特点：

1.生成器是可迭代对象

2.实现了延迟计算，看内存(按需，执行)

3.生成器本质和其他类型一样，都是实现了迭代器协议，只不过生成器是一边计算，一边生成，从而节省内存空间，其余的可迭代对象可没有好处。

三、迭代器

ps1:

1、遵循迭代器协议访问方式

x='hello'
# print(dir(x))
iter_test=x.__iter__()

print(iter_test)
print(iter_test.__next__())  #获取第1个值
print(iter_test.__next__())  #获取第2个值
print(iter_test.__next__())  #获取第3个值
print(iter_test.__next__())  #获取第4个值
print(iter_test.__next__())  #获取第5个值
print(iter_test.__next__())  #超出边界,当for循环结束时,捕捉到StopIteration异常,他就会终止迭代

执行结果：

Traceback (most recent call last):
h
File "D:/python/day9/iter和yield.py", line 14, in <module>
e
print(iter_test.__next__())  #超出边界,当for循环结束时,捕捉到StopIteration异常,终止迭代
l
StopIteration
l
o

ps2:

2、for循环访问方式

for循环l本质就是遵循迭代器协议的访问方式,先调用diedai_l=l.__iter__()方法,或者直接diedai_l=iter(l),然后依次执行diedai_l.next(),直到for循环捕捉到StopIteration终止循环。

for循环所有对象的本质都是一样的原理。

用for循环的方式

l=[1,2,3]
for i in l:  #把列表变成i_l=l.__iter_() ，再执行他下面的i_l.__next__()
print(i)

执行结果：

1
2
3

ps3:

3、用索引的方式，遍历列表的值

l=[1,2,3]

index=0
while index < len(l):
print(l[index])
index += 1

执行结果：

1
2
3

ps4:

用迭代器的方式

l=[1,2,3]
iter_l=l.__iter__()       #遵循迭代器协议，生成可迭代对象
print(iter_l.__next__())  #取列表的值
print(iter_l.__next__())  #取列表的值
print(iter_l.__next__())  #取列表的值

执行结果：

1
2
3

ps5:

下标访问方式

l = ['a', 'b', 'c']
print(l[0])
print(l[1])
print(l[2])
#print(l[3])  #起出边界报错：IndexError

执行结果：

a
b
c

ps6:

集合的方式

方法一：

#集合的方式
s={1,2,3}
for i in s:
print(i)

方法二：

s={1,2,3}
iter_s=s.__iter__()    #通过iter方法
print(iter_s)
print(iter_s.__next__())   #调用next
print(iter_s.__next__())
print(iter_s.__next__())
print(iter_s.__next__())  #超出边界,当for循环结束时,捕捉到StopIteration异常,终止迭代

执行结果：

<set_iterator object at 0x00BF4198>
Traceback (most recent call last):
1
File "D:/python/day9/iter and yield.py", line 46, in <module>
2
print(iter_s.__next__())  #超出边界,当for循环结束时,捕捉到StopIteration异常,终止迭代
3
StopIteration

ps7:

字典的方式

#字典的方式
dic={'a':1,'b':2}
iter_d=dic.__iter__()
print(iter_d.__next__())
print(iter_d.__next__())
print(iter_d.__next__())

ps8:

文件的方式

1、创建一个test.txt文件，内容如下：

111111
222222
333333

2、执行下面代码

#文件的方式
f=open('test.txt','r+')
#for i in f:
iter_f=f.__iter__()   #遵循可迭代原则，转换成迭代器，要的时候拿到内存，可以节约内存空间
print(iter_f)
print(iter_f.__next__(),end='')  #第一行
print(iter_f.__next__(),end='')  #第二行
print(iter_f.__next__(),end='')  #第三行
print(iter_f.__next__(),end='')  #执行完了的时候，就捕捉到StopIteration异常,终止迭代

执行结果：

<_io.TextIOWrapper name='test.txt' mode='r+' encoding='cp936'>
Traceback (most recent call last):
111111
File "D:/python/day9/iter and yield.py", line 64, in <module>
222222
print(iter_f.__next__(),end='')
333333StopIteration    #执行完了的时候，就捕捉到StopIteration异常,终止迭代

ps9:

用while去模拟for循环做的事情，实现迭代器的过程

l=[1,2,3,4,5]
diedai_l=l.__iter__()
while True:
try:
print(diedai_l.__next__())
except StopIteration:
# print('迭代完毕了,循环终止了')
break   #直接break，捕捉到导常，就不会报StopIteration异常

执行结果：

1
2
3
4
5

迭代器总结：

l=['die','erzi','sunzi','chongsunzi']   #把所有结果都放在内存中，比较占用内存

iter_l=l.__iter__()        #转成迭代器形式，可以在任意位置传输（也叫可迭代对象）
print(iter_l)
print(iter_l.__next__())    #第一次调用，得到的结果：die
print(iter_l.__next__())    #第二次调用, 得到的结果：erzi
print(iter_l.__next__())    #第三次调用, 得到的结果：sunzi
print(iter_l.__next__())    #第四次调用, 得到的结果：chongsunzi
print(iter_l.__next__())    #超出边界,捕捉到StopIteration异常,终止迭代

补充：

next内置函数

说明：next内置函数的next()方法，就是在调用l.__iter__()，下的 __next__()方法

1 l=['die','erzi','sunzi','chongsunzi']
2 iter_l = l.__iter__()
3 print(next(iter_l))        #next()---->iter_l.__next__()
4 print(next(iter_l))
5 print(next(iter_l))
6 print(next(iter_l))

执行结果：

1 die
2 erzi
3 sunzi
4 chongsunzi

生成器（详细讲解）

一、什么是生成器？

生成器就是迭代器，可以理解为一种数据类型，这种类型自动实现了迭代器协议.（其他的数据类型需要调用自己内置的__iter__方法），所以生成器就是可迭代对象。

二、生成器分类及在python中的表现形式？（Python有两种不同的方式提供生成器）

1.生成器函数：常规函数定义，但是，使用yield语句而不是return语句返回结果。yield语句一次返回一个结果，在每个结果中间，挂起函数的状态，以便下次重它离开的地方继续执行

2.生成器表达式：类似于列表推导，但是，生成器返回按需产生结果的一个对象，而不是一次构建一个结果列表

三、使用生成器的优点:

Python使用生成器对延迟操作提供了支持。所谓延迟操作，是指在需要的时候才产生结果，而不是立即产生结果。这也是生成器的主要好处。

四、生成器小结：

1.是可迭代对象

2.实现了延迟计算,省内存啊

3.生成器本质和其他的数据类型一样，都是实现了迭代器协议，只不过生成器附加了一个延迟计算省内存的好处，其余的可迭代对象可没有这点好处。

五、生成器（yield ）示例：

def test():
yield 1    #只要有yield就是生成器
yield 2    #他可以yield多次,yield可以保存函数状态
yield 3
g=test()
print('来自函数',g)
print(g.__next__())   #生成器自动实现了迭成器,所以会有__next__()方法。
print(g.__next__())   #运行一次，相当于保存的是上一次内存里状态的结果
print(g.__next__())

执行结果：

来自函数 <generator object（迭代器对象） test at 0x01B0BAE0>
1
2
3

六、补充知识：

三元表达式

#三元表达式演变过程

# name='alex'
# 'SB' if name == 'alex' else '帅哥'  #if判断name=alex就，返回SB;如果不等于alex，就返回帅哥。但SB要写在最前面。

七、三元表达式完整写法

if判断name=alex就，返回SB;如果不等于alex，就返回帅哥。但SB要写在最前面。

name='alex'
name='linhaifeng'
res='SB' if name == 'alex' else '帅哥'  #三元表达式
print(res)

执行结果：

帅哥

八、生成器表达式和列表解析

ps1:

生成一个列表

egg_list=[]
for i in range(10):
egg_list.append('鸡蛋%s' %i)
print(egg_list)

执行结果：

['鸡蛋0', '鸡蛋1', '鸡蛋2', '鸡蛋3', '鸡蛋4', '鸡蛋5', '鸡蛋6', '鸡蛋7', '鸡蛋8', '鸡蛋9']

ps2:

列表解析方法（生成列表）

l=['鸡蛋%s' %i for i in range(10)]
print(l)

执行结果：

['鸡蛋0', '鸡蛋1', '鸡蛋2', '鸡蛋3', '鸡蛋4', '鸡蛋5', '鸡蛋6', '鸡蛋7', '鸡蛋8', '鸡蛋9']

ps3:

三元表达式方法（生成列表）

#鸡蛋>5
l1=['鸡蛋%s' %i for i in range(10) if i > 5 ]
# l1=['鸡蛋%s' %i for i in range(10) if i > 5 else i] #没有四元表达式
print(l1)

#鸡蛋<5
l2=['鸡蛋%s' %i for i in range(10) if i < 5]
print(l2)

执行结果：

#鸡蛋>5结果：
['鸡蛋6', '鸡蛋7', '鸡蛋8', '鸡蛋9']

#鸡蛋<5结果：
['鸡蛋0', '鸡蛋1', '鸡蛋2', '鸡蛋3', '鸡蛋4']

ps4:

生成器表达式（基于迭代器__next__方法进行取值）

laomuji=('鸡蛋%s' %i for i in range(10)) #生成器表达式
print(laomuji)

print(laomuji.__next__())  #基于迭代器__next__方法进行取值
print(laomuji.__next__())
print(next(laomuji))
print(next(laomuji))
print(next(laomuji))
print(next(laomuji))
print(next(laomuji))
print(next(laomuji))
print(next(laomuji))
print(next(laomuji))
#print(next(laomuji))   #超出边界,当for循环结束时,捕捉到StopIteration异常,终止迭代

执行结果：

<generator object <genexpr> at 0x010EBAB0>
鸡蛋0
鸡蛋1
鸡蛋2
鸡蛋3
鸡蛋4
鸡蛋5
鸡蛋6
鸡蛋7
鸡蛋8
鸡蛋9

ps5:

其它

l=[1,2,3,34]
#map(func,l)   #可迭代对象
print(sum(l))  #求和,使用的是__iter__()方法转换成可迭代对象

#生成100000000
print(sum(list(range(100000000))))

#sum传给生成器生成一个列表
print(sum(i for i in range(10000000000000)))   #没有运行结果

执行结果：

40

4999999950000000

ps6:

生成器（生孩子事例）

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#Author: nulige

import time
def test():
print('开始生孩子啦.......')
print('开始生孩子啦.......')
print('开始生孩子啦.......')
yield '我'  #return
time.sleep(3)
print('开始生儿子啦.......')
yield '儿子'

time.sleep(3)
print('开始生孙子啦.......')
yield '孙子'

res=test()
print(res)
print(res.__next__())
print(res.__next__())
print(res.__next__())

执行结果：

<generator object test at 0x012EBB40>
开始生孩子啦.......
开始生孩子啦.......
开始生孩子啦.......
我
开始生儿子啦.......
儿子
开始生孙子啦.......
孙子

ps7:

send触发yield返回值原理

#yield 3相当于return 控制的是函数的返回值
#x=yield的另外一个特性，接受send传过来的值,赋值给x

def test():
print('开始啦')
firt = yield 1      # return 1,first=None
print('第一次', firt)
yield 2
print('第二次')

t = test()
res = t.__next__()  # next(t)
print(res)
# t.__next__()
res=t.send(None)
# res = t.send  # ('函数停留在first那个位置，我就是给first赋值的')
print(res)

执行结果：

开始啦
1

第一次 None
2

ps8:

吃包子事例

import time
def producer():
ret=[]
for i in range(100):
time.sleep(0.1)
ret.append('包子%s' %i)
return ret

def consumer(res):
for index,baozi in enumerate(res):
time.sleep(0.1)
print('第%s个人，吃了%s' %(index,baozi))

res=producer()
consumer(res)

执行结果：

我是[wupeiqi],我准备开始吃包子了
我是[yuanhao_SB],我准备开始吃包子了
wupeiqi 很开心的把【包子 0】吃掉了
yuanhao_SB 很开心的把【包子 0】吃掉了
wupeiqi 很开心的把【包子 1】吃掉了
yuanhao_SB 很开心的把【包子 1】吃掉了
wupeiqi 很开心的把【包子 2】吃掉了
yuanhao_SB 很开心的把【包子 2】吃掉了
wupeiqi 很开心的把【包子 3】吃掉了
yuanhao_SB 很开心的把【包子 3】吃掉了
wupeiqi 很开心的把【包子 4】吃掉了
yuanhao_SB 很开心的把【包子 4】吃掉了
wupeiqi 很开心的把【包子 5】吃掉了
yuanhao_SB 很开心的把【包子 5】吃掉了
wupeiqi 很开心的把【包子 6】吃掉了
yuanhao_SB 很开心的把【包子 6】吃掉了
wupeiqi 很开心的把【包子 7】吃掉了
yuanhao_SB 很开心的把【包子 7】吃掉了
wupeiqi 很开心的把【包子 8】吃掉了
yuanhao_SB 很开心的把【包子 8】吃掉了
wupeiqi 很开心的把【包子 9】吃掉了
yuanhao_SB 很开心的把【包子 9】吃掉了

#运行结果省略部分.....

View Code