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

 

(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这个迭代器本身

 

(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可以传多个值,但是必须是元组类型

 

 

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

  

 

 

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

 

posted @ 2017-04-24 17:24  karina梅梅  阅读(250)  评论(0编辑  收藏  举报