Python3 迭代器与生成器

最新推荐文章于 2024-04-04 00:00:00 发布

淮南草

最新推荐文章于 2024-04-04 00:00:00 发布

阅读量148

点赞数

分类专栏： python 语法基础

本文链接：https://blog.csdn.net/zhuisaozhang1292/article/details/79997259

版权

python 语法基础专栏收录该内容

29 篇文章 0 订阅

订阅专栏

生成器

特性：1、只有在调用时才会生成相应的数据

2、只记录当前位置

3、只有一个__next__()方法

单线程下的并行程序、程序执行到yield就跳出去

在 Python 中，使用了 yield 的函数被称为生成器（generator）。

跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。

在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。

调用一个生成器函数，返回的是一个迭代器对象。

普通函数和生成器使用的区别：

def r_return(n):
     print ("You taked me.")
     while n > 0:
         print ("before return")
         return n
         n -= 1
         print ("after return")
 
rr = r_return(3)

输出：

You taked me.
before return

输入：

def y_yield(n):
     print ("You taked me.")
     while n > 0:
         print ("before yield")
         yield n
         n -= 1
         print ("after yield")
 
rr = y_yield(3)
rr.__next__()
rr.__next__()
rr.__next__()
rr.__next__()

输出：

You taked me.
before yield
after yield
before yield
after yield
before yield
after yield
Traceback (most recent call last):
  File "F:\eclipse-workspace\algorithm\src\MMP.py", line 44, in <module>
    rr.__next__()
StopIteration

一般的函数，都是止于return。作为生成器的函数，由于有了yield，则会遇到它挂起，如果还有return，遇到它就直接抛出SoptIteration异常而中止迭代

实例2：

import time
def consumer(name):
    print("%s 准备喝可乐了" %name)
    while True:
        kele = yield
        print("可乐[%s]来了 ，被[%s]喝了!" %(kele,name))
        
# c = consumer('hcl')
# # print(c)
# c.__next__()
# c.__next__()
 
def producer(name):
    c = consumer('A')
    c2 = consumer('B')
    c.__next__()
    c2.__next__()
    print("我开始喝可乐了")
    for i in range(10):
        time.sleep(1)
        print("%s生产了一瓶可乐，分两半" %name)
        c.send(i)
        c2.send(i)

producer('ln')

输出为：

A 准备喝可乐了
B 准备喝可乐了
我开始喝可乐了
ln生产了一瓶可乐，分两半
可乐[0]来了 ，被[A]喝了!
可乐[0]来了 ，被[B]喝了!
ln生产了一瓶可乐，分两半
可乐[1]来了 ，被[A]喝了!
可乐[1]来了 ，被[B]喝了!
ln生产了一瓶可乐，分两半
可乐[2]来了 ，被[A]喝了!
可乐[2]来了 ，被[B]喝了!
ln生产了一瓶可乐，分两半
可乐[3]来了 ，被[A]喝了!
可乐[3]来了 ，被[B]喝了!
ln生产了一瓶可乐，分两半
可乐[4]来了 ，被[A]喝了!
可乐[4]来了 ，被[B]喝了!
ln生产了一瓶可乐，分两半
可乐[5]来了 ，被[A]喝了!
可乐[5]来了 ，被[B]喝了!
ln生产了一瓶可乐，分两半
可乐[6]来了 ，被[A]喝了!
可乐[6]来了 ，被[B]喝了!
ln生产了一瓶可乐，分两半
可乐[7]来了 ，被[A]喝了!
可乐[7]来了 ，被[B]喝了!
ln生产了一瓶可乐，分两半
可乐[8]来了 ，被[A]喝了!
可乐[8]来了 ，被[B]喝了!
ln生产了一瓶可乐，分两半
可乐[9]来了 ，被[A]喝了!
可乐[9]来了 ，被[B]喝了!

迭代器

特性：1、可迭代对象

2、迭代器

凡是可作用于for循环的对象都是Iterable函数

凡是可作用于next()函数的对象都是Iterable类型

集合数据类型如 list dict str 等都是Iterable 但不是Iterator

生成器一定是迭代器，迭代器的方法有iter()和next()

使用 yield 实现斐波那契数列

import sys
 
def fibonacci(n): # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n): 
            return
        yield a        #b
        a, b = b, a + b
        counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成
 
while True:
    try:
        print (next(f), end=" ")
    except StopIteration:
        sys.exit()

输出为：