asyncio与aiomysql自实现爬虫框架

最新推荐文章于 2023-09-24 22:07:23 发布
最新推荐文章于 2023-09-24 22:07:23 发布
阅读量457 收藏 2
点赞数
分类专栏： Python爬虫 文章标签： python 数据库 mysql redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44238683/article/details/118420171
版权

目标：

  • 增量爬虫
  • 异步redis
  • 日志，邮件
  • 重定向请求

现阶段：

  • 爬虫基础模板
  • 异步操作mysql

下阶段：

  • 日志，邮件
  • 异步redis

码云地址
https://gitee.com/wenwenc9/sdpier_frame.git

项目结构：

在这里插入图片描述

一、运用采集

# -*- coding: utf-8 -*-
# @Time    : 2021-07-01 14:32
# @Author  : XuGuangJun
# @FileName: crawl_main.py
# @Software: PyCharm
import aiohttp
import asyncio
from lxml import etree
import nest_asyncio
import ujson
import time
import queue  # 对列
import traceback  # 错误日志


class AsyncSpider_request:

    def __init__(self, url_list, headers=None, cookies=None,
                 json=None, data=None, params=None, method='GET',
                 timeout=9, binary=False):
        """
        :param url_list: urls为list
        :param headers:{"Authorization": "Basic bG9naW46cGFzcw=="}
        :param cookies:{'cookies_are': 'working'}
        :param json:{'test': 'object'}
        :param data:{'key1': 'value1', 'key2': 'value2'}/b'\x00Binary-data\x00'
        :param params:{'key1': 'value1', 'key2': 'value2'}/[('key', 'value1'), ('key', 'value2')]
        :param method: POST请求还是GET请求
        :param timeout: 超时时间
        :param binary: 是否为文件下载
        """
        # 在jupyter需要这个，不然asyncio运行出错
        nest_asyncio.apply()

        # 初始化默认参数
        self.headers = headers
        self.cookies = cookies
        self.json = json
        self.data = data
        self.params = params
        self.method = method.lower()
        self.timeout = timeout
        self.binary = binary
        # 结果集合
        self.sucess = []
        self.sucessNum = 0
        self.fail = []
        self.failNum = 0

        if type(url_list) == str:  # 应对单个url和多个url
            self.url_list = [url_list]
        else:
            self.url_list = url_list

    async def judge_binary(self, response):
        status = response.status
        # 判断是否是二进制文件采集，二进制文件得到流
        if self.binary:
            html = await response.read()
        else:
            encoding = response.get_encoding()  # 有些网页并不是utf-8编码
            if encoding == 'gb2312':
                encoding = 'gbk'
            html = await response.text(encoding=encoding)
        redirected_url = str(response.url)
        return status, html, redirected_url

    # 请求函数
    async def fetch(self, session, url, ):
        try:
            if self.method == 'get':
                async with session.get(url, timeout=self.timeout, verify_ssl=False, params=self.params,
                                       cookies=self.cookies) as response:
                    status, html, redirected_url = await self.judge_binary(response)
            elif self.method == 'post':
                async with session.post(url, timeout=self.timeout, verify_ssl=False, cookies=self.cookies,
                                        json=self.json, data=self.data, ) as response:
                    status, html, redirected_url = await  self.judge_binary(response)
            else:
                raise print('method方法错误！仅有get与post')
        except Exception as e:
            msg = '请求失败：{},错误原因：{}==={}'.format(url, str(type(e)), str(e))
            print(msg)
            html = ''
            status = 0
            redirected_url = url
        # 状态码过滤
        if status == 200:
            self.sucessNum += 1
            self.sucess.append((status, html, redirected_url))
        else:
            self.failNum += 1
            self.fail.append((status, redirected_url))

    async def create_urls_session(self):
        """
        创建sesiion，创建请求任务
        :return:
        """
        _headers = {
            'User-Agent': ('Mozilla/5.0 (compatible; MSIE 9.0; '
                           'Windows NT 6.1; Win64; x64; Trident/5.0)'),
        }
        if self.headers:
            _headers = self.headers
        async with aiohttp.ClientSession(json_serialize=ujson.dumps, headers=_headers) as session:
            # 异步任务创建
            tasks = [loop.create_task(self.fetch(session, url)) for url in self.url_list]
            # 激活任务
            await asyncio.wait(tasks)

    def run(self):
        loop.run_until_complete(self.create_urls_session())


async def main():
    # ▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲  普通示例，默认get请求   ▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲
    # url_list = ['https://www.baidu.com/', 'https://www.baidu.com/', 'https://www.baidu.com/']  # 目标网址
    # P = AsyncSpider_request(url_list=url_list)
    # P.run()  # 启动方法
    # print(P.sucess)  # 返回成功
    # print(P.fail)  # 返回失败

    # ▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲ 最佳东方示例，get请求示例 ▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲
    # url_zjdf_list = 'https://interface-mobile.veryeast.cn/v1/job/recommends'  # 目标网址
    # params_1 = {'city': '070000', 'location': '070000', 'company_industry': '1', 'page': '1'}
    # params_2 = [('city', '070000'), ('location', '070000'), ('company_industry', '1'), ('page', '1')]
    # P = AsyncSpider_request(url_list=url_zjdf_list, method='get', params=params_2)
    # P.run()  # 启动方法
    # print(P.sucess)  # 返回成功
    # print(P.fail)  # 返回失败

    # ▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲  猎聘示例，post请求  ▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲
    # url_lp_list = 'https://app-tongdao.liepin.com/a/n/job/search.json'
    # true = True
    # index_json = {
    #     "data": {"keyword": "", "dq": "010", "industry": "000", "salaryLow": 0, "salaryHigh": 999,
    #              "refreshTime": "000",
    #              "sortType": 0, "compKind": ["000"], "compScale": "000", "currentPage": 0, "pageSize": 100,
    #              "isCampus": true}, "client_id": 80001, "version": "3.1.0", "version_code": 30100,
    #     "dev_type": 1, 'dq': '', 'industry': ''}
    # index_headers = {
    #     'Host': 'app-tongdao.liepin.com',
    #     'Connection': 'keep-alive',
    #     'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.143 Safari/537.36 MicroMessenger/7.0.9.501 NetType/WIFI MiniProgramEnv/Windows WindowsWechat',
    #     'content-type': 'application/json',
    #     'cookie': '_mscid=cx_wx_01; openid=opSQK0Q5_ywuMc9BH54rjO4roGGM; acw_tc=2760829516167265918576629ead62b6e99406247dc701b6117bfc651fb581; UniqueKey=9706777a3386324c1a667e00ad0d9493; lt_auth=7rtbOXVXxl3x5yLajWNY46ge2o35VGqd8HgLhEoG0tbuWfyz4PbkSgKGqrUExAMhwxl1dMULN7H5%0D%0APe73y3VI60QXwG2uiZiyo%2FK4z3wJdvRcN8W2vfT%2Bk8zRe50clUAC8mNb%0D%0A; app_auth=7rtbOXVXxl3x5yLajWNY46ge2o35VGqd8HgLhEoG0tbuWfyz4PbkSgKGqrUExAMhwxl1dMULN7H5%0D%0APe73y3VI60QXwG2uiZiyo%2FK4z3wJdvRcN8W2vfT%2Bk8zRe50clUAC8mNb%0D%0A; FE-hasUserLogin=true',
    #     'x-client-type': 'wxa',
    #     'Referer': 'https://servicewechat.com/wx4d70579bfaefd959/142/page-frame.html',
    #     'Accept-Encoding': 'gzip, deflate, br',
    # }
    # P = AsyncSpider_request(url_list=url_lp_list, headers=index_headers, method='POST', json=index_json)
    # P.run()  # 启动方法
    # print(P.sucess)  # 返回成功
    # print(P.fail)  # 返回失败


if __name__ == '__main__':
    start = time.time()
    # 创建事件循环
    loop = asyncio.get_event_loop()
    loop.run_until_complete(main())
    loop.close()
    print('总耗时：', time.time() - start)

二、异步mysql，asyn

# -*- coding: utf-8 -*-
# @Time    : 2021/6/23 15:46
# @Author  : XuGuangJun
# @FileName: asyncio_mysql.py
# @Software: PyCharm
# -*- coding: utf-8 -*-
import asyncio
import aiomysql

# from ..settings import MYSQL_SETTINGS

# 数据库设置
MYSQL_SETTINGS = {
    'MINSIZE': 5,  # 最小协程链接mysql
    'MAXSIZ': 10,  # 最大协程链接mysql
    'PORT': 3306,
    'HOST': '172.16.10.23',
    'USER': 'root',
    'PASSWORD': '..',
}


class Pmysql:
    """
    由于aiomysql.connect是异步的，在python里 __init__ 方法不能使用async关键词，
    也就是在对象的初始化时不能异步，所以我获取连接的操作单独的使用单例模式来创建一个连接，当然也可以不使用单例，
    每次进行查询的时候，都重新获取一个新的连接connection。
    """

    def __init__(self, database):
        self.coon = None
        self.pool = None
        self.database = database

    """
    使用连接池的意义在于，有一个池子，它里保持着指定数量的可用连接，当一个查询结执行之前从这个池子里取一个连接，
    查询结束以后将连接放回池子中，这样可以避免频繁的连接数据库，节省大量的资源。
    """

    async def initpool(self):
        # 初始化连接池
        __pool = await aiomysql.create_pool(
            minsize=MYSQL_SETTINGS['MINSIZE'],
            maxsize=MYSQL_SETTINGS['MAXSIZ'],
            host=MYSQL_SETTINGS['HOST'],
            port=MYSQL_SETTINGS['PORT'],
            user=MYSQL_SETTINGS['USER'],
            password=MYSQL_SETTINGS['PASSWORD'],
            db=self.database,
            autocommit=False,
        )
        return __pool

    async def getCurosr(self):
        # 从空闲池获取连接的协程。根据需要创建新连接，并且池的大小小于maxsize。
        self.conn = await self.pool.acquire()
        # 获取连接游标
        cur = await self.conn.cursor(aiomysql.cursors.DictCursor)
        return self.conn, cur

    async def query(self, query_sql, param=None):
        """
        查询函数
        :param query_sql: sql语句
        :param param: 参数
        :return:
        """
        self.conn, cur = await self.getCurosr()
        try:
            await cur.execute(query_sql, param)
            return await cur.fetchall()
        except Exception as e:
            print('执行查询命令出错')
        finally:
            if cur:  # 游标存在，使用完毕 关闭游标
                await cur.close()
            # 释放掉conn,将连接放回到连接池中
            await self.pool.release(self.conn)

    async def insert(self, query_sql, param=None):
        """
        插入数据函数
        :param query_sql: sql语句
        :param param: 参数
        :return:
        """
        self.conn, cur = await self.getCurosr()
        try:
            await cur.execute(query_sql, param)
        except Exception as e:
            print('执行插入命令出错')
        finally:
            if cur:  # 游标存在，使用完毕 关闭游标
                await cur.close()
            # 释放掉conn,将连接放回到连接池中
            await self.pool.release(self.conn)


async def createMysqlObj(db):
    """
    创建mysql连接对象
    :return: mysql对象
    """
    mysqlobj = Pmysql(database=db)
    pool = await mysqlobj.initpool()
    mysqlobj.pool = pool
    return mysqlobj


async def query(sql, databases):
    mysqlobj = await createMysqlObj(databases)
    datas = await mysqlobj.query(sql)
    return datas


async def insert(sql, databases):
    mysqlobj = await createMysqlObj(databases)
    datas = await mysqlobj.query(sql)
    return datas


if __name__ == '__main__':
    sql = "select * from tb_job"

    # spyder 与 jupyter 编译器（内置运行了loop）
    # res_df = pd.DataFrame(list(await query(sql)))

    # python3.7+
    result = asyncio.run(query(sql, 'bigdata_final')) # 传入sql语句，数据库名称
    print(result)

    # python3.4+
    # loop = asyncio.get_event_loop()
    # datas = loop.run_until_complete(query(sql, 'bigdata_final'))
    # print(datas)
稳稳C9
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
aiomysql：aiomysql是用于从asyncio访问MySQL数据库的库
02-03
aiomysql：aiomysql是用于从asyncio访问MySQL数据库的库
Python基于asyncio的多任务异步爬虫框架
Divine0的博客
04-28 1303
基本概念： 单线程+多任务异步协程：pip install asyncio 特殊的函数 如果一个函数的定义被async修饰后，则该函数就变成了一个特殊的函数 特殊之处： 该特殊的函数调用后，函数内部的实现语句不会被立即执行 该特殊函数被调用后会返回一个协程对象 协程对象 对象。通过特殊函数的调用返回一个协程对象。 协程 == 特殊函数 == 一组指定的操作 协程 == 一组指...
python链家网高并发异步爬虫asyncio+aiohttp+aiomysql异步存入数据
weixin_34357928的博客
03-05 367
python链家网二手房异步IO爬虫，使用asyncio、aiohttp和aiomysql 很多小伙伴初学python时都会学习到爬虫，刚入门时会使用requests、urllib这些同步的库进行单线程爬虫，速度是比较慢的，后学会用scrapy框架进行爬虫，速度很快，原因是scrapy是基于twisted多线程异步IO框架。 本例使用的asyncio也是一个异步IO框架，在python3.5以后加...
Asyncpy协程爬虫框架
李玺
05-23 6052
Asyncpy是我基于asyncio和aiohttp开发的一个轻便高效的爬虫框架，采用了scrapy的设计模式，参考了github上一些开源框架的处理逻辑。 github: https://github.com/lixi5338619/asyncpy pypi: https://pypi.org/project/asyncpy/ 安装需要的环境 python版本需要 >=3.6 依赖包： [ ‘lxml’, ‘parsel’,‘docopt’, ‘aiohttp’] 如果安装报错： ERROR:
asyncio异步编程之异步mysql
mr~li的博客
03-09 788
import asyncio import aiomysql async def async_ope_mysql(): sql_conn = await aiomysql.connect(host="", user="xx", password="!xx", db="xx", port=3306) cur = await sql_conn.cursor() sql = "select Host, User from user;" awa.
19_基于asyncio模块实现异步爬虫.zip
08-23
本项目实战基于Python的`asyncio`模块实现了一个异步爬虫，旨在利用异步I/O来提高爬取网页数据的效率。下面我们将深入探讨`asyncio`模块以及如何在爬虫项目中应用它。 `asyncio`是Python标准库中的一个模块，主要...
使用asyncio和aiohttp开发的轻量级异步协程web爬虫框架
04-11
1、资源内容：使用asyncio和aiohttp开发的轻量级异步协程web爬虫框架 2、适用人群：计算机，电子信息工程、数学等专业的学习者，作为“参考资料”参考学习使用。 3、解压说明：本资源需要电脑端使用WinRAR、7zip等...
自己动手写开源爬虫框架 Slit
08-10
【标题】"自己动手写开源爬虫框架 Slit"揭示了本文将介绍如何构建一个开源的网络爬虫框架。在IT行业中，爬虫框架对于数据挖掘、数据分析以及自动化信息提取等任务至关重要。Slit这个名字可能是“Simple Lightweight ...
基于事件分发的爬虫框架.zip
04-08
在事件分发的爬虫框架中，通常会使用异步I/O模型，如asyncio库，来实现非阻塞的网络请求，从而提高爬虫的性能。 【项目源码】包含在压缩包内的项目文件，为用户提供了一手的代码参考和学习材料。通过阅读和理解源码...
使用asyncio和 aiohttp开发的轻量级异步协程 web爬虫框架-爬虫开发
最新发布
04-23
计算机技术是指评价计算机系统的各种知识和技能的总称。它涵盖了计算机硬件、软件、网络和信息安全等方面。计算机技术的发展使我们能够进行高效...随着计算机技术的不断革新，我们可以更加高效地实现预期自动化、标准化
asyncmy:快速的异步MySQL驱动程序
03-16
asyncmy-快速的asyncio MySQL驱动程序 介绍 asyncmy是一个快速的asyncio MySQL驱动程序，它重用了大部分内容，并用重写了内核以速度。 基准 结果来自，我们可以知道asyncmy与其他驱动程序相比表现良好。 设备为MacBook Pro（13英寸，M1,2020）16G，MySQL版本为8.0.23。 安装 只需从pypi安装： > pip install asyncmy 用法 使用connect from asyncmy import connect from asyncmy . cursors import DictCursor import asyncio async def run (): conn = await connect () async with conn . cursor ( cursor = DictCurso
Python库 | asyncmy-0.1.2-cp39-cp39-manylinux2014_x86_64.whl
04-20
资源分类：Python库 所属语言：Python 使用前提：需要解压 资源全名：asyncmy-0.1.2-cp39-cp39-manylinux2014_x86_64.whl 资源来源：官方 安装方法：https://lanzao.blog.csdn.net/article/details/101784059
Python异步操作MySQL示例【使用aiomysql】
09-09
主要介绍了Python异步操作MySQL,结合实例形式分析了Python安装及使用aiomysql针对mysql数据库异步操作相关实现技巧,需要的朋友可以参考下
（异步爬虫）aiomysql剔除代理池中失效的IP
向日葵的专属太阳
11-10 1651
（异步爬虫）aiomysql剔除代理池中失效的IP 最近写的几个爬虫，都因为IP被封的原因，爬取的数据很少，尽管已经限制访问的时间，但时间长了，一直使用同一个IP必然有风险。所以趁着现在课少，写了个简单的代理池（仅供自用），目前还在一步步完善。下面就异步mysql和异步IP测试来简单记录一下。 之前没怎么用协程，这次使用踩了不少坑。。话不多说直接开整。 首先要做的肯定是获取当前数据库中已有的ip。由于只取一次，就直接pymysql来进行操作了。 def query_db(): conn = pym
aiohttp保存MySQL_python链家网异步IO爬虫，使用asyncio、aiohttp和aiomysql
weixin_39523529的博客
01-29 104
python链家网异步IO爬虫，使用asyncio、aiohttp和aiomysql平均1秒可以爬取30个详情页信息可以使用asyncio.Semaphore来控制并发数，达到限速的效果 # -*- coding: utf-8 -*-""":author: KK:url: http://github.com/PythonerKK:copyright: ? 2019 KK """import asy...
python模块之 aiomysql 异步mysql
局外人LZ的博客
09-06 2645
aiomysql 是一个基于 asyncio 的异步 MySQL 客户端库，用于在 Python 中与 MySQL 数据库进行交互。它提供了异步的数据库连接和查询操作，适用于异步编程环境异步支持：aiomysql 是基于 asyncio 实现的，可以与 asyncio 框架无缝集成，充分利用异步编程的优势，提高应用程序的性能和并发能力。高性能：aiomysql 使用了底层的 PyMySQL 库，通过异步操作和连接池技术，可以实现高性能的数据库访问。
mysql 使用异步io_InnoDB引擎之-异步IO（Async IO）
weixin_30915487的博客
01-21 1066
InnoDB引擎有几个重点特性，为其带来了更好的性能和可靠性：插入缓冲(Insert Buffer)两次写(Double Write)自适应哈希索引(Adaptive Hash Index)异步IO(Async IO)刷新邻接页(Flush Neighbor Page)关于AIO与SIO为了提高磁盘操作性能，当前的数据库系统都采用异步IO的方式来处理磁盘操作。同步IO：我们常用的read/writ...
Python 之Mysql的异步操作库 aiomysql 使用说明手册 笔记
白袍小将的博客
09-24 3269
python之MySQL数据库操作，该操作执行异步操作，通过asyncio进行高性能操作。
asyncio异步爬虫
05-10
使用 asyncio 实现异步爬虫可以提高爬虫的效率，因为它可以让程序在等待网络 IO 的时候不阻塞，而是去执行其他任务。下面是一个使用 asyncio 实现的简单异步爬虫示例： ```python import asyncio import aiohttp async def fetch(session, url): async with session.get(url) as response: return await response.text() async def main(): async with aiohttp.ClientSession() as session: tasks = [] for url in ['http://example.com', 'http://example.net', 'http://example.org']: tasks.append(asyncio.ensure_future(fetch(session, url))) htmls = await asyncio.gather(*tasks) print(htmls) loop = asyncio.get_event_loop() loop.run_until_complete(main()) ``` 这个示例中，我们使用 aiohttp 库发送异步 HTTP 请求，使用 asyncio.gather() 来执行多个协程，并等待所有协程执行完毕后返回结果。这样就可以实现异步爬虫了。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值