python爬虫学习之———进程

最新推荐文章于 2020-10-30 23:23:31 发布

齐文龙

最新推荐文章于 2020-10-30 23:23:31 发布

阅读量231

点赞数 1

本文链接：https://blog.csdn.net/weixin_44539415/article/details/89318553

版权

python中多进程

一、概念

进程是os(操作系统)中概念，在某一程序任务组（启动时）由os分配的内存、进程控制状态块等相关资源，之后在进程中创建线程，来执行code.
一般情况下。京城由三部分组成：内存、程序code、进程控制块（进程id，进程的状态描述）。如在Linux操作系统下，执行ps命令，查看所有的进程运行状态。在window下，可以通过任务管理器来查看当前系统下的所有进程。

在python创建进程的方式有三种：

os.fork()只针对Linux系统的，在window/Linux下可以使用multiprocessing模块。
os.system() 执行os的命令，如pwd,ps,top,free,awk
os.popen() 执行os的命令，但是以字节流的方式读取执行的结果。os.system（）只执行命令，没办法读取执行结果。

os 与 sys 的区别
os 是操作系统（python os模块是程序与操作系统的交互）
sys 是python系统的解析器

二、进程的生命周期

整个进程的生命周期由五个状态（过程），分别是创建、就绪、运行、阻塞、结束。

三、Python程序的应用

3.1. os.multiprocessing模块

创建和运行进程

import multiprocessing
import os
import random
import string
import time

def generate_key():
    """
    每隔一秒钟生产一个6位由数字、大小写字母组成的key
    并写入到keystore.keys文件中
    :return:
    """
    characters = list(range(ord('0'),ord('9'))) + \
                 list(range(ord('a'),ord('z'))) + \
                 list(range(ord('A'),ord('Z')))
    characters = [chr(code) for code in characters]
    cs = ''.join([random.choice(characters) for _ in range(6)])
    """
    cs = ''.join(random.sample(string.ascii_letters+string.digits,6))
    一个简单的产生6位随机字母数字组合   
    string.ascii_letters 为所有的大小写  string.digits 为所有的数字
    """
    return cs

def new_keys():
    while True:
        key = generate_key()
        # 获取当前函数执行时，所在的进程信息
        current_process = multiprocessing.current_process()

        # 进程的信息（进程的id，父进程，进程的状态）
        pid = current_process.pid  # 进程id   os.getpid() 也可以
        ppid = os.getppid()  # 父进程的id
        print('%s in %s' % (pid, ppid), time.strftime('%d %H:%M:%S',time.localtime()),key)
        # 写入到keystore.keys文件
        with open('keystore.keys','a') as file:
            file.write(key + '\n')
        time.sleep(1)


if __name__ == '__main__':
    # new_keys()  # 将这个函数（任务、功能、程序）,放在（子）进程中执行
    # 1. 创建（子）进程
    # process = multiprocessing.Process(target=new_keys) # 启动一个进程
    process_list =[ multiprocessing.Process(target=new_keys) for _ in range(3)]
    # 启动多个进程
    # 2. 启动进程
    for process in process_list:
        process.start()   # 异步操作之后，当前的程序不会阻塞，则会继续向下执行
    print('----正在生成----')  # 会先执行当前（父进程）的函数

启动时的传参

在创建进程类 Process对象时，通过_init_()初始化参数中 target来指定进程执行的程序（函数对象），在通过args或者kwargs来制定程序（函数）需要的数据（参数）。

# coding:utf-8
"""
创建 Process 时为 target目标函数提供参数
任务： 由子进程完成keystore.keys文件的读取，每隔一秒读取一次
"""
from multiprocessing import Process
import os
import time


def read_key(filepath: str, timedelta: float) -> None:
    with open(filepath, 'r',encoding='utf-8') as file:
        # 文件对象可以被迭代的  (可解决大文件一行一行的读取)
        for line in file:
            print(os.getppid(), line, end='')
            time.sleep(timedelta)
    print('%s读取完成' % filepath)


if __name__ == '__main__':
    # read_key('keystore.keys',0.1)
    # process = Process(target=read_key, args=('keystore.keys', 0.3))
    # process.start()
    # process.join()  # 等待子进程执行完 才会进行主进程  会发生阻塞，直到子进程执行完

    files = (('keystore.keys', 0.1), ('process_01.py', 0.2))
    # 批量创建进程
    process_list = [Process(target=read_key,
                            kwargs={'filepath': filepath, 'timedelta': timedelta})
                    for filepath, timedelta in files]
    # {'filepath':filepath, 'timedelta':timedelta} == (filepath=filepath, timedelta=timedelta)

    # 批量启动
    for process in process_list:
        process.start()
    # 批量等待进程结束
    for process in process_list:
        process.join()
    print('-----over-----')

多进程的通信【重点】
场景：
在高并发情况下，一个任务可能需要多个进程进行协作，如下载进程专门负责下载资源的功能，解析进程专门负责解析或提取网页中的数据（感兴趣的数据），数据处理的进程负责解析之后的数据存储，图片下载，数据预处理等工作。
前提：
由于进程和进程之间是相互独立的，也就是说一个进程的内存空间是独立的，当某一个进程因为程序的原因导致进程崩溃，不会影响其他的进程。

四种进程间通信的方式

进程之间的通信方式一般有四种情况：

Pipe管道
管道的方式又分为半双工和全双工管道，半双工即是一段只能收，另一端只能发。全双工是两段都可以发和收；

半双工：（一个只能发，一个只能收）

# coding:utf-8
"""
基于Pipe的进程通信
1） 半双工
2） 全双工
"""
import time
from multiprocessing import Process, Pipe
import os


def download(conn):
    # 从conn中读取下载的任务
    while True:
        # 从管道中接收数据
        url = conn.recv()  # receive() 接收数据
        if url == 'over':
            break
        print(os.getppid(),url)


def start_requests(conn):
    # 通过conn发布下载的任务
    for url in ('http://www.baidu.com',
                'http://www.hao123.com',
                'http://www.qq.com'):
        conn.send(url)
        print(os.getppid(),"发布",url)
        time.sleep(1)
    conn.send('over')   # 告诉接收方发送完毕

if __name__ == '__main__':
    # duplex 表示是否为全双工，False表示半双工 True表示为全双工
    # conn1 只收
    # conn2 只发
    conn1, conn2 = Pipe(duplex=False)

    # 创建发布下载任务的进程
    publisher = Process(target=start_requests,args=(conn2,))

    # 创建接收下载任务的进程
    process = Process(target=download,args=(conn1,))
    publisher.start()
    process.start()

    publisher.join()
    process.join()

    print('----over----')

全双工：（可发可收）

# coding:utf8
"""
基于Pipe的进程通信
1） 全双工
"""
import time
from multiprocessing import Process, Pipe
import os


def download(conn):
    # 从conn中读取下载的任务
    # 当下载完成后，将数据返回给conn连接的管道
    while True:
        # 从管道中接收数据
        url = conn.recv()  # receive() 接收数据
        if url == 'over':
            break

        print(os.getpid(),"接收下载任务",url)
        time.sleep(3)  # 模拟下载的时间
        print(os.getpid(), "下载任务完成", url)
        conn.send('%s->%s:%s'%(os.getppid(),'下载任务完成',url))


def start_requests(conn):
    # 通过conn发布下载的任务
    for url in ('http://www.baidu.com',
                'http://www.hao123.com',
                'http://www.qq.com'):
        conn.send(url)  # 发送数据
        print(os.getpid(),"发布",url)
        data = conn.recv()  # 接收下载完成后的数据
        print(os.getpid(),"接收到的数据",data)
    conn.send('over')   # 告诉接收方发送完毕

if __name__ == '__main__':
    # duplex 表示是否为全双工，False表示半双工 True表示为全双工
    conn1, conn2 = Pipe(duplex=True)

    # 创建发布下载任务的进程
    publisher = Process(target=start_requests,args=(conn2,))

    # 创建接收下载任务的进程
    process = Process(target=download,args=(conn1,))
    publisher.start()
    process.start()

    publisher.join()
    process.join()

    print('----over----')

Queue 队列
队列本身是阻塞的，可以发布和读取可能会出现阻塞。

# coding:utf-8
"""
基于Queue队列实现进程间通信
Queue对象常用的方法：
put(value) 存放数据
value = get()  读取数据
empty()  是否为空
qsize    当前队列的大小
"""
import os
import time
import random
from multiprocessing import Process
from multiprocessing import Queue


def start_requests(queue: Queue):
    # 模拟某一网页的入口url,下载数据，
    urls = ['http://www.baidu.com/s=%s&t=%s' % (os.getpid(), time.localtime())
            for _ in range(10000) if _ % 1000 == 0]

    for url in urls:
        data = random.choices(['a', 'b', 'c', 'd', 'g', 'y', 'e', 'q'], k=2)
        # 向 queue 中存放数据
        queue.put((url, data))
        time.sleep(0.5)


def parse(queue:Queue):
    # 从Queue中读取响应的数据，并进行解析
    try:
        while True:
            url,data = queue.get(timeout=2)  # 读取数据超时情况下会抛出异常   超时时间为2秒
            print(os.getpid(),'开始解析',url,data)
            time.sleep(0.3)
    except:
        print(os.getpid(),'任务完成')


if __name__ == '__main__':
    # 创建Queue对象
    queue = Queue(maxsize=100)

    # 创建两个进程（下载任务）
    downloads = [Process(target=start_requests, args=(queue,))
                 for _ in range(2)]
    # 创建三个解析进程
    parses = [Process(target=parse, args=(queue,))
              for _ in range(3)]

    for process in downloads + parses:
        process.start()
    for process in downloads + parses:
        process.join()

    print('----over----')

共享内存 Manager
由c语言实现的功能，系统本身会在内存区域中分出一个共享区域，实现多进程之间通信
信号或Socket
如果是在Linux中，使用socket模块中socket.AF_UNIX方式绑定或连接一个.socket文件实现进程间通信

# coding:utf-8
"""
基于Socket实现进程间通信（Lnuix系统）
# 要求：通过.socket文件实现的
"""

from multiprocessing import Process
import socket
import os
import time


def download(url, socket_filepath):
    print(os.getpid(),'start request',url)
    time.sleep(10)
    data = '%s:%s'%(url,'<html><h1>hi</h1></html>')

    # 将data数据写入socket中，传递给parser进程
    s = socket.socket(socket.AF_UNIX)

    # 直到 socket_filepath文件存在为止
    while not os.path.exists(socket_filepath):
        pass
    s.connect(socket_filepath)
    # 将数据写入socket中
    s.send(data.encode())
    print(os.getpid(),'---发送数据成功---')


def parse(socket_filepath):
    s = socket.socket(socket.AF_UNIX)
    if os.path.exists(socket_filepath):
        os.remove(socket_filepath)
    s.bind(socket_filepath)  # 绑定socket文件
    s.listen(6)
    c,address= s.accept() # 等待连接
    data = c.recv(1024)  #接收连接进程的数据
    print(os.getpid(),data)


if __name__ == '__main__':
    # 指定两个进程间通信的socket文件
    socket_file = 'process5.socket'
    downloader = Process(target=download, args=('http://www.baidu.com', socket_file))

    parser = Process(target=parse,
                     args=(socket_file,))
    downloader.start()
    parser.start()

    downloader.join()
    parser.join()

    print(os.getpid(), '----over----')

windows

# coding:utf-8
"""
基于Socket实现进程间通信（windows）
要求：通过(ip ,port) 网络通信
"""

from multiprocessing import Process
import socket
import os
import time


def download(url, port):
    print(os.getpid(),'start request',url)
    time.sleep(2)
    data = '%s:%s'%(url,'<html><h1>hi</h1></html>')

    # 将data数据写入socket中，传递给parser进程
    s = socket.socket()

    s.connect(('localhost',port))
    # 将数据写入socket中
    s.send(data.encode())
    print(os.getpid(),'---发送数据成功---')


def parse(port):
    s = socket.socket()
    s.bind(('',port))  # 绑定ip ,与端口   ‘’意思是绑定运行本程序的系统ip
    s.listen(6)
    c,address= s.accept() # 等待连接
    data = c.recv(1024*8)  #接收连接进程的数据
    print(os.getpid(),data)


if __name__ == '__main__':

    downloader = Process(target=download, args=('http://www.baidu.com', 8999))

    parser = Process(target=parse,
                     args=(8999,))
    downloader.start()
    parser.start()

    downloader.join()
    parser.join()

    print(os.getpid(), '----over----')

总结一下socket的用法如下：
1、用于进程间通信（Process - Process）
使用socket文件
2、用于网络间通信（client-server）
使用（ip,port）
socket的使用步骤，分客户端和服务端，详情如下：
1.Server端

创建socket-socket（socket.AF_INET/AF_UNIX）
绑定（ip，port）或者socket文件-bind（）
监听-listen（）
获取客户端信息client, address = service.accept()
等待客户端的连接对象进行通信
client.recv(8192) 接收数据
client.send()发送数据
关闭连接

client.close（）
2.Client端

创建socket
连接服务器（ip，port）或者socket-connect()
通过连接的socket可以和服务端通信

s.send() 发送数据
s.recv() 接收数据

关闭连接

s.close()

3.2. os.system()函数
主要用于Python的程序执行操作系统命令的，如开启视频转换功能、开启定时爬虫任务等。和os.popen()函数不同之处在于，只执行操作系统的命令，而不获取命令执行的结果。

"""
使用os.system来执行操作系统的命令
创建子进程来执行的OS的命令
通过sys.argv来接收命令行中的参数
"""

import os
import sys

if __name__ == '__main__':
    # 来读取命令行的参数
    """
    命令行格式：
       >python os_system.py filepath 
    """
    argvs = sys.argv
    # print(argvs)
    if len(argvs) <= 1:
        raise Exception("必须指定文件名")  # 抛出异常  终结当前程序的执行
    filepath = argvs[1]
    # Linux命令统计文件的行数 cat ../Day01/keystore.keys | wc -l
    # os.system('cat %s |wc -l' % filepath)
    os.system('notepad %s'%filepath)  # 将文件使用记事本打开
    # os.system('li -la ../')

3.3. os.popen()函数
案例需求：读取服务器下可用的docker images,并将读取的结果写入到csv文件中。
实现步骤：
1.cmd = os.popen(‘docker images’) 需要装 docker
2.result = cmd.read() 读取结果
3.将读取的结果的标题（第一行）作为csv文件的标题
4.将剩余的数据写入到csv文件

"""
通过os.popen() 实现与操作系统进行交互
使用场景如下：
-远程启动或关闭服务
-远程获取服务的资源
"""
import csv
import os


if __name__ == '__main__':
    # 1. 执行os命令
    cmd = os.popen('docker images')  
    file = open('images.csv','w')

    # 2. 读取命令执行的结果
    result = cmd.read()
    result = result.split('\n')
    titles = result[0].split()

    print(titles)
    writer = csv.DictWriter(file,fieldnames=titles)
    writer.writeheader() # 写入标题  （第一次）
    for line in result[1:]:
        row = line.split()
        if len(row) < 6:  # 考虑到最后一行没有数据  就不打断
            continue
        writer.writerow({
            'REPOSITORY':row[0],
            'TAG':row[1],
            'IMAGE':row[2],
            'ID':row[3],
            'CREATED':row[4]+' '+row[5],
            'SIZE':row[6]
        })

齐文龙

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
python爬虫学习之———进程

python中多进程一、概念进程是os(操作系统)中概念，在某一程序任务组（启动时）由os分配的内存、进程控制状态块等相关资源，之后在进程中创建线程，来执行code.一般情况下。京城由三部分组成：内存、程序code、进程控制块（进程id，进程的状态描述）。如在Linux操作系统下，执行ps命令，查看所有的进程运行状态。在window下，可以通过任务管理器来查看当前系统下的所有进程。在pyt...
复制链接

扫一扫