python中yield和协程_python sche_yield负载

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、生成器yield

yield是Python中的一个关键字，用于定义生成器函数。生成器函数是一种特殊的函数，它可以在运行中暂停并返回一个中间结果，然后在下一次调用时继续执行，并从上一次暂停的位置开始。
yield语句可以在生成器函数中使用，它类似于return语句，但不同之处在于，它可以多次返回一个中间结果，并保留函数的状态，以便下一次调用时继续执行。一般来说，使用yield的程序可以看成是一个迭代器。

以下是使用yield语句定义生成器函数的示例：

def my_generator():
    yield 1
    yield 2
    yield 3
    yield 4

1
2
3
4
5
6

以上函数定义了一个生成器函数，它可以生成数字1、2、3和4。可以通过调用next()函数来迭代生成器：

g = my_generator()
print(next(g)) # 输出 1
print(next(g)) # 输出 2
print(next(g)) # 输出 3
print(next(g)) # 输出 4
1
2
3
4
5

除了使用next()函数迭代生成器外，还可以使用for循环对生成器进行迭代：

for i in my_generator():
    print(i)

1
2
3

以上代码将输出数字1到4。使用yield语句定义生成器函数可以帮助节省内存，因为生成器函数在生成结果时不需要一次性生成全部结果，而是每次只生成一个结果，从而避免了一次性创建大量的对象。

实例一

#! /usr/bin/python
# -*-coding: UTF-8 -*-
import time


def fun1():
    a = 1
    print("将a赋值")
    yield a #中断函数，返回return a，等待写一个next才会执行
    b = 2
    print("将b赋值")
    yield b
    pass


def main():
    g1 = fun1()
    print(next(g1))
    time.sleep(2)
    print(next(g1))

    pass

if __name__=='__main__':
    main()

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

运行结果为：

将a赋值
1
将b赋值
2

Process finished with exit code 0

1
2
3
4
5
6
7

实例二

#! /usr/bin/python
# -*-coding: UTF-8 -*-
import time


def produce():
    for i in range(100):
        yield "生产了%s个包子"%i
    pass


def main():
    p = produce()
    num = 0
    for i in p:
        print(i)
        num +=1
        if num==12:
            break

    pass

if __name__=='__main__':
    main()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

或者：

#! /usr/bin/python
# -*-coding: UTF-8 -*-
import time


def produce():
    for i in range(100):
        yield "生产了%s个包子"%i
    pass


def main():
    p = produce()
    num = 0
    for i in range(12):
        print(p.__next__())


    pass

if __name__=='__main__':
    main()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

运行结果为：

生产了0个包子
生产了1个包子
生产了2个包子
生产了3个包子
生产了4个包子
生产了5个包子
生产了6个包子
生产了7个包子
生产了8个包子
生产了9个包子
生产了10个包子
生产了11个包子

Process finished with exit code 0

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

传入参数的yield实例

实例三

#! /usr/bin/python
# -*-coding: UTF-8 -*-
import time

def gen():
    print("start")
    content = yield 1
    print("===========",content)
    yield 2
    pass


def main():
    g = gen()
    ret1 = g.__next__()
    print("第一个yield返回为：",ret1)
    ret2 = g.send("i am coming")#给第一个yield发东西，发完自动next
    print("第二个yield返回为：",ret2)


    pass

if __name__=='__main__':
    main()

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

运行结果为：

start
第一个yield返回为： 1
=========== i am coming
第二个yield返回为： 2

Process finished with exit code 0

1
2
3
4
5
6
7

二、协程

Python协程是一种用户级的轻量级线程，可以在单个线程中实现多个并发任务。它通过在函数执行过程中暂停和恢复来实现多任务切换，可以避免多线程的上下文切换开销，提高程序的效率。在Python 3.5及以上版本中，可以使用async/await关键字来定义协程函数，同时配合asyncio模块实现协程调度和异步IO操作。

下面是一个简单的例子，演示了如何使用async/await关键字创建一个协程函数：

import asyncio

async def greet(name):
    print(f"Hello, {name}!")
    await asyncio.sleep(1)
    print(f"Goodbye, {name}!")

async def main():
    await asyncio.gather(
        greet("Alice"),
        greet("Bob"),
        greet("Charlie")
    )

if __name__ == "__main__":
    asyncio.run(main())

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

上述代码中，greet()是一个协程函数，使用async关键字定义。在函数中，我们使用await关键字来暂停函数的执行，等待异步操作完成后再恢复执行。在main()函数中，我们使用asyncio.gather()函数来同时运行多个协程，并等待它们全部执行完成。

需要注意的是，像上述代码中的print()函数，以及Python标准库中许多IO相关的操作，本身就是异步的。在使用这些函数时，并不需要显式地使用await关键字来暂停函数的执行。只有当需要等待某个IO操作完成后才能继续执行时，我们才需要使用await关键字。

实例一

#! /usr/bin/python
# -*-coding: UTF-8 -*-
import time

def task1():
    while True:
        print("---任务1---")
        time.sleep(1)
        yield

def task2():
    while True:
        print("---任务2---")
        time.sleep(2)
        yield


def main():

    t1 = task1()
    t2 = task2()

    while True:
        next(t1)
        next(t2)
    pass

if __name__=='__main__':
    main()

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
28
29
30

运行结果为：

---任务1---
---任务2---
---任务1---
---任务2---
---任务1---
---任务2---
---任务1---
---任务2---
#无限下去。。。。
1
2
3
4
5
6
7
8
9

python中greenl
et模块
Greenlet是一个Python的第三方模块，它实现了轻量级的协程，支持向上下文切换（context switching）和调度。协程是一种用户态线程，可以在不同任务之间切换，避免了线程切换的开销，能够提高程序的并发性能。

Greenlet模块可以用于实现高性能的网络服务器，以及协程相关的应用程序。它提供了一个Greenlet类，用于创建和管理协程。通过调用Greenlet的switch()方法，可以从当前协程中切换到指定的协程上下文，从而实现协程之间的切换。

以下是一个使用Greenlet模块实现协程的示例代码：

from greenlet import greenlet

def foo():
    print("Starting foo...")
    gr2.switch()
    print("Resuming foo...")
    gr2.switch()

def bar():
    print("Starting bar...")
    gr1.switch()
    print("Resuming bar...")

gr1 = greenlet(foo)
gr2 = greenlet(bar)
gr1.switch()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在上述例子中，我们定义了两个函数foo()和bar()，分别是协程的两个上下文。我们使用Greenlet类创建了两个协程对象gr1和gr2，并在主程序中调用了gr1的switch()方法开始运行foo()函数。在foo()函数中，我们使用gr2的switch()方法切换到gr2协程上下文运行bar()函数，然后再次切换回gr1协程上下文。在bar()函数中，我们使用gr1的switch()方法切换回gr1协程上下文继续运行foo()函数。

通过这种方式，我们就实现了两个协程之间切换的过程，避免了线程切换的开销，提高了程序的并发性能。

实例二

#! /usr/bin/python
# -*-coding: UTF-8 -*-
import time

from greenlet import greenlet



def main():
    def eat(name):
        print("%s eat 1" % name)
        g2.switch("haha")
        print("%s eat 2" % name)
        g2.switch()

    def play(name):
        print("%s play 1" % name)
        g1.switch()
        print("%s play 2" % name)


    g1 = greenlet(eat)
    g2 = greenlet(play)

    g1.switch("haha")

    pass

if __name__=='__main__':
    main()

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
28
29
30
31

运行结果为：

haha eat 1
haha play 1
haha eat 2
haha play 2

Process finished with exit code 0

1
2
3
4
5
6
7

实例三

#! /usr/bin/python
# -*-coding: UTF-8 -*-
import time

from greenlet import greenlet

def f1():
    m = 1
    for i in range(10):
        m += 1
        time.sleep(1)
        print(m)
        g2.switch()

def f2():
    m = 1
    for i in range(20):
        m += 2
        time.sleep(1)
        print()
        g1.switch()

g1 = greenlet(f1)
g2 = greenlet(f2)

def main():
    start_time = time.time()
    g2.switch()
    end_time = time.time()
    print(end_time-start_time)


    pass

if __name__=='__main__':
    main()

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
28
29
30
31
32
33
34
35
36
37

运行结果为：

2

3

4

5

6

7

8

9

10

11

21.20890712738037

Process finished with exit code 0

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

三、gevent

实例一

#! /usr/bin/python
# -*-coding: UTF-8 -*-
import gevent
import time

from greenlet import greenlet

def eat(name):
    print("%s eat 1"%name)
    gevent.sleep(2)#模拟拥塞
    print("%s eat 2"%name)

def play(name):
    print("%s play 1"%name)
    gevent.sleep(1)
    print("%s eat 2"%name)

def main():
    g1 = gevent.spawn(eat,"小明")#创建协程对象
    g2 = gevent.spawn(play,"小红")
    g1.join()
    g2.join()
    print("主")


    pass

if __name__=='__main__':
    main()

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
28
29
30

运行结果为：

小明 eat 1
小红 play 1
小红 eat 2
小明 eat 2
主

Process finished with exit code 0

1
2
3
4
5
6
7
8

实例二

#! /usr/bin/python
# -*-coding: UTF-8 -*-
from gevent import monkey;monkey.patch_all()#如果不用gevent.sleep的话
import gevent
import time

from greenlet import greenlet

def eat(name):
    print("%s eat 1"%name)
    time.sleep(1)
    print("%s eat 2"%name)

def play(name):
    print("%s play 1"%name)
    time.sleep(2)
    print("%s eat 2"%name)

def main():
    g1 = gevent.spawn(eat,"小明")#创建协程对象
    g2 = gevent.spawn(play,"小红")
    #g1.join()
    #g2.join()
    gevent.joinall([g1,g2])
    print("主")


    pass

if __name__=='__main__':
    main()

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
28
29
30
31
32

运行结果为：

小明 eat 1
小红 play 1
小明 eat 2
小红 eat 2
主

Process finished with exit code 0

1
2
3
4
5
6
7
8