学习python:day10

一. 进程

1. 多进程multiprocessing

multiprocessing包是Python中的多进程管理包，是一个跨平台版本的多进程模块。与threading.Thread类似，它可以利用multiprocessing.Process对象来创建一个进程。该进程可以运行在Python程序内部编写的函数。该Process对象与Thread对象的用法类似。

创建一个Process实例，可用start()方法启动。

join()方法可以等待子进程结束后再继续往下运行，通常用于进程间的同步。


1

2

3

4

5

6

7

8

9

10

from multiprocessing import Process

import time

def f(name):

    time.sleep(2)

    print(‘hello‘, name)

 

if __name__ == ‘__main__‘:

    p = Process(target=f, args=(‘bob‘,))

    p.start()

    p.join()

写个程序，对比下主进程和子进程的ID：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

from multiprocessing import Process

import os

def info(title):

    print(title)

    print(‘进程名称:‘, __name__)

    print(‘父进程ID:‘, os.getppid())

    print(‘子进程ID:‘, os.getpid())

    print("\n\n")

def f(name):

    info(‘\033[31;1mcalled from child process function f\033[0m‘)

    print(‘hello‘, name)

if __name__ == ‘__main__‘:

    info(‘\033[32;1mmain process line\033[0m‘)

    p = Process(target=f, args=(‘bob‘,))

    p.start()

2. 进程间通信

不同进程间内存是不共享的，要想实现两个进程间的数据交换，可以使用Queue、Pipe、Manager，其中：

1）Queue  \ Pipe 只是实现进程间数据的传递；

2）Manager 实现了进程间数据的共享，即多个进程可以修改同一份数据；

2.1 Queue

Queue允许多个进程放入，多个进程从队列取出对象，先进先出。（使用方法跟threading里的queue差不多）


1

2

3

4

5

6

7

8

9

10

11

12

from multiprocessing import Process,Queue

def f(qq):

    qq.put([42,None,"hello"])

    qq.put([43,None,"HI"])

if __name__ == ‘__main__‘:

    q = Queue()

    p = Process(target=f,args=(q,))

    p.start()

    print(q.get())

    print(q.get())

    p.join()

2.2 Pipe

Pipe也是先进先出


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

from multiprocessing import Process, Pipe

def f(conn):

    conn.send([42, None, ‘儿子发送的消息‘])

    conn.send([42, None, ‘儿子又发消息啦‘])

    print("接收父亲的消息:",conn.recv())

    conn.close()

if __name__ == ‘__main__‘:

    parent_conn, child_conn = Pipe()

    p = Process(target=f, args=(child_conn,))

    p.start()

    print(parent_conn.recv())  # prints "[42, None, ‘hello‘]"

    print(parent_conn.recv())  # prints "[42, None, ‘hello‘]"

    parent_conn.send("回家吃饭！") # prints "[42, None, ‘hello‘]"

    p.join()

2.3 Manager

Manager对象类似于服务器与客户之间的通信 (server-client)，与我们在Internet上的活动很类似。我们用一个进程作为服务器，建立Manager来真正存放资源。其它的进程可以通过参数传递或者根据地址来访问Manager，建立连接后，操作服务器上的资源。在防火墙允许的情况下，我们完全可以将Manager运用于多计算机，从而模仿了一个真实的网络情境。


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

from multiprocessing import Process,Manager

import  os

def f(d,l):

    d[os.getpid()] = os.getpid()

    l.append(os.getpid())

    print(l)

if __name__ == "__main__":

    with Manager() as manager:

        d = manager.dict()#生成一个字典，可在多个进程间共享和传递

        l = manager.list(range(5))#生成一个列表，可在多个进程间实现共享和传递

        p_list = []

        for i in range(10):

            p = Process(target=f,args=(d,l))

            p.start()

            p_list.append(p)

        for res in p_list:#等待结果

            res.join()

3. 进程池

进程池 (Process Pool)可以创建多个进程。这些进程就像是随时待命的士兵，准备执行任务(程序)。一个进程池中可以容纳多个待命的士兵。

进程池有两种方法：

1）串行：apply

2）并行：apply_async


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

from multiprocessing import Process,Pool

import time

import os

def Foo(i):

    time.sleep(2)

    print("in process",os.getpid())

    return i+100

def Bar(arg):

    ‘‘‘回调函数‘‘‘

    print("-->>exec done:",arg,os.getpid())

if __name__ == "__main__":

    pool = Pool(processes=3)#允许进程池同时放入3个进程

    print("主进程",os.getpid())

    for i in range(10):

        pool.apply_async(func=Foo,args=(i,),callback=Bar)

    print(‘end‘)

    pool.close()

    pool.join()#进程池中进程执行完毕后在关闭；如果注释则程序直接关闭

使用回调函数的目的是：在父进程中执行可以提高效率；（比如连接数据库，写回调函数的话，父进程连接一次数据库即可；如果使用子进程，则需要连接多次）

4. 其他(lock)

lock：屏幕上打印的锁，防止打印显示混乱


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

from multiprocessing import Process, Lock

def f(l, i):

    #上锁

    l.acquire()

    try:

        print(‘hello world‘, i)

    finally:

        #解锁

        l.release()

#因为屏幕是共享的，定义锁的目的是打印的信息不换乱，而不是顺序不会乱

if __name__ == ‘__main__‘:

    #定义锁

    lock = Lock()

    for num in range(10):

        Process(target=f, args=(lock, num)).start()

二. 协程

协程，又称微线程，纤程。英文名Coroutine。

协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈。因此：协程能保留上一次调用时的状态（即所有局部状态的一个特定组合），每次过程重入时，就相当于进入上一次调用的状态，换种说法：进入上一次离开时所处逻辑流的位置。

好处：

  • 无需线程上下文切换的开销
  • 无需原子操作锁定及同步的开销
  • 方便切换控制流，简化编程模型
  • 高并发+高扩展性+低成本：一个CPU支持上万的协程都不是问题。所以很适合用于高并发处理。

缺点：

  • 无法利用多核资源：协程的本质是个单线程,它不能同时将 单个CPU 的多个核用上,协程需要和进程配合才能运行在多CPU上.当然我们日常所编写的绝大部分应用都没有这个必要，除非是cpu密集型应用。
  • 进行阻塞（Blocking）操作（如IO时）会阻塞掉整个程序

1.实例

传统的生产者-消费者模型是一个线程写消息，一个线程取消息，通过锁机制控制队列和等待，但一不小心就可能死锁。

如果改用协程，生产者生产消息后，直接通过yield跳转到消费者开始执行，待消费者执行完毕后，切换回生产者继续生产，效率极高。

代码示例：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

def consumer():

    r = ‘‘

    while True:

        n = yield r

        if not n:

            return

        print(‘[消费者] Consuming %s...‘ % n)

        r = ‘200 OK‘

def produce(c):

    c.send(None)

    n = 0

    while n < 5:

        n = n + 1

        print(‘[生产者] Producing %s...‘ % n)

        r = c.send(n)

        print(‘[生产者] 消费者返回状态码: %s‘ % r)

    c.close()

c = consumer()

produce(c)

输出结果：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

[生产者] Producing 1...

[消费者] Consuming 1...

[生产者] 消费者返回状态码: 200 OK

[生产者] Producing 2...

[消费者] Consuming 2...

[生产者] 消费者返回状态码: 200 OK

[生产者] Producing 3...

[消费者] Consuming 3...

[生产者] 消费者返回状态码: 200 OK

[生产者] Producing 4...

[消费者] Consuming 4...

[生产者] 消费者返回状态码: 200 OK

[生产者] Producing 5...

[消费者] Consuming 5...

[生产者] 消费者返回状态码: 200 OK

注意到consumer函数是一个generator，把一个consumer传入produce后：

  1. 首先调用c.send(None)启动生成器；
  2. 然后，一旦生产了东西，通过c.send(n)切换到consumer执行；
  3. consumer通过yield拿到消息，处理，又通过yield把结果传回；
  4. produce拿到consumer处理的结果，继续生产下一条消息；
  5. produce决定不生产了，通过c.close()关闭consumer，整个过程结束。

整个流程无锁，由一个线程执行，生产者和消费者协作完成任务，所以称为“协程”，而非线程的抢占式多任务。（原理：遇到I/O操作就切换，只剩下CPU操作（CPU操作非常快））

一句话总结协程的特点：子程序就是协程的一种特例。

python中支持协程的有以下两个模块：greenlet和greent

2. Greenlet

greenlet封装好的协程,利用.swith对协程操作进行手动切换


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

from greenlet import  greenlet

def test1():

    print(12)

    gr3.switch()

    print(34)

    gr2.switch()

    print(78)

def test2():

    print(56)

    gr1.switch()

def test3():

    print(90)

    gr1.switch()

gr1 = greenlet(test1)#启动协程

gr2 = greenlet(test2)

gr3 = greenlet(test3)

gr1.switch()

3. Greent

Gevent 是一个第三方库，可以轻松通过gevent实现并发同步或异步编程，在gevent中用到的主要模式是Greenlet, 它是以C扩展模块形式接入Python的轻量级协程。 Greenlet全部运行在主程序操作系统进程的内部，但它们被协作式地调度。


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

import gevent

def foo():

    print("运行foo")

    gevent.sleep(2)

    print("再次回到foo")

def bar():

    print("这里是bar")

    gevent.sleep(1)

    print("又回到了bar")

def func3():

    print("运行func3")

    gevent.sleep(0)

    print("再次运行func3")

gevent.joinall([

    gevent.spawn(foo),

    gevent.spawn(bar),

    gevent.spawn(func3)

])

同步与异步的性能区别：

1）同步：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

from gevent import monkey;

# monkey.patch_all()

import gevent

from  urllib.request import urlopen

import time

def f(url):

    print(‘GET: %s‘ % url)

    resp = urlopen(url)

    data = resp.read()

    print(‘%d bytes received from %s.‘ % (len(data), url))

urls = [ ‘https://www.python.org/‘,

         ‘https://www.yahoo.com/‘,

         ‘https://github.com/‘

         ]

time_start = time.time()

for url in urls:

    f(url)

print("同步cost",time.time() - time_start)

2）异步：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

from gevent import monkey;

# monkey.patch_all()

import gevent

from  urllib.request import urlopen

import time

def f(url):

    print(‘GET: %s‘ % url)

    resp = urlopen(url)

    data = resp.read()

    print(‘%d bytes received from %s.‘ % (len(data), url))

urls = [ ‘https://www.python.org/‘,

         ‘https://www.yahoo.com/‘,

         ‘https://github.com/‘

         ]

async_time_start = time.time()

gevent.joinall([

    gevent.spawn(f, ‘https://www.python.org/‘),

    gevent.spawn(f, ‘https://www.yahoo.com/‘),

    gevent.spawn(f, ‘https://github.com/‘),

])

print("异步cost",time.time()-async_time_start )

结论：同步开销时间为4秒，异步开销为2.5秒，大大节省了开销，这就是协程的魅力；monkey.patch_all()使gevent能识别到urllib中的I/O操作

使用gevent实现单线程下的多socket并发：

import sys
import socket
import time
import gevent

from gevent import socket,monkey
monkey.patch_all()

def server(port):
    s = socket.socket()
    s.bind((‘0.0.0.0‘, port))
    s.listen(500)
    while True:
        cli, addr = s.accept()
        gevent.spawn(handle_request, cli)

def handle_request(conn):
    try:
        while True:
            data = conn.recv(1024)
            print("recv:", data)
            conn.send(data)
            if not data:
                conn.shutdown(socket.SHUT_WR)

    except Exception as  ex:
        print(ex)
    finally:
        conn.close()
if __name__ == ‘__main__‘:
    server(8001)

import socket

HOST = ‘localhost‘    # The remote host
PORT = 8001           # The same port as used by the server
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((HOST, PORT))
while True:
    msg = bytes(input(">>:"),encoding="utf8")
    s.sendall(msg)
    data = s.recv(1024)
    #print(data)

    print(‘Received‘, repr(data))
s.close()

时间： 2024-10-29 03:42:43

学习python:day10的相关文章

学习Python随想

进入大三之后进入了一周基本都是专业课的状态,虽然相比之前几个学期课时量减少了,但实际上学要学习的任务却大大增加了,而类似于Python,spss这一类的课程是之前之前并没有听说过的,但在上过两周之后发现,Python是类似于c语言一类的课程,而之前的c语言和数据结构学得并不好,所以其实在内心深处是有一丝丝的惧怕的,希望在实践课上能多做一些类似于第一次的学打代码的联系,多找找感觉. 课堂进度十分之快,时而跟得上时而跟不上,而一旦跟不上就会跟多米诺骨牌似的,影响接下来的课堂学习.在智慧云教室最大的感

【个人计划】告别英雄联盟，开始学习Python

不知不觉中接触英雄联盟已经快两年了,记得是大四那年找完工作,一下比较清闲,宿舍刚好有lol的氛围,于是乎,四个新手在何大神的带领下,走上了lol的道路.不得不说,从那以后,花费在lol上的时间太多啦,据我估计,个人玩了将近2000了吧,别看局数这么多,其实就是个渣渣,技术太菜了,这也就是我告别英雄联盟的原因啦,根本没有玩这个游戏的天赋,技术上没有一点点提高,一直就是在浪费时间罢了. 就我个人而言,1.在补兵方面,时好时坏,而且有时候性子急,不太注重前期的补兵发育,往往导致输的结局:2.游戏中大部

学习python第一天

学习Python第一天 Python小白,做Linux运维5年,纯系统运维已经不能满足日常工作需要,所以学习Linux运维开发入门级语言python 前言: Python, 是一种面向对象.解释型计算机程序设计语言,由Guido van Rossum于1989年发明,第一个公开发行版发行于1991年. Python是纯粹的自由软件, 源代码和解释器CPython遵循 GPL(GNU General Public License)协议. Python语法简洁清晰,特色之一是强制用空白符(white

重新学习python系列(一)？ WTF？

重新学习python:两年前学了点python之后就一直没做做过啥项目, 基本上全忘光了,复习一下搞点事情 or |and & ord() ascii转16进制 chr()  16进制转ascii >>> u'ABC'.encode('utf-8') 'ABC' >>> u'中文'.encode('utf-8') '\xe4\xb8\xad\xe6\x96\x87' >>> 'abc'.decode('utf-8') u'abc' >&g

Python学习--Python基础语法

第一个Python程序 交互式编程 交互式编程不需要创建脚本文件,是通过 Python 解释器的交互模式进来编写代码. linux上你只需要在命令行中输入 Python 命令即可启动交互式编程,提示窗口如下: Window上在安装Python时已经已经安装了默认的交互式编程客户端,提示窗口如下: 在Python提示符中输入一下文本,然后按回车查看运行结果: print 'hello world'; 输出: hello world 脚本式编程 让我们来写一个简单的Python脚本,所有的Pytho

几条学习python的建议

熟悉python语言, 以及学会python的编码方式. 熟悉python库, 遇到开发任务的时候知道如何去找对应的模块. 知道如何查找和获取第三方的python库, 以应付开发任务. 学习步骤 安装开发环境 如果你在window下, 去下载pythonxy安装起来, 然后运行python, 进入python解释环境. 如果你在ubuntu下, 执行: sudo apt-get install python, 然后在命令行下运行python, 进入python解释环境. 学习方法 作为一名成熟的

鱼C《零基础入门学习Python》10-17节课时知识点总结

第10讲:列表:一个打了激素的数组 1. 列表都可以存放一些什么东西?  我们说 Python 的列表是一个打了激素的数组,如果把数组比喻成集装箱,那么 Python 的列表就是一个大仓库,Ta 可以存放我们已经学习过的任何数据类型. 2. 向列表增加元素有哪些方法?  三种方法想列表增加元素,分别是:append().extend() 和 insert().    3. append() 方法和 extend() 方法都是向列表的末尾增加元素,请问他们有什么区别?  append() 方法是将

学习python的小随笔

Python在课表中的名字是高级语言程序设计.上了两周的专业课,我想说我真的是想来学教育的,现在成了计算机了.我还想说,有没有一种可以用中文写程序的软件,有志向的大佬们赶紧弄个吧!       其实关于学习Python倒是不反感,无论是当初学习c++,还是现在学Python,都感觉这个东西挺有意思的.当你能把一个程序写出来并且运转成功之后,那种成就感是难以形容的.(哪怕是对着书敲上的)       希望老师教学中.把我们当做一个程序小白,很多老师以为学过了就精通了,可是事实不是那样.个人感觉Py

学习Python的第一课(简单的单元测试)

由于有C#开发基础,感觉学习Python应该不难,主要是一些语法了,再加上现在互联网这么发达. 感觉还是要有思路,否则学什么也只能是什么. 话不多说,简单发下这几天的学习成果吧: 第一次写博客,大家不要见笑啊 简单的语法就不多说了,随便搜搜就可以得到.() 单元测试来了: 要做两个测试: # 用于判断质数 import math def isPrime(n): print ("验证数字"+str(n)+"是否质数开始") print ("开平方:"