c迭代器与生成器

时间 2019-12-10

标签迭代与生成器栏目 C&C++ 繁體版

原文原文链接

一：迭代器python

1.什么是迭代？linux

　　1.重复 2.下一次重复是基于上一次的结果数据结构

# l=['a','b','c','d'] # count=0 # while count < len(l): # print(l[count]) #count的值基于上一次结果，因此是迭代
# count+=1

2.迭代器协议app

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

python 为了提供一种不依赖索引的迭代方式

　　以obj=[1,2,3,,4,5]为例：

　　　　python会为一些对象内置.__iter__方法，可以.__iter__的都是能够成为可迭代对象.

　　　　　　若是咱们obj.__iter__()后获得一个结果就是迭代器。迭代器既有.__iter__ 方法又有 .__next__方法.

　　迭代器的优势:
　　　　1.提供了一种不依赖索引的迭代方式
　　　　2.惰性计算，节省内存

　　迭代器的缺点：
　　　　1.取值不如按照索引取值的方便
　　　　2.只能前进，不能后退
　　　　3.没法获取长度函数

判断是否为可迭代对象或者迭代器对象的方法：测试

以a=[1,2,3,4]为例：

方法一:

　　　obj=a.__iter__() 　　　说明他是可迭代对象,obj成为迭代器

　　　obj.__next__() 　说明obj是迭代器对象

方法二：

　　　from collections import Iterable,Iterator #调用相应模块，测试是否为可迭代对象或者迭代器对象

　　 print(isinstance(a,Iterable)) #判断是否为可迭代对象，若是是则返回True

print(isinstance(a,Iterator)) #判断是否为迭代器对象，若是是则返回True

# # from collections import Iterable,Iterator # # print(isinstance(g,Iterator)) #可判断是够为迭代器对象

# def countdown(n): # print('starting countdown') # # while n > 0: # yield n # n-=1 # print('stop countdown') # g=countdown(5)

# print(g.__next__()) # print(g.__next__()) # for i in g: # print(i)

View Code

3 迭代器spa

　　在介绍迭代器以前，咱们先来了解一下容器这个概念。code

　　　　容器是一种把多个元素组织在一块儿的数据结构，容器中的元素能够逐个地迭代获取。简单来讲，就比如一个盒子,咱们能够往里面存放数据，也能够从里面一个一个地取出数据。在python中，属于容器类型地有:list,dict,set,str,tuple.....。容器仅仅只是用来存放数据的，咱们日常看到的 l = [1,2,3,4]等等，好像咱们能够直接从列表这个容器中取出元素，但事实上容器并不提供这种能力，而是可迭代对象赋予了容器这种能力。对象

　　　说完了容器，咱们在来谈谈迭代器。迭代器与可迭代对象区别在于:__next__()方法。

　　咱们能够采用如下方法来验证一下:

from collections import Iterator

f = open('a.txt')
i = 1
s = '1234'
d = {'abc':1}
t = (1, 2, 344)
m = {1, 2, 34, }

print(isinstance(i,Iterator))
print(isinstance(s,Iterator))
print(isinstance(d,Iterator))
print(isinstance(t,Iterator))
print(isinstance(m,Iterator))
print(isinstance(f,Iterator))

########输出结果##########
False
False
False
False
False
True

View Code

　结果显示:除了文件对象为迭代器，其他均不是迭代器

　　下面，咱们进一步来验证一下:

print(hasattr(i,"__next__"))
print(hasattr(s,"__next__"))
print(hasattr(d,"__next__"))
print(hasattr(t,"__next__"))
print(hasattr(m,"__next__"))
print(hasattr(f,"__next__"))

#######结果###########
False
False
False
False
False
True

View Code

从输出结果能够代表,迭代器与可迭代对象仅仅就是__next__（）方法的有无。

——————--模拟linux中的taif -f a.txt |grep 'error' |grep '404'

'模拟linux中'
#tail -f a.txt
import time
def tail(filepath,encoding='utf-8'):
    with open(filepath,encoding=encoding) as f:
        f.seek(0,2)
        while True:
            line=f.readline()
            if line:
                print(line,end='')
                # yield line
            else:
                time.sleep(0.5)

tail('b.txt')

# for i in g:
#     print(i)

#tail -f a.txt |grep 'error'

# def grep(lines,pattern):
#     for line in lines:
#         if pattern in line:
#             # print(line,end='')
#             yield line

# g=tail('a.txt')
# print(g)

# grep(g,'error')

# tail -f a.txt |grep 'error' |grep '404'

# g1=tail('a.txt')
# g2=grep(g1,'error')
# g3=grep(g2,'404')
# for i in g3:
#     print(i)

View Code

4 for循环

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

Tips：(字符串，列表，元组，字典，集合，文件对象）这些都不是可迭代对象，只不过在for循环式，调用了他们内部的__iter__方法，把他们变成了可迭代对象，

而后for循环调用可迭代对象的__next__方法去取值，并且for循环会捕捉StopIteration异常，以终止迭代.

　　　StopIteration异常：.__nex___执行后若是没有返回值就会报此异常。

for item in g: 
    print(item)

 ###for执行in后面的对象g下面的.__iter__方法，获得一个迭代器k，而后for循环自动k.__next__一次，将获得的结果赋值给item.而后再iter一次变成迭代器赋值给item，直到没有值输出，出现stopiteration异常，for循环能够捕捉到这个异常，而后终止这个循环。

for item in 8：
　　print(item)
============结果================
TypeError：'int' object is not iterable              ###数字是不可迭代对象，下面没有.__iter__方法，因此报错。

Try 可检测异常：

l={'a':1,'x':2,'w':3,'z':4} l=l.__iter__()    #转换成迭代器
while True: try:     #捕捉异常，检测其下缩进的语句是否有异常
        i=l.__next__() print(i) except StopIteration:   #except检测异常
        break

View Code

二：生成器（生成器的本质就是迭代器）

1.什么是生成器

　　能够理解为一种数据类型，这种数据类型自动实现了迭代器协议（其余的数据类型须要调用本身内置的__iter__方法），因此生成器是可迭代对象。

　　按照咱们以前所说的，迭代器必须知足两个条件:既有__iter__()，又有__next__()方法。那么生成器是否也有这两个方法呢？答案是，YES。具体来经过如下代码来看看。

def func():
    print("one------------->")
    yield 1
    print("two------------->")
    yield 2
    print("three----------->")
    yield 3
    print("four------------>")
    yield 4

print(hasattr(func(),'__next__'))
print(hasattr(func(),'__iter__'))

#########输出结果###########
True
True

View Code

Python有两种不一样的方式提供生成器：

　　1.函数体内包含有yield关键字，该函数的执行结果是生成器(generator).可是，使用yield语句而不是return语句返回结果。yield语句一次返回一个结果，在每一个结果中间，挂起函数的状态，以便下次重它离开的地方继续执行.

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

既然生成器就是迭代器,那么咱们是否是也能够经过for循环来遍历出生成器中的内容呢?看下面代码.

def func():
    print("one------------->")
    yield 1
    print("two------------->")
    yield 2
    print("three----------->")
    yield 3
    print("four------------>")
    yield 4

for i in func():
    print(i)

#########输出结果########
one------------->
1
two------------->
2
three----------->
3
four------------>
4

View Code

很显然，生成器也能够经过for循环来遍历出其中的内容。

下面咱们来看看生成器函数执行流程：

def func():
    print("one------------->")
    yield 1
    print("two------------->")
    yield 2
    print("three----------->")
    yield 3
    print("four------------>")
    yield 4


g = func()  #  生成器 == 迭代器
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())

View Code

每次调用g.__next__()就回去函数内部找yield关键字，若是找获得就输出yield后面的值而且返回；若是没有找到，就会报出异常。上述代码中若是在调用g.__next__()就会报错。Python使用生成器对延迟操做提供了支持。所谓延迟操做，是指在须要的时候才产生结果，而不是当即产生结果。这也是生成器的主要好处。

生成器就是迭代器，只能前进不能后退，咱们看下这个例子：

#生成器函数补充
# def countdown(n):
#     while n > 0:
#         yield n
#         n-=1
#
# g=countdown(5)
# print(g.__next__())
# print(g.__next__())
#
# print('='*20)
# for i in g:
#     print(i)
#
# print('*'*20)
# for i in g:
#     print(i)

=======结果========
5
4
====================
3
2
1
********************

View Code

yiled与return的区别：

一个标准：

　　yield和return类似可是一个函数内能够有多个yield而函数中出现了多个return也只会对第一个return有效果

yield的功能：

　　1. 与return相似，均可以返回值，不同在于，yield能够返回多个值并且可暂停，再次执行可继续下一步操做，return到了就中止不在继续运行。

　　2.为封装好的的函数可以使用__iter__和__next__方法，

　　3.遵循迭代器的取值方式obj.__next__(),触发函数的执行和函数的保存都是经过yeild保存的

=========================================================================================================================================

1.三元表达式

x=2
y=3

# if x > y:
#     print(x)
# else:
#     print(y)

# res='aaaaa' if x > y else 'bbbbbbb'   #三元表达式---->【 条件成立     条件  条件不成立】
#
# print(res)

View Code

2.列表解析<不能加else，条件成立的状况下放到左边。>

# l=[1,31,73,84,57,22]
# l_new=[]
# for i in l:
#     if i > 50:
#         l_new.append(i)
# print(l_new)
#列表解析
# res=[i for i in l if i > 50]
# print(res)

View Code

3.生成器表达式

#g=(i for i in range(100000000000000000000000000000))
#print (g)

#print(next(g))   ##next(g) == g.__next__()
#print(next(g))   ##next(g) == g.__next__()