单线程多任务异步协程

目录

  1. 概念讲解

  2. 多任务异步协程理解

  3.基于aiohttp模块异步网络请求实现数据爬取及数据解析

一、需要了解的概念

  特殊函数:如果async修饰了一个函数的定义,那么该函数就变成了一个特殊函数,

    特殊之处:特殊函数被调用后函数内部实现语句不会被立即执行 

    该函数调用之后会返回一个协程对象   

  协程对象:特殊函数调用后可以返回一个协程对象

    协程 == 特殊函数

  任务对象:对协程对象的进一步封装,就是一个高级协程对象

    任务对象 == 协程对象 == 特殊的函数

    绑定回调:task.add_done_callback(parse) #parse就是一个回调函数

      parse的定义:

        parse必须又一个参数,该参数表示的就是回调函数对应的任务对象

        task.result(): 就是特殊函数的的返回值

  事件循环对象:可以让特殊函数内部的语句执行

    该对象内部必须注册的是任务对象,当事件循环开启后其内部注册的任务对象就可以基于异步被执行

  ps: 在特殊函数每部不可以出现不支持异步代码对应的模块

定义如下:

import asyncio
import time

urls = [
    ‘http://127.0.0.1:5000/jay‘,
    ‘http://127.0.0.1:5000/tom‘,
    ‘http://127.0.0.1:5000/jay‘,
    ‘http://127.0.0.1:5000/tom‘,
]

# 特殊函数
async def get_request(url):
    print(‘正在请求:‘,url)
    time.sleep(2)
    print(‘请求结束;‘,url)
    return ‘bobo‘

#对调函数
def parse(task): #task 该回调函数对应的任务对象
    print(‘ I am callback‘)
    print(task.result()) #result返回的就是特殊函数的返回值

#返回了一个协程对象
c = get_request(‘www.1.com‘)

#任务对象
task = asyncio.ensure_future(c)

#给任务对象绑定回调,任务对象执行完后才能被执行
task.add_done_callback(parse)

#创建一个事件循环对象
loop = asyncio.get_event_loop()

#需要将任务对象注册到事件循环对象中且需要启动循环对象
loop.run_until_complete(task)

二、多任务异步协程过程理解

import asyncio
import time

urls = [
    ‘http://127.0.0.1:5000/jay‘,
    ‘http://127.0.0.1:5000/tom‘,
    ‘http://127.0.0.1:5000/jay‘,
    ‘http://127.0.0.1:5000/tom‘,
]

start = time.time()
# 特殊函数
#!!!特殊函数内部不可以出现不支持异步的模块代码,如果出现了则会中断所有的异步代码
async def get_request(url):
    print(‘正在请求:‘,url)
    #time.sleep(2)
    await asyncio.sleep(2) #await 遇到阻塞的时候需要阻塞然后再走后续代码
    print(‘请求结束;‘,url)
    return ‘bobo‘

#任务列表
tasks = []

for url in urls:
    c = get_request(url)  #执行特殊函数得到一个协程对象
    task = asyncio.ensure_future(c) #获取任务对象
    tasks.append(task)

#一个任务对象和另一个任务对象所对应的代码是异步的
#某一个对象内部的代码是串行的

# 注册的任务对象 事件循环开启
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks)) #此处的wait当任务对象遇到阻塞的时候允许挂起,把cpu的使用权交出来
print(‘耗时‘,time.time()-start)

三、基于aiohttp模块异步网络请求实现数据爬取及数据解析 

1. aiphttp模块使用详解
pip install aiohttp
编码:
    基本架构:

with aiohttp.ClientSession() as s: #s就是一个请求对象
    with s.get(url) as response:
        page_text = response.text() #read() ==> content json没变
        return page_text

    补充细节
        在每个with前加async
        在每个阻塞前加await

async with aiohttp.ClientSession() as s: #s就是一个请求对象
    async with await s.get(url) as response:
        page_text = await response.text() #read() ==> content json没变
        return page_text

2.aioihttp使用案列及说明及数据解析

import asyncio
import time
import requests
import aiohttp
from lxml import etree
urls = [
    ‘http://127.0.0.1:5000/jay‘,
    ‘http://127.0.0.1:5000/tom‘,
    ‘http://127.0.0.1:5000/jay‘,
    ‘http://127.0.0.1:5000/tom‘,
]

start = time.time()
# 特殊函数
#!!!特殊函数内部不可以出现不支持异步的模块代码,如果出现了则会中断所有的异步代码
async def get_request(url):
    #requests模块是不支持异步的
    # page_text = requests.get(url).text
    # return page_text
    async with aiohttp.ClientSession() as s: #s就是一个请求对象
        async with await s.get(url) as response: #get/post(url,data/parms,headers,proxy=‘http://ip:port‘)
            page_text = await response.text() #read() ==> content json没变
            return page_text

#定义回调函数
def parse(task):
    page_text = task.result()
    tree = etree.HTML(page_text)
    print(tree.xpath(‘//a/text()‘))

#任务列表
tasks = []

for url in urls:
    c = get_request(url)
    task = asyncio.ensure_future(c)
    #绑定回调用于数据解析
    task.add_done_callback(parse)
    tasks.append(task)

loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))
print(‘耗时‘,time.time()-start)

原文地址:https://www.cnblogs.com/guniang/p/11718937.html

时间: 2024-10-09 15:43:19

单线程多任务异步协程的相关文章

爬虫第四章 单线程+多任务异步协程

单线程+多任务异步协程: asyncio 事件循环 loop: 无限循环的对象,事件循环中最终需要将一些特殊的函数注册到该事件循环中 特殊的函数: 被ansyc关键字修饰的函数 协程: 本质上是一个对象,可以把协程对象注册到事件循环中, 任务对象:就是对协程对象进一步的封装. 绑定回调函数(即在执行完特殊函数之后执行这个回调函数):task.add_done_callback(func) - func(task) :task 参数表示的就是绑定的任务对象 - task.result() 返回的就

单线程实现了多任务异步协程

单线程+多任务异步协程: 意义:提升爬取数据的效率,我们也可以使用线程池, 异步爬虫方式: 多线程/多进程(电脑吃不消,没办法无节制开启)不建议 池:池中的线程或进程也是无法任意开启. 单线程+多任务异步协程(推荐)(500个协程,最优) 概念: 协程:本质就是一个对象,协程对象,怎么去获取?可以使用asynic该关键字去修饰一个函数定义,此时的函数就叫它特殊函数,当该特殊函数被调用之后,就可以返回一个协程对象,特殊之处不仅仅是返回一个协程对象,当函数内部实现的语句不会被立即执行(时间循环开启后

python爬虫--多任务异步协程, 快点,在快点......

多任务异步协程asyncio 特殊函数: - 就是async关键字修饰的一个函数的定义 - 特殊之处: - 特殊函数被调用后会返回一个协程对象 - 特殊函数调用后内部的程序语句没有被立即执行 - 协程 - 对象.协程==特殊的函数.协程表示的就是一组特定的操作. - 任务对象 - 高级的协程(对协程的进一步的封装) - 任务对象==协程==特殊的函数 - 任务对象==特殊的函数 - 绑定回调: - task.add_done_callback(task) - 参数task:当前回调函数对应的任务

多任务异步协程,asyncio及aiohttp

要实现异步协程,需要满足几个条件: 1,创建协程对象,且协程内部操作需要支持异步. 2,创建任务对象,如需为协程执行结果进行进一步处理,则需要为任务对象绑定回调函数. 3,创建事件循环,并将任务启动. 1 import asyncio 2 import requests 3 from lxml import etree 4 import aiohttp 5 import os 6 7 headers = { 8 9 'User-Agent': 'Mozilla/5.0 (Windows NT 1

单线程+异步协程

event_loop:事件循环,相当于一个无限循环(不清楚循环多少次),我们可以把一些特殊函数注册(放置)到这个事件循环上,当满足某些条件的时候,函数就会被循环执行.程序是按照设定的顺序从头执行到尾,运行的次数也是完全按照设定.当在编写异步程序时,必然其中有部分程序的运行耗时是比较久的,需要先让出当前程序的控制权,让其在背后(挂起)运行,让另一部分的程序先运行起来.当背后运行的程序完成后,也需要及时通知主程序已经完成任务可以进行下一步操作,但这个过程所需的时间是不确定的,需要主程序不断的监听状态

爬虫 + 数据分析 - 4 异步协程, selenium使用, 自动登录

一.单线程+异步协程 1.基本概念: event_loop:事件循环,相当于一个无限循环,我们可以把一些特殊函数注册(放置)到这个事件循环上, 当满足某些条件的时候,函数就会被循环执行.程序是按照设定的顺序从头执行到尾,运行的次数也是完全按照设定. 当在编写异步程序时,必然其中有部分程序的运行耗时是比较久的,需要先让出当前程序的控制权,让其在背后运行, 让另一部分的程序先运行起来.当背后运行的程序完成后,也需要及时通知主程序已经完成任务可以进行下一步操作, 但这个过程所需的时间是不确定的,需要主

06爬虫-异步协程

1. 前言(目的就是大大提升爬虫效率) 在执行IO密集型任务的时候,代码常常遇到IO操作而等待.例如我们在爬虫的时候,用到requests请求的时候,网页响应慢,一直等待着,那么爬虫的效率会大大的降低. 为了解决这类问题,本文就来探讨一下 Python 中异步协程来加速的方法,此种方法对于 IO 密集型任务非常有效.如将其应用到网络爬虫中,爬取效率甚至可以成百倍地提升. 注:本文协程使用 async/await 来实现,需要 Python 3.5 及以上版本. 2. 基本了解 在了解异步协程之前

单线程多任务异步抓取(asyncio)

协程 import asyncio import time #定义了一个特殊的函数 #特殊:调用后会返回一个协程对象,且函数内部的实现语句不会被立即执行 #创建一个协程对象 # async def test(num): # print(num) # # c = test(10) # print(c) #封装一个任务对象 # async def test(num): # print(num) # # c = test(10) # #根据协程对象封装了一个任务对象 # task = asyncio.

爬虫速度太慢?来试试用异步协程提速吧!

1. 前言 在执行一些 IO 密集型任务的时候,程序常常会因为等待 IO 而阻塞.比如在网络爬虫中,如果我们使用 requests 库来进行请求的话,如果网站响应速度过慢,程序一直在等待网站响应,最后导致其爬取效率是非常非常低的. 为了解决这类问题,本文就来探讨一下 Python 中异步协程来加速的方法,此种方法对于 IO 密集型任务非常有效.如将其应用到网络爬虫中,爬取效率甚至可以成百倍地提升. 注:本文协程使用 async/await 来实现,需要 Python 3.5 及以上版本. 2.