学习python的第六天

最新推荐文章于 2022-11-10 00:08:35 发布

gghhmm001

最新推荐文章于 2022-11-10 00:08:35 发布

阅读量62

点赞数

本文链接：https://blog.csdn.net/gghhmm001/article/details/99986929

版权

一、python的知识点总结
1.进程通信

#进程通信
import multiprocessing
import os

def func(conn):#conn表示管道类型
    conn.send(['a','b','c','d','e'])#发送的数据
    print('func',os.getpid(),conn.recv())#收到的数据
    conn.close()#关闭

if __name__=="__main__":
    conn_a,conn_b = multiprocessing.Pipe()#创建一个管道，有两个口
    #print(id(conn_a),id(conn_b))
    #print(type(conn_a),type(conn_b))#multiprocessing.connection.Connection
    #相当于在进程中conn_a.send(['a','b','c','d','e']),发送给conn_b
    p = multiprocessing.Process(target=func,args=(conn_a,)).start()
    conn_b.send([1,2,3,4,5,6,7])#发送数据给conn_a
    print('mian',os.getpid(),conn_b.recv())

2.接收发送信息

import multiprocessing
def A(conn):
    print('A',conn.recv())#收到信息
    #conn.close() #关闭
if __name__=="__main__":
    conn_a,conn_b = multiprocessing.Pipe()
    p = multiprocessing.Process(target=A,args=(conn_a,))
    p.start()
    while 1:
        input_ = input('>>')
        conn_b.send(input_)#发送信息给conn_a
        #print('mian',conn_b.recv())

3.类似于聊天机器人的一个对话系统

import os
import multiprocessing

def M(conn):
    while 1:
        recv_=conn.recv()
        print('机器人收到：%s'%recv_)
        if recv_=="你好":
            conn.send('我不好~')
        elif recv_=="今天天气怎么样":
            conn.send('请问你的手机助手，我不知道')
        elif recv_=="我美吗":
            conn.send('心里没点比数吗？还要问我？')
        else:
            conn.send('SB,老子正在学习，别打扰我！')
def P(conn):
    y = 'y'
    while y != 'n':
        input_=input('人说:')
        conn.send(input_)
        os.system('say %s'%conn.recv())
if __name__=="__main__":
    conn_M,conn_P =multiprocessing.Pipe()
    p_M = multiprocessing.Process(target=M,args=(conn_M,))
    p_M.start()
    P(conn_P)

4.multiprocessing

import multiprocessing
import os


def info(title):
    print(title)
    print(__name__)
    print('father', os.getppid())
    print('self', os.getpid())
    print('--------')



if __name__ == "__main__": # 除了创建的子进程和子进程调用函数，其他的都是脚本主进程
    # info('hello')
    # 创建一个子进程调用函数
    P = multiprocessing.Process(target=info,args=('hello python',))
    P.start()
    P.join() # 和多线程一样，也是等待的意思
    print('hello word') # 若没有join则会独立运行

5.join

import multiprocessing
import os
import time


def info(title):
    print(title)
    time.sleep(2)
    print(__name__)
    print('father', os.getppid())
    print('self', os.getpid())
    print('--------')


if __name__ == "__main__":
    p1 = multiprocessing.Process(target=info,args=('A1',))
    p2 = multiprocessing.Process(target=info, args=('A2',))
    p3 = multiprocessing.Process(target=info, args=('A3',))
    p1.start()
    p2.start()
    p3.start()
    p1.join()
    p2.join()
    p3.join()
    # 这里的join只是为了卡住主进程，使得三个进程都执行完毕再执行print
    # 这里很重要，以后多进程扫描文件需要完全等待几个进程全部执行完毕在汇总
    print('all over')
    '''
    轮流执行
    p1.start()
    p1.join()
    p2.start()
    p2.join()
    p3.start()
    p3.join()

6.创建锁

#进程同步
import os
import multiprocessing
import time


#多进程，并发，可能乱序并发执行（主要看系统如何处理）
#多进程加锁，挨个执行,也可能是乱序

def showdata(lock, i):
    with lock:
        print(multiprocessing.current_process().name)
        time.sleep(2)
        print(i)


if __name__ == "__main__":
    lock = multiprocessing.RLock()  # 创建锁
    for num in range(10):
        multiprocessing.Process(target=showdata, args=(lock, num)).start()

7.pipe

# 进程通信
import multiprocessing
import os


def func(conn):  # conn表示管道类型
    print('func',os.getpid(), conn.recv())  # 收到的数据
    conn.send(['a', 'b', 'c', 'd', 'e'])  # 发送的数据
    conn.close()  # 关闭

if __name__ == "__main__":
    conn_a, conn_b = multiprocessing.Pipe()  # 创建一个管道，有两个口

    # print(id(conn_a),id(conn_b))
    # print(type(conn_a), type(conn_b)) #multiprocessing.connection.Connection链接，意思就是连接口

    # 相当于在进程中conn_a.send(['a','b','c','d','e'])，发送给conn_b
    p = multiprocessing.Process(target=func, args=(conn_a,)).start()
    conn_b.send([1, 2, 3, 4, 5, 6, 7])  # 发送数据给conn_a
    print('mian',os.getpid(), conn_b.recv())

8.share

# 全局变量不可以进程共享
import multiprocessing
import os
data = []

def List():
    global data
    data.append(1)
    data.append(2)
    data.append(3)
    print('p',os.getpid(),data)


if __name__ == '__main__':
    p = multiprocessing.Process(target=List,args=()).start()  # 子进程
    data.append('a')  # 脚本主进程
    data.append('b')
    data.append('c')
    print('main',os.getpid(),data)

    '''
    全局变量不共享
    1809 ['a', 'b', 'c']
    1810 [1, 2, 3]

9.queue

# 队列可以进程共享

import multiprocessing
import os

queue = multiprocessing.Queue()
# 注意队列只能单向，要么是父进程插入子进程取出，要么是子进程插入父进程取出

def func(myq):
    print(os.getpid())
    myq.put([1, 2, 3, 4])  # 子进程插入


if __name__ == '__main__':
    print(os.getpid())
    # queue.put(['a','b'])  # 这里若是脚本父进程先插入了，子进程就没法再插入了
    p = multiprocessing.Process(target=func, args=(queue,))
    p.start()
    print(queue.get())  # 脚本父进程取出

10.queueplus

import multiprocessing
import os

queue = multiprocessing.Queue()


def adddata(queue, i):  # 子进程调用的函数
    queue.put(i)
    print('put', os.getppid(), os.getpid(), i)


if __name__ == '__main__':  # 脚本父进程
    mylist = []
    for i in range(10):
        p = multiprocessing.Process(target=adddata, args=(queue, i))  # 子进程
        p.start()
        # print(queue.get())
        mylist.append(queue.get())  # get拿不到东西会一直等待

11.进程数据共享

import multiprocessing


def func(num):
    num.value = 10


if __name__ == '__main__':
    # multiprocessing.Value可以在不同进程之间共享数据
    num = multiprocessing.Value('d', 1)  # double float
    print(num.value)  # 单单num返回的结果 Synchronized wrapper for c_double(1.0)
    p = multiprocessing.Process(target=func, args=(num,))
    p.start()
    p.join()
    print(num.value)

12.进程列表数组共享

import multiprocessing


def func(num):
    num[2] = 9999


if __name__ == '__main__':
    # 不同进程之间实现数组共享
    num = multiprocessing.Array('i', [1, 2, 3, 4, 5, 6])  # i代表int类型
    print(num[:])
    p = multiprocessing.Process(target=func, args=(num,))
    p.start()
    p.join()
    print(num[:])

13.进程字典列表共享

import multiprocessing


def func(mydict, mylist):
    mydict["胡旺"] = "牛皮"
    mydict["lalal"] = "大美女"
    mylist.append(11)
    mylist.append(22)
    mylist.append(33)


if __name__ == "__main__":
    # with multiprocessing.Manager() as MG:
    #     mydict=MG.dict()
    #     mylist=MG.list(range(5))
    mydict = multiprocessing.Manager().dict()
                                        # [0,1,2,3,4]
    mylist = multiprocessing.Manager().list(range(5))

    p = multiprocessing.Process(target=func, args=(mydict, mylist))
    p.start()
    p.join()

    print(mylist)
    print(mydict)
# print(list(range(5)))  # 很牛逼的list

14.Queue对象
（1）Queue.qsize():返回队列的大致大小。注意，qsize() > 0 不保证后续的 get() 不被阻塞，qsize() < maxsize 也不保证 put() 不被阻塞。

（2）Queue.empty():如果队列为空，返回 True ，否则返回 False 。如果 empty() 返回 True ，不保证后续调用的 put() 不被阻塞。类似的，如果 empty() 返回 False ，也不保证后续调用的 get() 不被阻塞。

（3）Queue.full():如果队列是满的返回 True ，否则返回 False 。如果 full() 返回 True 不保证后续调用的 get() 不被阻塞。类似的，如果 full() 返回 False 也不保证后续调用的 put() 不被阻塞。

（4）Queue.put(item, block=True, timeout=None)：将 item 放入队列。如果可选参数 block 是 true 并且 timeout 是 None (默认)，则在必要时阻塞至有空闲插槽可用。如果 timeout 是个正数，将最多阻塞 timeout 秒，如果在这段时间没有可用的空闲插槽，将引发 Full 异常。反之 (block 是 false)，如果空闲插槽立即可用，则把 item 放入队列，否则引发 Full 异常 ( 在这种情况下，timeout 将被忽略)。

（5）Queue.get(block=True, timeout=None)：从队列中移除并返回一个项目。如果可选参数 block 是 true 并且 timeout 是 None (默认值)，则在必要时阻塞至项目可得到。如果 timeout 是个正数，将最多阻塞 timeout 秒，如果在这段时间内项目不能得到，将引发 Empty 异常。反之 (block 是 false) , 如果一个项目立即可得到，则返回一个项目，否则引发 Empty 异常 (这种情况下，timeout 将被忽略)。

（6）Queue.join()：阻塞至队列中所有的元素都被接收和处理完毕。
当条目添加到队列的时候，未完成任务的计数就会增加。每当消费者线程调用 task_done() 表示这个条目已经被回收，该条目所有工作已经完成，未完成计数就会减少。当未完成计数降到零的时候， join() 阻塞被解除。

gghhmm001

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
学习python的第六天

一、python的知识点总结1.进程通信#进程通信import multiprocessingimport osdef func(conn):#conn表示管道类型 conn.send(['a','b','c','d','e'])#发送的数据 print('func',os.getpid(),conn.recv())#收到的数据 conn.close()#关闭...
复制链接

扫一扫