第五篇、Python之迭代器与生成器

1、迭代和递归等概念

循环（loop）：指的是在满足条件的情况下，重复执行同一段代码。比如，while语句，for循环。

迭代（iterate）：指的是按照某种顺序逐个访问列表中的每一项。比如，for语句。Python中，迭代永远是取出元素本身，而非元素的索引。对于有序集合，元素确实是有索引的。使用 enumerate() 函数获得索引。

递归（recursion）：指的是一个函数不断调用自身的行为。比如，以编程方式输出著名的斐波纳契数列。

遍历（traversal）：指的是按照一定的规则访问树形结构中的每个节点，而且每个节点都只访问一次。

2、迭代器协议

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

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

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

注：可以通过__next__取值，就是迭代器（遵循迭代器协议生成的都是可迭代对象，迭代器就是可迭代对象）

l=["ye","ba","er","sun"]
inter_l=l.__iter__()
print(inter_l.__next__())
print(next(inter_l))

3、python中强大的for循环机制

for循环的本质：循环所有对象，全都是使用迭代器协议。

for循环的原理：基于迭代器协议提供了一个统一的可以遍历所有对象的方法，即在遍历之前，先调用对象的__iter__方法将其转换成一个迭代器，然后使用迭代器协议去实现循环访问，这样所有的对象就都可以通过for循环来遍历了。

列表，字符串，元组，字典，集合，文件对象等本质上来说都不是可迭代对象，在使用for循环的时候内部是先调用他们内部的_iter_方法，使他们变成了可迭代对象，然后在使用可迭代对象的_next_方法依次循环元素，当元素循环完时，会触发StopIteration异常，for循环会捕捉到这种异常，终止迭代。

访问方式常见的有下标方式访问、迭代器协议访问、for循环访问

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

访问方式

4. for循环的作用

对于序列类型的对象可使用下标的访问方式，但是对于非序列类型（字典，集合，文件对象等），for循环提供了访问遍历机制。

l=[1,2,3]

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

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

5.生成器初识

生成器的本质：

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

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

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

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

生成器的优点：

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

生成器小结：

1）是可迭代对象

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

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

可迭代对象：只要对象本身有__iter__方法，那它就是可迭代的。 # 只有内置了iter方法就是可迭代的对象。

d={‘a‘:1,‘b‘:2,‘c‘:3}
d.__iter__() # iter(d)

执行对象下的__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　

d={‘a‘:1,‘b‘:2,‘c‘:3}
d.__iter__
for k in d: #d.__iter__()    # for 循环
    print(k)

s={1,2,3,4}
for i in s:
    print(i)

为什么要用迭代器：
优点：

  1. 迭代器提供了一种不依赖于索引的取值方式，这样就可以遍历那些没有索引的可迭代对象了（字典，集合，文件）
  2. 迭代器与列表比较，迭代器是惰性计算的，更节省内存

缺点：

    1. 无法获取迭代器的长度，使用不如列表索引取值灵活
    2. 一次性的，只能往后取值，不能倒着取值
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))           #True
print(isinstance(l,Iterable))           #True
print(isinstance(t,Iterable))           #True
print(isinstance(d,Iterable))           #True
print(isinstance(set1,Iterable))        #True
print(isinstance(f,Iterable))           #True

# 查看是否是迭代器
print(isinstance(s,Iterator))          #False
print(isinstance(l,Iterator))          #False
print(isinstance(t,Iterator))          #False
print(isinstance(d,Iterator))          #False
print(isinstance(set1,Iterator))       #False
print(isinstance(f,Iterator))          #True

6、 生成器函数

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

  1. 如果函数内yield是表达式形式，那么必须先next(e)
  2. 二者的共同之处是都可以让函数在上次暂停的位置继续运行，不一样的地方在于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有何区别？

return只能返回一次函数就彻底结束了，而yield能返回多次值。函数在暂停以及继续下一次运行时的状态是由yield保存。

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

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)

yield

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))

next

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(‘\033[45m%s\033[0m‘ %line)

#/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(‘大蒜包子‘))

#为什么叫协程？
#协程怎么用？

协程函数

7、 生成器表达式（三元表达式）和列表解析

name=‘alex‘
name=‘linhaifeng‘
res=‘SB‘ if name == ‘alex‘ else ‘shuai‘
print(res)

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)])

8、生成器总结

综上已经对生成器有了一定的认识，下面我们以生成器函数为例进行总结

  • 语法上和函数类似：生成器函数和常规函数几乎是一样的。它们都是使用def语句进行定义，差别在于，生成器使用yield语句返回一个值，而常规函数使用return语句返回一个值
  • 自动实现迭代器协议：对于生成器，Python会自动实现迭代器协议，以便应用到迭代背景中（如for循环，sum函数）。由于生成器自动实现了迭代器协议，所以，我们可以调用它的next方法，并且，在没有值可以返回的时候，生成器自动产生StopIteration异常
  • 状态挂起：生成器使用yield语句返回一个值。yield语句挂起该生成器函数的状态，保留足够的信息，以便之后从它离开的地方继续执行

优点一：生成器的好处是延迟计算，一次返回一个结果。也就是说，它不会一次生成所有的结果，这对于大数据量处理，将会非常有用。

sum([i for i in range(100000000)])   #列表解析：内存占用大,机器容易卡死
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__())#报错

这里，至少有两个充分的理由说明 ，使用生成器比不使用生成器代码更加清晰：

  1. 使用生成器以后，代码行数更少。大家要记住，如果想把代码写的Pythonic，在保证代码可读性的前提下，代码行数越少越好
  2. 不使用生成器的时候，对于每次结果，我们首先看到的是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)   #提取出来的line都是字符串形式，需要使用eval提取起数据结构
            yield p[‘population‘]
gen=get_provice_population(‘人口信息.txt‘)

all_population=sum(gen)
for p in gen:
    print(p/all_population)
执行上面这段代码，将不会有任何输出，这是因为，生成器只能遍历一次。在我们执行sum语句的时候，就遍历了我们的生成器，当我们再次遍历我们的生成器的时候，将不会有任何记录。所以，上面的代码不会有任何输出。

因此，生成器的唯一注意事项就是：生成器只能遍历一次。

eval

def test():
    for i in range(4):
        yield i

g=test()
g1=(i for i in g)
g2=(i for i in g1)
print(list(g1))
print(list(g2))

note1

def add(n,i):
    return n+i

def test():
    for i in range(4):
        yield i

g=test()
for n in [1,10]:
    g=(add(n,i) for i in g)
print(list(g))

note2

import os

def init(func):
    def wrapper(*args,**kwargs):
        g=func(*args,**kwargs)
        next(g)
        return g
    return wrapper

@init
def list_files(target):
    while 1:
        dir_to_search=yield
        for top_dir,dir,files in os.walk(dir_to_search):
            for file in files:
                target.send(os.path.join(top_dir,file))
@init
def opener(target):
    while 1:
        file=yield
        fn=open(file)
        target.send((file,fn))
@init
def cat(target):
    while 1:
        file,fn=yield
        for line in fn:
            target.send((file,line))

@init
def grep(pattern,target):
    while 1:
        file,line=yield
        if pattern in line:
            target.send(file)
@init
def printer():
    while 1:
        file=yield
        if file:
            print(file)

g=list_files(opener(cat(grep(‘python‘,printer()))))

g.send(‘/test1‘)

协程应用：grep -rl /dir

【参考文档】

python基础之迭代器协议和生成器：https://www.cnblogs.com/luchuangao/p/6685626.html

迭代器协议和生成器：https://www.cnblogs.com/chenice/articles/6135714.html

原文地址：https://www.cnblogs.com/chenyuting/p/8709760.html

时间： 2024-08-29 03:05:30

第五篇、Python之迭代器与生成器的相关文章

python之迭代器与生成器

python之迭代器与生成器 可迭代 假如现在有一个列表,有一个int类型的12345.我们循环输出. list=[1,2,3,4,5] for i in list: print(i) for i in 12345: print(i) 结果: Traceback (most recent call last): File "C:/Pycham/生成器与迭代器/test1.py", line 6, in <module> for i in 12345: TypeError:

【Python】迭代器、生成器、yield单线程异步并发实现详解

转自http://blog.itpub.net/29018063/viewspace-2079767 大家在学习python开发时可能经常对迭代器.生成器.yield关键字用法有所疑惑,在这篇文章将从理论+程序调试验证的方式详细讲解这部分知识,话不多说,直接进入主题. 一.迭代器(Iterater):     首先介绍迭代器,迭代器是访问集合元素的一种方式,迭代器对象从集合的第一个元素开始访问,直到所有的元素被访问完结束.是不是觉得跟for循环很像?但是迭代器有几个特性需记住:    1.访问者

python基础----迭代器、生成器、协程函数

一.什么是迭代器协议 1.迭代器协议是指:对象必须提供一个next方法,执行该方法要么返回迭代中的下一项,要么就引起一个StopIteration异常,以终止迭代 (只能往后走不能往前退) 2.可迭代对象:实现了迭代器协议的对象(如何实现:对象内部定义一个__iter__()方法) 3.协议是一种约定,可迭代对象实现了迭代器协议,python的内部工具(如for循环,sum,min,max函数等)使用迭代器协议访问对象. 二,为什么要用迭代器 优点: 1:迭代器提供了一种不依赖于索引的取值方式,

Python的迭代器和生成器

先说迭代器,对于string.list.dict.tuple等这类容器对象,使用for循环遍历是很方便的就,在后台for语句对容器对象对象调用iteration()函数,这是python的内置函数,iter()会返回一个定义next()方法的迭代器对象,它在容器中逐个访问容器内元素,next()也是python的内置函数.在没有后续元素是,调用next()会抛出一个StopIteration异常 上面说的都是python自带的容器对象,它们都实现了相应的迭代器方法,自定义类的遍历怎么实现,方法是

python中迭代器和生成器。

前言:很多python教程中,对python的解释不容易理解,本文记录自己的理解和体会,是对迭代器和生成器的初步理解. 迭代器: 迭代器的实质是实现了next()方法的对象,常见的元组.列表.字典都是迭代器. 迭代器中重点关注两种方法: __iter__方法:返回迭代器自身.可以通过python内建函数iter()调用. __next__方法:当next方法被调用的时候,迭代器会返回它的下一个值,如果next方法被调用,但迭代器没有只可以返回,就会引发一个StopIteration异常.该方法可

python之 迭代器，生成器

什么叫跌代: 可以将某个数据集合内的数据一个一个挨着取出来就叫做跌代. 迭代器协议: 可以被跌代要满足的要求叫做可迭代协议,可迭代对象必须提供一个next的方法,执行该方法要么返回跌代中的下一项,要么就引起一个StopIteration异常,以终止跌代(跌代只能往后走,而不能往前退) python中的for循环: for循环的本质就是遵循迭代器协议去访问对象,for循环可以遍历(字符串,列表,元祖,字典,集合,文件对象)这些对象都是不可迭代对象,只不过在for循环时,调用了他们内部的-iter-

day13 python学习 迭代器，生成器

1.可迭代:当我们打印 print(dir([1,2]))   在出现的结果中可以看到包含 '__iter__', 这个方法,#次协议叫做可迭代协议 包含'__iter__'方法的函数就是可迭代函数 字符串.列表.元组.字典.集合都可以被for循环,说明他们都是可迭代的. 2.迭代器 iterator l = [1,2,3,4] l_iter = l.__iter__() #迭代器的生成 item = l_iter.__next__() #迭代器的使用,用此方法一一钓鱼迭代器中的数值 print

python基础-迭代器和生成器

一.递归和迭代 1.递归:(问路示例) 递归算法是一种直接或者间接地调用自身算法的过程.在计算机编写程序中,递归算法对解决一大类问题是十分有效的,它往往使算法的描述简洁而且易于理解. 2.迭代:简单理解为更新换代( 儿子生孙子的故事) 二.迭代器协议 1.迭代器协议是指:对象必须提供一个next方法,执行该方法要么返回迭代中的下一项,要么就引起一个StopIteration异常,以终止迭代 (只能往后走不能往前退) 2.可迭代对象:实现了迭代器协议的对象(如何实现:对象内部定义一个__iter_

python中迭代器和生成器的区别

1 #!/usr/bin/python 2 def power(values): 3 for value in values: 4 print "powing %s" % value 5 yield value 6 def add(values): 7 for value in values: 8 if value % 2 == 0: 9 yield value + 3 10 else: 11 yield value + 2 12 elements = [1, 4, 7, 9, 12,