Python爬虫中的协程

协程

基本概念

协程:当程序执行的某一个任务遇到了IO操作时(处于阻塞状态),不让CPU切换走(就是不让CPU去执行其他程序),而是选择性的切换到其他任务上,让CPU执行新的任务,当原来的任务不处于阻塞状态后,CPU可以快速的回到之前的任务继续执行,这样就不用让原本的程序去排队等待CPU调度。

微观上看,任务是一个一个的切换执行,切换条件就是某一个任务有IO操作, 而宏观上,我们看到的是多个任务一起执行,这就是多任务异步操作。上面的一切的前提就是单线程的情况下,因为多线程可以多个线程同时干多件事。

import time


def func():
    print('first, hi!')
    # 让程序睡眠3秒钟,此时线程处于阻塞状态,CPU不为线程工作
    # 当我们爬取一个网页时,向一个url发送请求,会通过网络传输将请求发送到服务器
    # 然后服务器会处理请求、准备数据、将数据通过网络传输回客户端等工作
    # 这一系列的操作也会耗费时间,所以在从发送请求开始,到接收服务器返回的数据这一段时间内
    # 即在网络请求返回数据之前,程序也处于阻塞状态
    # 程序进行处于IO操作时是处于阻塞状态的
    time.sleep(3)
    print('second, hello..')


if __name__ == '__main__':
    func()

Python爬虫中的协程_第1张图片

协程和线程的区别(个人理解)

昨天仔细想的时候,感觉协程和线程很像,不知道它们之间的区别在哪,然后百度了一下,在这里说一下自己的理解(很不官方,不懂的可以百度一下,别人写的会比较详细和专业)。

打个比喻,一个公司有很多员工,老板给每个员工分配任务,员工之间各有分工,每个人负责自己的工作,如果遇到一个很会压榨人的老板,就会给每个员工安排很多任务。员工在完成自己分配到的多个任务时,因为自己只有一个人,不能同时把多个任务一起干,所以肯定是某个时刻内只干一件事。但是为了提高工作效率,在某个任务需要等待时,员工肯定不能傻傻的等着,而是利用这个等待的时间去干另一个任务(毕竟手上被万恶的资本家分配了很多活),比如正在跑的一个程序A要运行很久,那么在这个程序A运行的时间里,员工肯定去写另一个程序B了,如果这个程序B写完后也要运行很久,那么员工就会去完成程序C,或者此时程序A运行完了,接着完成程序A.....

上面所说的一个公司有多个员工,那么每个员工相当于一个线程,多个员工各有分工干自己的活,就是多个线程之间独立完成自己的工作。而一个员工充分利用时间完成多个任务(从一段时间上看(宏观),如一周内,员工同时完成多个任务,但是实际上(微观),某个时刻员工只做一件事),这每一个任务就是协程,所以协程实际上是一个单线程,宏观上同步完成多个任务,微观上异步完成多个任务。

协程可以充分的让一个线程忙起来,提高效率,不然当某个任务阻塞时,线程就处于空闲的等待状态,这使得线程资源没有得到充分利用,执行效率也大打折扣,就像老板想让打工人一刻都不停的给他创造价值一样。

用Python编写协程的程序

单个异步任务

有四种方式,但这里只选择其中的一种,如以下代码所示:

import asyncio


# 这种写法就是普通的函数
# def func():
#     print('你好,我是张三!')
#
#
# if __name__ == '__main__':
#     func()

# 在函数前面加async关键字,就表明该函数是异步协程函数
async def func():
    print('你好,我是张三!')

if __name__ == '__main__':
    # func()  # 如果直接调用,会得到一个警告:RuntimeWarning: ...
    g = func()  # 此时函数是一个异步协程函数,执行函数得到一个协程对象
    """
    输出:
    
    sys:1: RuntimeWarning: coroutine 'func' was never awaited
    """
    print(g)
    asyncio.run(g)  # 协程程序的运行需要asyncio模块的支持

多个异步任务

import asyncio
import time


# 在函数前面加async关键字,就表明该函数是异步协程函数
async def func1():
    print('你好,我是张三!')
    time.sleep(3)
    print('你好,我是张三!')

async def func2():
    print('你好,我是李四!')
    time.sleep(2)
    print('你好,我是李四!')

async def func3():
    print('你好,我是王五!')
    time.sleep(4)
    print('你好,我是王五!')

if __name__ == '__main__':
    f1 = func1()
    f2 = func2()
    f3 = func3()
    # 把多个异步任务放到一个列表中
    tasks = [f1, f2, f3]
    t1 = time.time()
    # 一次性启动多个异步任务(协程)
    asyncio.run(asyncio.wait(tasks))
    t2 = time.time()
    print(t2 - t1)

Python爬虫中的协程_第2张图片

上面三个函数是异步协程操作,理论上执行时间应该会小于9秒,因为异步任务会在某一个任务阻塞时去调用其他任务,但是观察上述代码执行时间,发现和同步执行三个函数效果一样,都是用了9秒多,如下图。出现这种的情况的原因是:函数里的time.sleep()是同步操作,而异步协程函数中出现同步操作的时候,异步就中断了,也就是说,当异步函数中有同步操作时,CPU不会切换去调用其他任务,而是像同步函数那样,执行完一个任务再去执行另一个任务(在这个例子中,就是执行完func1,再执行func2,再执行func3)。

Python爬虫中的协程_第3张图片

修改上述代码,实现异步操作效果,如下:

import asyncio
import time


# 在函数前面加async关键字,就表明该函数是异步协程函数
async def func1():
    print('你好,我是张三!')
    # time.sleep(3)  # 异步程序中出现同步操作,会中断异步,即不会切换任务执行
    # 异步操作代码,表示挂起任务,让任务睡眠3秒,然后切换CPU去执行其他任务
    await asyncio.sleep(3)
    print('你好,我是张三!')

async def func2():
    print('你好,我是李四!')
    # time.sleep(2)
    await asyncio.sleep(2)
    print('你好,我是李四!')

async def func3():
    print('你好,我是王五!')
    # time.sleep(4)
    await asyncio.sleep(4)
    print('你好,我是王五!')


# 一般不会直接像下面那样调用多个异步任务,而是把它包装在一个异步协程函数里
# if __name__ == '__main__':
#     f1 = func1()
#     f2 = func2()
#     f3 = func3()
#     # 把多个异步任务放到一个列表中
#     tasks = [f1, f2, f3]
#     t1 = time.time()
#     # 一次性启动多个异步任务(协程)
#     asyncio.run(asyncio.wait(tasks))
#     t2 = time.time()
#     print(t2 - t1)

async def main():
    # 写法一(不推荐)
    # await 都是写在异步协程函数里,即与async配套使用
    # await后一般跟协程对象、task等对象
    # await表示挂起某个异步任务,即是执行某个异步任务
    # await asyncio.create_task(func1())
    # await asyncio.create_task(func2())
    # await asyncio.create_task(func3())

    # 写法二(推荐)
    tasks = [
        # asyncio.create_task(func1()) 把协程对象包装成task对象
        asyncio.create_task(func1()),
        asyncio.create_task(func2()),
        asyncio.create_task(func3())
    ]
    # 这里await作用和上面一样,表示挂起协程对象,即会异步执行tasks列表中的异步任务
    await asyncio.wait(tasks)

if __name__ == '__main__':
    t1 = time.time()
    asyncio.run(main())
    t2 = time.time()
    print(t2 - t1)

Python爬虫中的协程_第4张图片

使用异步模拟爬虫程序

import asyncio

async def download(url):
    print('开始下载...')
    await asyncio.sleep(2)
    print('下载完成!')

async def main():
    tasks = []
    urls = ['url1', 'url2', 'url3']
    for url in urls:
        d = download(url)  # 得到一个异步协程对象
        # asyncio.create_task(d) 把协程对象包装成task对象
        tasks.append(asyncio.create_task(d))
    await asyncio.wait(tasks)

if __name__ == '__main__':
    asyncio.run(main())

异步发送http请求

以下代码是根据多个图片地址异步下载图片

import asyncio
# 下载命令:pip install aiohttp
import aiohttp

# 图片地址
urls = [
    "https://img95.699pic.com/photo/50165/7667.jpg_wh860.jpg",
    "https://bpic.588ku.com/back_origin_min_pic/20/04/19/f753e29e3dbe2ad75b8f6d6053199faa.jpg"
]

async def download(url):
    file_name = url.rsplit('/', 1)[1]
    # aiohttp.ClientSession()对象等价于requests模块,所以也有get、post方法
    # 且用法差不多
    async with aiohttp.ClientSession() as req:  # => req = aiohttp.ClientSession()
        # 因为是异步操作,所以要加上async关键字
        # with的作用和文件操作中的with类似,可以管理上下文,在使用完req对象之后会自动关闭
        # req.get(url) 发送请求获取图片数据
        async with req.get(url) as resp:  # => resp = req.get(url)
            # 这里的文件读写操作也是IO操作,也是会造成阻塞,所以也可以通过异步协程来完成
            # 具体可以学习aiofiles模块来实现
            with open(file_name, mode='wb') as f:
                # resp.content.read()是异步操作,所以前面要加await表示挂起
                # 挂起的意思就是resp.content.read()什么时候有东西了什么时候写入文件
                # 即什么时候有需要的内容了什么时候进行对应的操作
                # resp.content.read() 表示以字节的形式读取返回的数据的内容
                # 在这里就是读取图片的字节数据,然后存入文件,即保存图片数据
                f.write(await resp.content.read())
        # req.close() 使用with之后不用手动写上这句话
    print(file_name, '下载完成')

async def main():
    tasks = [asyncio.create_task(download(url)) for url in urls]
    await asyncio.wait(tasks)

if __name__ == '__main__':
    asyncio.run(main())

使用异步爬虫爬取西游记小说内容

详见:异步爬取西游记

你可能感兴趣的:(python,爬虫,python,爬虫,开发语言)