dday06

一. 多进程和多线程
例题

import multiprocessing

def A(conn):
    conn.send(['a','b','c','d','e'])  #发送的数据
    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_b.send([1,2,3,4,5,6,7])  #发送数据给conn_a
         print('main',conn_b.recv())
运行结果：
main ['a', 'b', 'c', 'd', 'e']
A [1, 2, 3, 4, 5, 6, 7]

2.写一个对话系统是双方面的，你可以作为一个选择A–>B,B–>A,A–>B. 类似于聊天机器人的一个对话系统。

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('别打扰我')
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)
运行结果：

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则会独立运行
 运行结果：
hello python
__mp_main__
father 16376
self 7440
--------
hello word

4.队列进程可以共享

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())  # 脚本父进程取出
  


运行结果：
25572
24976
[1, 2, 3, 4]

5.全局变量不可以进程共享

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)


运行结果：
main 18400 ['a', 'b', 'c']
p 25660 [1, 2, 3]

6.进程通信

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())


运行结果：
func 16084 [1, 2, 3, 4, 5, 6, 7]
mian 16708 ['a', 'b', 'c', 'd', 'e']

7.进程字典列表共享

import multiprocessing
def func(mydict, mylist):
    mydict["毛毛"] = "牛皮"
    mydict["l毛毛"] = "大美女"
    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

运行结果：
[0, 1, 2, 3, 4, 11, 22, 33]
{'毛毛': '大美女'}

8.进程数组列表数组共享

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[:])
    运行结果:
    [1, 2, 3, 4, 5, 6]
    [1, 2, 9999, 4, 5, 6]

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

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

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

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

import requests
import threading
import re

class maoyan_top500(threading.Thread):
    def __init__(self, start_, end_,lock):
        threading.Thread.__init__(self)
        self.headers = {
            'User-Agent':
            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.100 Safari/537.36'
        }
        self.base_url = 'https://maoyan.com/board/4?offset=%d'
        self.start_ = start_
        self.end_ = end_
        self.lock = lock

    def run(self):
        for offset in range(self.start_, self.end_, 10):
            url = self.base_url % offset
            response = requests.get(url, headers=self.headers)
            html = response.text
            info_list = self.get_Information(html)
            with self.lock:
                self.write(info_list)
            print('offset {} OK !'.format(offset))

    def get_Information(self, html):
        information_list = []
        for line in html.split('\n'):
            if 'class="image-link"' in line:
                movie_name = line.split('title="')[1].split('"')[0]
                information_list.append(movie_name)
            if 'class="integer"' in line:
                res = re.search(
                    '<p class="score"><i class="integer">(\d\.)</i><i class="fraction">(\d)</i></p>',
                    line)
                integer = res.group(1)
                fraction = res.group(2)
                score = integer + fraction
                information_list.append(score)

        return information_list
    
    def write(self,info_list):
        str_ = str(info_list) + '\n'
        with open('res.txt',mode='a',encoding='utf8') as file:
            file.write(str_)

if __name__ == "__main__":
    threads = []
    lock = threading.Lock()
    for i in range(2):
        t = maoyan_top500(start_=i * 50, end_=(i + 1) * 50,lock=lock)
        t.start()
        threads.append(t)
    for t in threads:
        t.join()

    print('Over')