python基础—迭代器、生成器

python基础—迭代器、生成器

 

1 迭代器定义

 

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

 

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

 

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

 

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

   迭代器也有__iter__方法。

 

2 迭代器特性

优点：

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

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

缺点：

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

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

 

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

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

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

 

3 迭代器代码

(1)索引方式循环

1
2
3
4
5
6
7
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__方法，那他就是可迭代的

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

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

 

(3)迭代器的__next__方法

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

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

1
2
3
4
5
6
7
l=['a','b','c','d']
i=iter(l)
print(i.__next__())
print(i.__next__())
print(i.__next__())
print(i.__next__())
print(i.__next__())

输出结果：

1
2
3
4
5
a
b
c
d
StopIteration  #报错

 

(4)while循环与迭代器

 

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

 

输出结果：

1
2
3
4
b
c
a
d

 

(5)for循环与迭代器

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

For循环与列表

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

 

For循环与文件

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

　　

(6)迭代器也有__iter__方法

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

 

(7)迭代器是一次性的

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

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

1
2
3
4
5
6
7
8
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)

输出结果：

1
2
3
4
d
a
b
c

 

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

Isinstance使用例子:

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

 输出结果：

1
2
True
True

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
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停止

1
2
3
4
5
6
7
8
9
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))

输出结果：

1
2
3
4
5
<generator object test at 0x000000E8CBDE5360>
first
1
True
True

　

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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)

输出结果：

1
2
3
4
5
6
7
one
1
two
2
three
3
StopIteration  #报错

　　

1
2
3
4
5
6
7
8
9
10
def test():
    print("one")
    yield 1
    print("two")
    yield 2
    print("three")
    yield 3
g=test()
for i in g:
    print(i)

输出结果：

1
2
3
4
5
6
one
1
two
2
three
3

 

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

yield可以返会任何类型的值

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

输出结果：

1
(1,2,3,4)

 

生成器与return有何区别？

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

 

yield到底干了什么事情？

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

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

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

 

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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)

输出结果：　

1
2
3
4
5
6
7
8
9
10
11
12
13
14
start countnum
5
4
3
2
1
done
start countnum
5
4
3
2
1
done

　　

4.4 用生成器模拟管道　

tailf命令的实现

1 普通函数实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#/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 生成器函数实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#/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” 实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#/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的输入

　

1
2
3
4
5
6
7
8
9
10
11
12
13
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协程函数举例

 

1
2
3
4
5
6
7
8
9
10
11
12
13
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")

 

输出结果：

1
2
3
4
5
6
<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

　　

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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"))

输出结果：

1
2
3
4
5
6
7
8
9
10
<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

1
2
3
4
5
6
7
8
9
10
11
12
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 协程函数用装饰器初始化

 

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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-06-19 16:25  云养猫  阅读(128)  评论(0)  编辑  收藏  举报