Python爬虫案例演示:Python多线程、多进程、协程

很多时候我们写了一个爬虫,实现了需求后会发现了很多值得改进的地方,其中很重要的一点就是爬取速度。本文 就通过代码讲解如何使用 多进程、多线程、协程 来提升爬取速度。注意:我们不深入介绍理论和原理,一切都在代码中。

二、同步

首先我们写一个简化的爬虫,对各个功能细分,有意识进行函数式编程。下面代码的目的是访问300次百度页面并返回状态码,其中 parse_1 函数可以设定循环次数,每次循环将当前循环数(从0开始)和url传入 parse_2 函数。

import requests

def parse_1():    url = ‘https://www.baidu.com‘    for i in range(300):        parse_2(url)

def parse_2(url):    response = requests.get(url)    print(response.status_code)

if __name__ == ‘__main__‘:    parse_1()

性能的消耗主要在IO请求中,当单进程单线程模式下请求URL时必然会引起等待

示例代码就是典型的串行逻辑, parse_1 将url和循环数传递给 parse_2 , parse_2 请求并返回状态码后 parse_1 继续迭代一次,重复之前步骤

三、多线程

因为CPU在执行程序时每个时间刻度上只会存在一个线程,因此多线程实际上提高了进程的使用率从而提高了CPU的使用率

实现多线程的库有很多,这里用 concurrent.futures 中的 ThreadPoolExecutor 来演示。介绍 ThreadPoolExecutor 库是因为它相比其他库代码更简洁

为了方便说明问题,下面代码中如果是新增加的部分,代码行前会加上 > 符号便于观察说明问题,实际运行需要去掉

import requests> from concurrent.futures import ThreadPoolExecutor

def parse_1():    url = ‘https://www.baidu.com‘    # 建立线程池    > pool = ThreadPoolExecutor(6)    for i in range(300):        > pool.submit(parse_2, url)    > pool.shutdown(wait=True)

def parse_2(url):    response = requests.get(url)    print(response.status_code)

if __name__ == ‘__main__‘:    parse_1()

跟同步相对的就是 异步 。异步就是彼此独立,在等待某事件的过程中继续做自己的事,不需要等待这一事件完成后再工作。线程就是实现异步的一个方式,也就是说多线程是异步处理异步就意味着不知道处理结果,有时候我们需要了解处理结果,就可以采用 回调

import requestsfrom concurrent.futures import ThreadPoolExecutor

# 增加回调函数> def callback(future):    > print(future.result())

def parse_1():    url = ‘https://www.baidu.com‘    pool = ThreadPoolExecutor(6)    for i in range(300):        > results = pool.submit(parse_2, url)        # 回调的关键步骤        > results.add_done_callback(callback)    pool.shutdown(wait=True)

def parse_2(url):    response = requests.get(url)    print(response.status_code)

if __name__ == ‘__main__‘:    parse_1()

P ython实现多线程有一个无数人诟病的 GIL(全局解释器锁) ,但多线程对于爬取网页这种多数属于IO密集型的任务依旧很合适。

四、多进程

多进程用两个方法实现: ProcessPoolExecutor 和 multiprocessing

1. ProcessPoolExecutor

和实现多线程的 ThreadPoolExecutor 类似

import requests> from concurrent.futures import ProcessPoolExecutor

def parse_1():    url = ‘https://www.baidu.com‘    # 建立线程池    > pool = ProcessPoolExecutor(6)    for i in range(300):        > pool.submit(parse_2, url)    > pool.shutdown(wait=True)

def parse_2(url):    response = requests.get(url)    print(response.status_code)

if __name__ == ‘__main__‘:    parse_1()

可以看到改动了两次类名,代码依旧很简洁,同理也可以添加 回调 函数

import requestsfrom concurrent.futures import ProcessPoolExecutor

> def callback(future):    > print(future.result())

def parse_1():    url = ‘https://www.baidu.com‘    pool = ProcessPoolExecutor(6)    for i in range(300):        > results = pool.submit(parse_2, url)        > results.add_done_callback(callback)    pool.shutdown(wait=True)

def parse_2(url):    response = requests.get(url)    print(response.status_code)

if __name__ == ‘__main__‘:    parse_1()

2. multiprocessing

直接看代码,一切都在注释中。

import requests> from multiprocessing import Pool

def parse_1():    url = ‘https://www.baidu.com‘    # 建池    > pool = Pool(processes=5)    # 存放结果    > res_lst = []    for i in range(300):        # 把任务加入池中        > res = pool.apply_async(func=parse_2, args=(url,))        # 获取完成的结果(需要取出)        > res_lst.append(res)    # 存放最终结果(也可以直接存储或者print)    > good_res_lst = []    > for res in res_lst:        # 利用get获取处理后的结果        > good_res = res.get()        # 判断结果的好坏        > if good_res:            > good_res_lst.append(good_res)    # 关闭和等待完成    > pool.close()    > pool.join()

def parse_2(url):    response = requests.get(url)    print(response.status_code)

if __name__ == ‘__main__‘:    parse_1()

可以看到 multiprocessing 库的代码稍繁琐,但支持更多的拓展。 多进程和多线程确实能够达到加速的目的,但如果遇到IO阻塞会出现线程或者进程的浪费 ,因此有一个更好的方法……

五、异步非阻塞

协程+回调 配合动态协作就可以达到异步非阻塞的目的,本质只用了一个线程,所以很大程度利用了资源

实现异步非阻塞经典是利用 asyncio 库+ yield ,为了方便利用逐渐出现了更上层的封装 aiohttp ,要想更好的理解异步非阻塞最好还是深入了解 asyncio 库。而 gevent 是一个非常方便实现协程的库

import requests> from gevent import monkey# 猴子补丁是协作运行的灵魂> monkey.patch_all()> import gevent

def parse_1():    url = ‘https://www.baidu.com‘    # 建立任务列表    > tasks_list = []    for i in range(300):        > task = gevent.spawn(parse_2, url)        > tasks_list.append(task)    > gevent.joinall(tasks_list)

def parse_2(url):    response = requests.get(url)    print(response.status_code)

if __name__ == ‘__main__‘:    parse_1()

gevent能很大提速,也引入了新的问题: 如果我们不想速度太快给服务器造成太大负担怎么办? 如果是多进程多线程的建池方法,可以控制池内数量。如果用gevent想要控制速度也有一个不错的方法: 建立队列。 gevent中也提供了 Quene类 ,下面代码改动较大

import requestsfrom gevent import monkeymonkey.patch_all()import gevent> from gevent.queue import Queue

def parse_1():    url = ‘https://www.baidu.com‘    tasks_list = []    # 实例化队列    > quene = Queue()    for i in range(300):        # 全部url压入队列        > quene.put_nowait(url)    # 两路队列    > for _ in range(2):        > task = gevent.spawn(parse_2)        > tasks_list.append(task)    gevent.joinall(tasks_list)

# 不需要传入参数,都在队列中> def parse_2():    # 循环判断队列是否为空    > while not quene.empty():        # 弹出队列        > url = quene.get_nowait()        response = requests.get(url)        # 判断队列状态        > print(quene.qsize(), response.status_code)

if __name__ == ‘__main__‘:    parse_1()

结束语

以上就是几种常用的加速方法。如果对代码测试感兴趣可以利用time模块判断运行时间。爬虫的加速是重要技能,但适当控制速度也是爬虫工作者的良好习惯,不要给服务器太大压力,拜拜~

原文地址:https://www.cnblogs.com/7758520lzy/p/12653541.html

时间: 2024-11-01 23:20:00

Python爬虫案例演示:Python多线程、多进程、协程的相关文章

多线程 多进程 协程 Queue(爬虫代码)

快速理解多进程与多线程以及协程的使用场合和特点 首先我们来了解下python中的进程,线程以及协程! 从计算机硬件角度: 计算机的核心是CPU,承担了所有的计算任务.一个CPU,在一个时间切片里只能运行一个程序. 从操作系统的角度: 进程和线程,都是一种CPU的执行单元. 进程:表示一个程序的上下文执行活动(打开.执行.保存...) 线程:进程执行程序时候的最小调度单位(执行a,执行b...) 一个程序至少有一个进程,一个进程至少有一个线程. 并行 和 并发: 并行:多个CPU核心,不同的程序就

多线程/多进程/协程

占用的资源:进程>线程>协程 进程:先加载程序A的上下文,然后开始执行A,保存程序A的上下文,调入下一个要执行的程序B的程序上下文,然后开始执行B,保存程序B的上下文 进程的颗粒度太大,每次都要有上下的调入,保存,调出. 线程:一个软件的执行不可能是一条逻辑执行的,必定有多个分支和多个程序段,就好比要实现程序A,实际分成 a,b,c等多个块组合而成:这里的a,b,c就是线程,也就是说线程是共享了进程的上下文环境,的更为细小的CPU时间段 https://www.zhihu.com/questi

Python爬虫进阶五之多线程的用法

前言 我们之前写的爬虫都是单个线程的?这怎么够?一旦一个地方卡到不动了,那不就永远等待下去了?为此我们可以使用多线程或者多进程来处理. 首先声明一点! 多线程和多进程是不一样的!一个是 thread 库,一个是 multiprocessing 库.而多线程 thread 在 Python 里面被称作鸡肋的存在!而没错!本节介绍的是就是这个库 thread. 不建议你用这个,不过还是介绍下了,如果想看可以看看下面,不想浪费时间直接看 multiprocessing 多进程 鸡肋点 名言: "Pyt

Python 中的进程、线程、协程、同步、异步、回调

进程和线程究竟是什么东西?传统网络服务模型是如何工作的?协程和线程的关系和区别有哪些?IO过程在什么时间发生? 在刚刚结束的 PyCon2014 上海站,来自七牛云存储的 Python 高级工程师许智翔带来了关于 Python 的分享<Python中的进程.线程.协程.同步.异步.回调>. 一.上下文切换技术 简述 在进一步之前,让我们先回顾一下各种上下文切换技术. 不过首先说明一点术语.当我们说"上下文"的时候,指的是程序在执行中的一个状态.通常我们会用调用栈来表示这个状

Python快速学习第十二天--生成器和协程

yield指令,可以暂停一个函数并返回中间结果.使用该指令的函数将保存执行环境,并且在必要时恢复. 生成器比迭代器更加强大也更加复杂,需要花点功夫好好理解贯通. 看下面一段代码: [python] view plain copy def gen(): for x in xrange(4): tmp = yield x if tmp == 'hello': print 'world' else: print str(tmp) 只要函数中包含yield关键字,该函数调用就是生成器对象. [pytho

Python开发【第九篇】:协程、异步IO

协程 协程,又称微线程,纤程.英文名Coroutine.一句话说明什么是协程,协程是一种用户态的轻量级线程. 协程拥有自己的寄存器上下文和栈.协程调度切换时,将寄存器上下文和栈保存到其他地方,在切换回来的时候,恢复先前保存的寄存器上下文和栈.因此,协程能保留上一次调用的状态(即所有局部状态的一个特定组合),每次过程重入时,就相当于进入上一次调用的状态,换种说法,进入上一次离开时所处逻辑流的位置. 子程序,或者称为函数,在所有语言中都是层级调用,比如A调用B,B在执行过程中又调用了C,C执行完毕返

Python、进程间通信、进程池、协程

进程间通信 进程彼此之间互相隔离,要实现进程间通信(IPC),multiprocessing模块支持两种形式:队列和管道,这两种方式都是使用消息传递的. 进程队列queue 不同于线程queue,进程queue的生成是用multiprocessing模块生成的. 在生成子进程的时候,会将代码拷贝到子进程中执行一遍,及子进程拥有和主进程内容一样的不同的名称空间. 示例1: 1 import multiprocessing 2 def foo(): 3 q.put([11,'hello',True]

python并发之多进程、多线程、协程和异步

一.多线程 二.协程(又称微线程,纤程) 协程,与线程的抢占式调度不同,它是协作式调度.协程在python中可以由generator来实现. 首先要对生成器和yield有一个扎实的理解. 调用一个普通的python函数,一般是从函数的第一行代码开始执行,结束于return语句.异常或者函数执行(也可以认为是隐式地返回了None). 一旦函数将控制权交还给调用者,就意味着全部结束.而有时可以创建能产生一个序列的函数,来“保存自己的工作”,这就是生成器(使用了yield关键字的函数). 能够“产生一

哗啦啦Python之路 - 线程,进程,协程

1. 线程锁 如果不控制多个线程对同一资源进行访问的话,会对数据造成破坏,使得线程运行的结果不可预期.因此要引进线程锁. 线程同步能够保证多个线程安全访问竞争资源,最简单的同步机制是引入互斥锁. 互斥锁为资源引入一个状态:锁定/非锁定.某个线程要更改共享数据时,先将其锁定,此时资源的状态为“锁定”,其他线程不能更改:直到该线程释放资源,将 资源的状态变成“非锁定”,其他的线程才能再次锁定该资源.互斥锁保证了每次只有一个线程进行写入操作,从而保证了多线程情况下数据的正确性. 未引入锁前: impo