python基础—迭代器、生成器

时间:2023-03-08 15:33:56
python基础—迭代器、生成器

python基础—迭代器、生成器

1 迭代器定义

迭代的意思是重复做一些事很多次,就像在循环中做的那样。

只要该对象可以实现__iter__方法,就可以进行迭代。

迭代对象调用__iter__方法会返回一个迭代器,所谓的迭代器就是具有next方法的对象。(在调用next方法时不需要任何参数)。在调用next方法时,迭代器会返回它的下一个值。如果next方法被调用,但迭代器没有值可以返回,就会引发一个StopITeration异常。

一个实现了__iter__方法的对象是可迭代的,一个实现了next方法的对象是迭代器。

   迭代器也有__iter__方法。

2 迭代器特性

优点:

1 迭代器提供了一种不依赖索引的取值方式,这样就可以遍历那些没有索引的可迭代对象了(字典,集合,文件)

2 迭代器与列表比较,迭代器是惰性计算的,更节省内存

缺点:

1 无法获取迭代器的长度,使用不如列表索引取值灵活

2 一次性的,只能往后取值,不能倒着取值

迭代规则的关键是?为什么不是使用列表?

1 如果有一个函数,可以一个接一个地计算值,那么在使用时可能是计算一个值时获取一个值,而不是像列表一样获取所有的值。如果有很多值,列表会占用太多的内存。

2 使用迭代器更通用,更简单,更优雅

3 迭代器代码

(1)索引方式循环

l=['a','b','c','d']
i=0
while i<len(l):
print(l[i])
i+=1
for i in range(len(l)):
print(l[i])

(2)只要被内置了__iter__方法就是可迭代对象

可迭代的:只要对象本身有__iter__方法,那他就是可迭代的

l=['a','b','c','d']
l.__iter__() #相当于iter(l)
iter(l)
i=iter(l)

i  就是迭代器,i 就是列表l的迭代器

(3)迭代器的__next__方法

迭代器使用__next__方法,可以不依赖下标取值,超出字典长度会有结束报错。

调用__next__方法必须是迭代器,也只有迭代器才有__next__方法。

l=['a','b','c','d']
i=iter(l)
print(i.__next__())
print(i.__next__())
print(i.__next__())
print(i.__next__())
print(i.__next__())

输出结果:

a
b
c
d
StopIteration #报错

(4)while循环与迭代器

d={'a':1,'b':2,'c':3,'d':4}
i=iter(d)
while True:
try:
print(next(i))
except StopIteration:
break

输出结果:

b
c
a
d

python基础—迭代器、生成器

(5)for循环与迭代器

在这里for就是使用可迭代对象的__iter__方法返回此可迭代对象的迭代器,并且执行此迭代器的next方法,并且出现StopITeration报错就结束

For循环与列表

d={'a':1,'b':2,'c':3,'d':4}
for i in d:
print(i)

For循环与文件

with open('a.txt','r') as f:
for line in f:
print(line.strip())

  

(6)迭代器也有__iter__方法

f 的迭代器也有__iter__方法,并且指向f这个迭代器本身

python基础—迭代器、生成器

(7)迭代器是一次性的

只能往后取值,不能倒着取值

可迭代对象不是一次性的。

d={'a':1,'b':2,'c':3,'d':4}
i=iter(d)
print(next(i))
print(next(i))
print(next(i))
print(next(i))
for x in i: #迭代器i已经将上面的值取完,for循环在这里没有值可取
print(x)

输出结果:

d
a
b
c

(8)isinstance判断对象是否是可迭代对象和迭代器对象

Isinstance使用例子:

print(type('ssssss') is str)
print(isinstance("ssssss",str))

输出结果:

True
True

用isinstance判断是不是可迭代对象与迭代器对象

#查看可迭代对象和迭代器对象

from collections import Iterable,Iterator
str1='hello'
list1=[1,2,3]
tuple1=(1,2,3)
dict1={"a":1,"b":2,"c":3}
set1={1,2,3,4}
f1=open('a.txt')
#都是可迭代的
str1.__iter__()
list1.__iter__()
tuple1.__iter__()
dict1.__iter__()
set1.__iter__()
f1.__iter__()
print(isinstance(str1,Iterable)) #True
print(isinstance(list1,Iterable)) #True
print(isinstance(tuple1,Iterable)) #True
print(isinstance(dict1,Iterable)) #True
print(isinstance(set1,Iterable)) #True
print(isinstance(f1,Iterable)) #True
#查看是否是迭代器
print(isinstance(str1,Iterator)) #False
print(isinstance(list1,Iterator)) #Flase
print(isinstance(tuple1,Iterator)) #Flase
print(isinstance(dict1,Iterator)) #Flase
print(isinstance(set1,Iterator)) #Flase
print(isinstance(f1,Iterator)) #Flase

  

4、生成器  

4.1 生成器函数定义 

生成器就是一个函数,这个函数内包含有yield这个关键字

返回一个生成器对象。生成器本质就是迭代器

生成器是一个包含yield关键字的函数。当它被调用时,在函数体中的代码不会被执行,而会返回一个迭代器。每次请求一个值,就会请求生成器中的代码,直到遇到一个yield或者return语句。Yield语句意味着生成一个值。Return语句意味着生成器要停止执行。

生成器是由两部分组成的:生成器的函数和生成器的迭代器。生成器的函数是有def语句定义的,包含yield部分。生成器的迭代器是这个函数返回的部分。生成器函数返回的迭代器可以像其他迭代器那样使用。

  

4.2  yield作用   

生成器与return有何区别?

Return只能返回一次函数就彻底结束了,而yield返回多次值

yield到底干了什么事情?

1 yield把函数变成生成器-,生成器实质就是迭代器。 相当于把__iter__和__next__方法封装到函数内部。

2 用return返回值能返回一次,而yield返回多次

3 函数在暂停以及继续下一次运行时的状态是由yield保存

任何包含yield语句的函数称为生成器。Yield不是像return那样返回值,而是每次产生多个值。生成器每次产生一个值(使用yield语句),函数就会被冻结:即函数停在那点等待被重新唤醒。函数被重新唤醒之后就从停止的那点开始。

4.3 生成器运行详解

Test函数中yield返回给g一个生成器,实质就是迭代器,通过next方法取值,并且在取值时会执行test函数和取yield的返回值。即next函数会触发生成器函数g的运行,遇到yield停止

from collections import Iterable,Iterator
def test():
print("first")
yield 1
g=test()
print(g)
print(next(g))
print(isinstance(g,Iterable))
print(isinstance(g,Iterator))

输出结果:

<generator object test at 0x000000E8CBDE5360>
first
1
True
True

 

def test():
print("one")
yield 1
print("two")
yield 2
print("three")
yield 3
g=test()
res=next(g)
print(res)
res=next(g)
print(res)
res=next(g)
print(res)
res=next(g)
print(res)

输出结果:

one
1
two
2
three
3
StopIteration #报错

  

def test():
print("one")
yield 1
print("two")
yield 2
print("three")
yield 3
g=test()
for i in g:
print(i)

输出结果:

one
1
two
2
three
3

 一个yield可以返回多个值,接收的类型是元组

yield可以返会任何类型的值

def test():
yield 1,2,3,4
g=test()
print(next(g))

输出结果:

(1,2,3,4)

生成器与return有何区别?

Return只能返回一次函数就彻底结束了,而yield返回多次值

yield到底干了什么事情?

1 yield把函数变成生成器--->迭代器

2 用return返回值能返回一次,而yield返回多次

3 函数在暂停以及继续下一次运行时的状态是由yield保存

例子:

def countdown(n):
print("start countnum")
while n>0:
yield n
n-=1
print('done')
g=countdown(5)
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
try:
print(next(g)) #这一次next函数应用没有yield返回,会报错StopIteration,需要try检测
except StopIteration:
pass
g=countdown(5)
print(next(g))
for i in g: #for会将g变成迭代器:iter(g),执行next取值,并捕捉next出现的异常
print(i)

输出结果: 

start countnum
5
4
3
2
1
done
start countnum
5
4
3
2
1
done

  

4.4 用生成器模拟管道 

tailf命令的实现

1 普通函数实现

#/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)
continue
else:
print(line,end="") tail("/tmp/a.txt")

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)
continue
else:
yield line
g=tail("/tmp/a.txt")
print(g)
for line in g:
print(line)

  

tail -f |grep “error” 实现

#/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)
continue
else:
yield line
def grep(pattern,lines):
for line in lines:
if pattern in line:
yield line
#调用阶段:得到两生成器对象
g=tail("/tmp/a.txt")
gg=grep("error",g)
#next触发执行gg生成器函数
for line in gg:
print(line)

  

1 迭代器的应用

文件名:a.txt  文件内容如下:

apple 10 3

tesla 100000 1

mac 3000 2

lenovo 30000 3

chicken 10 3

实现功能:cat a.txt|grep apple

要求1:定义迭代器函数cat

要求2:定义迭代器函数grep

要求3:模拟管道的功能,将cat的处理结果作为grep的输入

 

def cat(file_auth):
with open(file_auth,"r") as f:
f.seek(0)
for line in f:
yield line
def grep(pattern,lines):
for line in lines:
if pattern in line:
yield line
cat_func=cat("/tmp/a.txt")
grep_func=grep("apple",cat_func)
for line in grep_func:
print(line)

  

  

5、协程函数  

5.1 协程函数定义 

如果在一个函数内部yield的使用方式是表达式形式的话,如x=yield,那么该函数成为协程函数。

yield是表达式方式使用,则必须用send方法进行传值。

协程函数=生成器+yield表达式+send方法

5.2 e.send与next(e)的区别

e.send与next(e)的区别

1 如果函数内yield是表达式形式,那么必须先next(e)

使用send方法只有在生成器挂起之后才有意义(也就是在yield函数第一次被执行之后),因此要用send方式时需要用next方法初始化生成器。

用next(e)初始化  相当于 e.send(None) ,可以用装饰器解决初始化问题

2 二者的共同之处是都可以让函数在上次暂停的位置继续运行,不一样的地方在于send在触发下一次代码的执行时,会顺便给yield传一个值。

end可以传多个值,但是必须是元组类型

python基础—迭代器、生成器

5.3协程函数举例

def eater(name):
print("%s start to eat food"%name)
while True:
food=yield
print("%s get %s,to start eat"%(name,food))
print("done")
e=eater("people")
print(e)
next(e)
e.send("apple")
e.send("fruit")
e.send("beef")
e.send("meet")

输出结果:

<generator object eater at 0x000000F944583D00>
people start to eat food
people get apple,to start eat
people get fruit,to start eat
people get beef,to start eat
people get meet,to start eat

  

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("people")
print(e)
next(e) print(e.send("apple"))
print(e.send("fruit"))
print(e.send("beef"))
print(e.send("meet"))

输出结果:

<generator object eater at 0x0000006F92D83D00>
people start to eat food
people get apple,to start eat
['apple']
people get fruit,to start eat
['apple', 'fruit']
people get beef,to start eat
['apple', 'fruit', 'beef']
people get meet,to start eat
['apple', 'fruit', 'beef', 'meet']

  

2 生成器的应用

把下述函数改成生成器的形式,执行生成器函数的到一个生成器g,

然后g.send(url),打印页面的内容,利用g可以无限send

from  urllib.request import urlopen
def get(url):
while True:
def index():
print(url)
print(urlopen(url).read())
url=yield index g=get("http://www.baidu.com")
next(g)
baidu=g.send("http://www.baidu.com")
baidu()

  

 python基础—迭代器、生成器

 5.4 协程函数用装饰器初始化

协程函数使用装饰器完成初始化

def auth(func):
def wrapper(*args,**kwargs):
res=func(*args,**kwargs)
next(res)
return res
return wrapper
@auth
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("people")
e.send("123")

python基础—迭代器、生成器