Python爬虫仅需一行代码----crawl第三方库

zhangtt123

仅需一行代码写爬虫–simple_crawl
simple_crawl
仅需一行代码即可达到爬虫效果
) t9 T+ b# c! b$ v( [2 |8 Q项目地址(欢迎star):https://github.com/Amiee-well/crawl
使用方法
pip install simple_crawl
# B. r6 ~5 V# |- _5 I4 G
6 o" h) s3 h- G$ [### 以下源代码为简单介绍,详细功能介绍再源代码之下
$ w7 N+ x8 R- M5 T! {from simple_crawl import request
  [5 x$ d- V4 |2 y- Nrequest.parse(
+ d0 v. @$ K- S        # status 参数为运行状态,支持单线程多线程多进程协程以及联合
        status="aiohttp",
        # url 参数为爬虫网址,单线程状态为字符串格式,特殊状态为列表格式
) N9 D5 p; k* w4 @" h        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
        # login 参数为获取登陆信息,如淘宝等网址需要登陆信息
    #login="taobao",
    # type_url 参数为返回源代码格式,支持text和json,默认返回text
6 l# e( v8 v* Y5 T4 r! S: c    type_url = "text",
    # Parsing 参数为解析方法,支持re、xpath和beautifulsoup
5 @, {" y# u) t    Parsing = 'xpath',
# [. O2 z% c: r8 Q7 z    # label 参数为爬虫解析过程,字典格式,详情见下方
    label = {
- }- H9 k" |7 o0 ^% [% U            'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
            'name':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/text()',str],
            'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
     },
     # write 参数为爬虫结果保存,支持txt、csv、pkl、json,注:特殊状态爬虫信息容易混乱
     write='result.txt',
* M! Q6 M) B6 U+ r* U/ z     # next_url 参数为下一页爬虫地址,@必须为href,仅支持单线程爬虫
     next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
" F7 O6 M9 L, X- T$ R8 Y     # page 参数为断续笔记,第一个参数是否启用笔记,第二个参数选填默认page.txt,仅支持单线程爬虫
3 _! V( H1 K0 C& X# e1 S     page=[True,"now_url.txt"],
+ ?7 v+ V3 V' _4 J: H     # clean 参数为是否进行数据清洗,防止大量爬虫收集无用信息
3 P1 j3 Q) Q/ `) L7 i6 _     #clean=True,
     # texting 参数为是否选择连续爬虫,避免爬虫过程中出现非代码问题报错结束爬虫程序
+ ]* {! ^9 E9 F3 F' G6 n     texting=True,
6 z* {$ t- K$ e" r     # Thread_num 为多线程数,默认为1单线程,支持多线程状态和异步状态
     Thread_num=3,
     # cpu_count 为多进程数,默认为1单进程,支持多进程状态和联合状态
, C: P! Z4 a+ g+ z3 {     cpu_count=1,
     # sem 为异步控制数,默认为5同时启动,支持异步状态和联合状态
     sem=5,
     # write_SQL 为是否写入数据库,默认否
     # host 参数默认localhost
     # post 参数默认3306
& h$ N; {4 ^; u0 Y5 ?& U5 y     # user 参数默认root
7 l+ v7 M. j. S' f4 P+ J2 F     # password 参数必填,必须正确
+ B; z+ q7 D( V* L9 ]: P     # db 参数为即将存入的数据库名,若不存在自动创建
! A" `' S9 {* Q( |3 G/ K     # table 参数为即将存入的数据表名,若不存在自动创建
7 {% g: X2 P" w     write_SQL={
         'host':'localhost',
$ t$ x; \5 B+ s( v4 _& ?, h3 B7 U         'post':'3306',
2 W& {/ X+ ^6 ^+ m8 k- k% y; A! \. G         'user':'root',
         'password':'123456',
% W* L; c1 ]! n, N) b; B! w, y         'db':'example',
* x3 i1 Y* H3 @6 r         'table':'example'
      }
).run()
5 B$ ?5 u0 z6 t4 |8 t1 M
3 ]; U/ i, @. Y5 O1 W. n! D介绍一下crawl参数设置：

'''
单行代码爬虫程序执行
:param status:启用爬虫类型,支持普通爬虫、多进程爬虫、多线程爬虫、异步爬虫、异步多进程爬虫,参数请参考文档
4 }" ]* u) q  t:param url:即将请求的url地址,仅支持get请求
:param type_url:请求url后返回格式,支持text和json格式返回
8 h& C7 s5 X0 m; m) s$ O' h! q# N: B:param Thread_num:即将启动多线程个数,默认为1单线程
:param sem:协程信号量,控制协程数,防止爬的过快,默认为5
; n! X1 M/ e3 G1 \:param cpu_count:运行爬虫使用多进程cpu核数,默认为系统核数一半
:param login:模拟网站登陆,保存登陆信息
/ b2 M; w) k2 A- p! Y4 B' w:param Parsing:爬虫方式,支持re、xpath以及bs4方法
0 L/ j* \8 y9 S* Z8 L. t:param texting:是否启用连续爬虫,爬虫程序异常报错后重新启动爬虫,
                       多次报错结束程序,默认否
:param label:选择器内容,字典格式保存,
                     字典值为列表格式,第一个参数为选择器,第二个参数为转换类型
                     第一个参数必填,第二个参数默认str类型
5 j5 }4 }4 V& n2 x:param write:是否写入文件,支持txt格式、csv格式、json格式以及pkl格式,默认否
:param next_url:是否跨页爬虫,选择器内容使爬虫继续翻页爬虫
8 q' l: ~% y/ i. m1 ~* g:param page:是否选择断续笔记接手下次爬虫处理,默认否
:param clean:是否进行简单类型数据清洗,默认否
* u( _7 U! M( \* L; ^2 y  U:param write_sql:是否写入数据库,默认否
                         'host'默认为'localhost','post'默认'3306','user'默认'root',
                         'password':'密码','db':'数据库','table':'数据表',
                         检测库是否存在,若不存在则创建,若存在则直接插入,
                         检测表是否存在,若不存在则创建,若存在则直接插入
:return True
! \# y  f  s$ h) O3 Q1 X! i" \'''
9 V! y' @7 S+ [9 H# X- v介绍玩法
接下来介绍的均为调用第三方库的情况下运行：
# n1 j' j  X1 W9 P
from simple_crawl import request
第一种玩法：输出源代码
调用requests库进行源代码请求。
% f( B! ]+ `2 o- m- D
: M4 J- H" q3 e, \特点：
% n. ~! I2 `2 n- w# F! o# e请求失败则调用ip池处理重新请求访问，
5 r, f- D# G0 R( ]; g出现五次失败默认网址输入错误。
支持text以及json字符串返回。默认text。
% n. \6 a0 A5 f7 h. b) E. T
+ m1 R9 X; z4 `2 U缺点：
0 P& d" I+ C! S! u* ]暂时只能进行get请求，不支持post访问

：return text or json

request.parse(
% p( x' J: N; k+ U; M; c        url = "https://www.douban.com/group/explore",
        type_url = "text"
2 `: P/ {8 @7 w: @& f/ N* v).run()
# return text

第二种玩法：模拟网站登陆并保存信息
/ A$ h$ I! F* V# }. j调用DecryptLogin库请求登陆访问。
5 I# Y. f* s! C; H
- V/ k* q5 I/ jps：DecryptLogin库为大佬皮卡丘写的一个很不错的模拟网站登陆库，在此引用一下，因为单行爬虫原因不支持账号密码登陆，我将大佬写的二维码登陆使用过来了。再次感谢大佬开源
/ G7 g- L/ T0 m% Y7 q在此放出文档地址
0 _: {+ ~; I  b2 D2 h. wDecryptLogin库中文文档：https://httpsgithubcomcharlespikachudecryptlogin.readthedocs.io/zh/latest/
; k/ d+ m# `/ ?
7 `% f; J( w* F. W1 D, p! L6 G特点：
( x( ?0 `0 y; z2 ]$ M0 [将DecryptLogin库中二维码继承到此库（非二次开发）
支持QQ群、QQ空间、QQ安全中心、淘宝、京东和斗鱼登陆（大佬登陆库中所有的二维码登陆）
保存session.pkl信息到本地方便下次登陆运行
; C3 @* K$ S" N
缺点：
4 H; l9 W. e- X0 Lsession.pkl登陆信息过时无法自动删除。
导致下次登陆疑似cookie无法正常登陆。
( Q4 Q0 K- t+ q6 [; L0 l1 a/ \
:return session

  ]7 ~# p) ^/ T0 d' @' f1 Frequest.parse(
& w7 w: r" r% ]9 b8 t+ c        # 臭不要脸的推广一下我的店铺
( M0 S4 A$ ?) f        url="https://shop574805287.taobao.com/",
3 N; R4 F7 R* |$ M7 u% ?        login="taobao"
).run()
# L# }# S" J  V/ \" U( }# return text
# H+ D, T- X7 u' ~9 W2 }' d. D
* A/ V& a% c  j第三种玩法：爬取网站信息
, X! C6 W% X, s8 x" E! r, ?* ?爬虫库自然少不了爬虫的过程
6 ?/ \1 G  y+ `
特点：
! Z4 P* H( H; d) t6 U' x支持re库，xpath解析以及bs4选择器。
爬取方法为字典格式。单方面输出。
字典键为保存的字段名称。
字典值为列表格式：第一个参数为选择器，第二个参数为转换类型。第一个参数必填，第二个参数默认str类型。

缺点：暂无（等待小伙伴们发现）
& H9 u2 d& @' o0 ~
& U, X* x0 w: o$ r$ U% S" T：return reptile_results

5 n- r& ~2 O1 Z6 D# @- Y2 ~request.parse(
4 P: m! G# h3 R" X' R3 v        url='https://www.douban.com/group/explore',
        # 字符串格式,选择器方法。
    Parsing = 'xpath',
% y8 r  W! Y/ c3 s+ o    # 字典格式,参数如上。
    label = {
        'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
: }- c! e( b; W- {& w3 j        'name':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/text()',str],
        'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
4 ^: u5 v: K4 ^6 o7 ~+ c. l        }
9 b1 Z* `6 W  P' G0 I).run()
  _: C; c. j+ ?3 z( W# return reptile_results（list）
1 I$ k* ]+ O* [$ z9 B
8 d7 l& E" U  z: X0 n第四种玩法：自由保存信息
, c# D: N/ a+ L6 O+ N# U8 I目前版本支持保存txt、csv、json以及pkl四大主流文件。日后版本更新将发布更为全面的保存方法。

特点：
6 y8 R6 h- v. }; Q9 B写入文件均为数据格式传入文件。
且输入格式规范方便阅读and省事。

( J& L% r6 l. v: C  _3 l; @4 d缺点：
保存格式仅四种，
% j) U2 V# q2 @+ q. f: \) f不方便用户之后读写操作。

) |' L3 c& U' s; Q5 ^. z" G1 a：return file

, c6 h: `/ A5 _1 Arequest.parse(
6 g- J2 k- w, e! E  _+ k        url='https://www.douban.com/group/explore',
    Parsing = 'xpath',
    label = {
- t6 S8 b: t7 q* p4 y- R        'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
6 z# M% g" x, ^4 q$ [: b2 j+ G        'name':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/text()',str],
        'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
        },
    # 字符串格式,具体保存位置填写
    write='result.pkl'
).run()
6 D$ J0 D' q6 q. v/ j- z4 X# return file

第五种玩法：读取下一页 url 地址继续爬虫
. w  z  Z# X$ |5 q' q+ d这也是每个人都担心的问题，仅仅一行代码怎么可能翻页爬虫。这还真能做到哦~

特点：
, N+ H  L. M1 I0 ^& Q: ?继承之前的Parsing参数选择器选择方法。
在这里可读取到解析后的下一页 url 网址。
方可继续进行爬虫处理。方便用户使用。

9 v! U! |) Z7 z2 Z6 m  W缺点：
' T3 Z# h! f  l/ m) l* U  L+ S若爬虫时下一页 url 地址改变，便结束爬虫。
& a* u' c: v0 x+ F只能爬取所给 url 地址中的信息。
/ Q* _" A1 m7 W& s0 g& \) m无法进行某一界面的多个网页爬取返回。
造成访问页面单一流失。
2 N8 X. g( H7 p- S7 K4 P
( g" q% I  ]0 p& A' E：return None
+ [0 f+ B( C: n4 e$ U
3 W( t/ P" G& d" l! L, Crequest.parse(
        url='https://www.douban.com/group/explore',
    Parsing = 'xpath',
/ h( ]% \, t& \' J    label = {
        'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
        'name':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/text()',str],
        'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
        },
7 a+ S) b. n, Q6 p, `    write='result.pkl',
    # 字符串格式,根据Parsing方法继续请求下一页a中href
) b8 c  Q( c- L3 E- ?    next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
).run()
# return None
8 b% P" ]9 Y* f
9 G  n$ z  T& u+ B3 g7 f, v第六种玩法：爬虫网页保存
  Z$ u8 h2 Y7 I( E听说过爬虫断续重连的朋友应该懂得这是个什么神仙操作。每次爬虫运行期间好好的，睡一觉醒来发现代码报错了。。。这就是个很难受的事，还不知道之前爬取到哪一页了，只能重新爬虫了啊！

特点：
; n' H1 h( P( @' ^$ O' p持续输出断续笔记。
将此次爬虫的 url 地址保存到一个文本文档内部。
下次读取文本文档即可快速进行直接断掉的爬虫 url 地址继续爬取所需。

: @) Z5 I" {  Z* U( |缺点：
读取内容不单一。
导致下次爬虫无法正确读取上次爬虫留下的痕迹。
) g& Y2 S3 x& x0 p! d9 v3 g) I, T
- L  x( K: X  W9 N：return url_file
+ q% B/ U7 r% E; p
request.parse(
5 T! I! N, m5 u) S& c    url='https://www.douban.com/group/explore',
    type_url='text',
    #login='taobao',
    Parsing = 'xpath',
8 x) e0 ]" J9 U# S    label = {
        'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
8 l: ]. l# s) z$ N4 ?- V& ]1 K& ^        'name':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/text()',str],
        'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
        },
    write='result.pkl',
    next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
    # 第一个参数为是否需要断续笔记。
    # 第二个参数为断续笔记保存位置。
    page=[True,'url_page.txt']
5 r; j8 h4 p+ w- o).run()
# return url_file

; t3 u7 J8 ?2 h5 U第七种玩法：简单数据清洗
5 `2 m+ b$ `1 v  R数据拿下后，直接保存到本地有些大佬可能觉得很辣鸡，连清洗都不清洗就存入本地了？那得拿到多少废数据脏数据。那么接下来介绍一下清洗参数。

1 ~2 \( l) I3 ^" Y- q- x$ n* E% w3 r特点：
7 T4 H* m0 N. i, O$ Q+ B2 o  U本人曾写过一个底层数据清洗。
能将列表格式数据进行归分清洗。
主要内容请参考另一篇文章
如下连接：数据清洗
% D$ C5 ], y, E+ e8 D, D  i$ l
缺点：
数据清洗格式简单。
) d, w) u$ T5 l. {数据清洗内容单一。
# D: h9 j" ^. O  q  s无法完全做到绝对清洗。
有待改善。

：return keyword_list, value_list
" ~6 Y: k+ `8 r; e# d* I$ e% O
request.parse(
    url='https://www.douban.com/group/explore',
# R5 K, C2 H3 `' T( ]6 R1 l    Parsing = 'xpath',
& d! T; E# J  T$ r! e: V& ^    label = {
. h& ~  ~0 U' t# k2 j3 Y1 P, d        'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
  c0 O/ r0 Y# ~4 I* D        'name':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/text()',str],
        'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
        },
    write='result.pkl',
* {8 _- ~! P+ z- o* k' h) M; L1 n    next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
    page=[True,'url_page.txt'],
    # bool类型,默认不清洗
    clean=True
).run()

2 v! f8 f% j* d4 |9 Y: f! m第八种玩法：爬虫存入数据库
+ u) l0 A4 W0 t, \) j7 Y8 Q  F存到txt、存到csv、存到json、存到pkl，那也太low了吧。现在流行的数据库用不了么？那是不可能的。。

- I( {+ L" T# n5 U2 d特点：
. i+ c# D' t# v  V8 M8 O信息存入MySQL数据库。
可连接docker远程数据库。
数据库的库名可以不存在。
数据库的表名可以不存在。
) S, ], H2 V$ \- ^- x* l根据之前传入字典键与值参数判断表类型。
自由建立数据表传入信息。

" v9 G, _# |4 D/ K, G5 l缺点：
" g; H# Y/ {, d4 z3 s, X! w仅支持MySQL数据库。

: ~6 j7 y" c/ F; V：return SQL
; w9 g% z3 Y, S  \4 [
request.parse(
0 T+ ~8 R  c" Z# j8 f/ ^    url='https://www.douban.com/group/explore',
    Parsing = 'xpath',
7 s& Z+ t8 x) z, {' o( ^/ [    label = {
        'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
        'name':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/text()',str],
- }' a% ]3 s' i- D        'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
) l% D- D; G; z4 O; }        },
) a! U( N0 R# k' {7 |    write='result.pkl',
    next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
    page=[True,'url_page.txt'],
    clean=True,
4 z- T& |6 u# V3 V    # 字典格式,
9 K" q) w  K; U    # host可有可无,默认localhost
- E; ~) z1 i! J( n" z' [9 g' p    # post可有可无,默认3306
    # user可有可无,默认root
    # password必要参数,数据库连接密码
    # db必要参数,数据库即将存入的库名
    # table必要参数,数据库即将存入的表名
1 a5 L+ X2 G+ j+ V    write_SQL={
2 W4 f+ l4 S) p# ~/ i        'host':'localhost',
9 q4 w+ [% H  g( A9 S        'post':'3306',
- Q4 r% X& J: _. E% N2 ^* Z7 v/ j        'user':'root',
5 z2 c$ d# n8 V6 M        'password':'123456',
        'db':'example',
$ l5 Z% q  e0 H( M; U        'table':'example'
; n$ w* \- S9 B$ R9 K( B" j, x        }
    ).run()

4 d. S+ Z, u6 W第九种玩法：重新启动爬虫
& X# }5 D3 K/ {' z# {7 B; I3 t爬虫最让人厌烦的就是被一个不痛不痒的错误信息给终止爬虫了，比如意外的远程断开链接等低级非代码错误，报错之后还得重新启动断续爬虫，就显得很麻烦。我做了一期爬虫程序异常报错后重新启动爬虫，多次报错结束程序。
! w, ?4 D: @! B' t5 q! `
# n5 @2 ^  P" H特点：
检测报错重新启动爬虫
" c# W  Y8 ~+ h1 X+ U0 u5 T无需手动处理错误信息
$ {+ w8 M9 n* G% k
8 [+ E' `; B' P# d& g/ N# V6 d缺点：
无法收集子线程错误。

：return None
4 [. _6 g' r  |! T/ |. d9 c2 F
* z" X5 i8 }9 B3 F5 ^6 nrequest.parse(
        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
* Z( U  T' H2 t4 L; |: p3 B9 E        #login="taobao",
& @: E, F' Q8 q; I        type_url = "text",
$ Y* n1 t2 ~+ b        Parsing = 'xpath',
' ]( @6 N. o& _  D2 H5 f        label = {
            'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
' Y# k( C  q9 @# `: W& v1 ]; w" }5 `            'name':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/text()',str],
' k2 i* o3 \8 D! i* e$ c) s5 R            'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
+ ?( e, T4 D7 x! R" z8 B            },
7 ?3 n  R9 J6 _( |' r" H        write='result.txt',
( U- J1 ~: b, X1 B) |. N& t0 N        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
" J: A) r3 l, d5 }$ u0 ?2 W! K$ s        page=[True,"now_url.txt"],
; U, ]: O2 H# T% s        # texting 参数为是否启用连续爬虫
: i! t  r0 H; W7 @) K/ n        # 爬虫程序异常报错后重新启动爬虫
# Q3 V8 h" i$ V$ [        texting=True,
        ###
        write_SQL={
            'host':'localhost',
- s7 F3 k; N9 `1 y            'post':'3306',
            'user':'root',
            'password':'123456',
) ^! D! `: K2 c: e            'db':'example',
+ w0 P* \+ s' }( c            'table':'example'
( e: X( u1 T: t$ i# [2 c9 u            }
).run()

第十种玩法：多线程爬虫
特点：
4 P. n- o' T5 U+ ?5 L- ?爬虫速度加快，
更好的利用了线程。

缺点：暂无
& t  p- Z) v0 K+ _; k
：return None
* F  Z+ o# y6 X# @5 h
4 b4 V) h5 ]" Z. |2 prequest.parse(
( M! H7 N/ f5 {4 L- ^4 `( m* f        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
1 p6 {5 e& K* T: c" E* Y        #login="taobao",
+ p6 x; m( ^: ]1 e: A& C& k        type_url = "text",
  F' k9 k# \# u7 C        Parsing = 'xpath',
& c0 U6 n6 F2 n6 o- T8 a7 H2 W2 A        label = {
            'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
            'name':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/text()',str],
            'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
/ i; K/ F% W9 W) b; p* l            },
        write='result.txt',
        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
# ~1 W$ E0 p8 X  r( s7 E        page=[True,"now_url.txt"],
1 k$ T! s0 X5 w/ H5 g        #clean=True,
( T6 X6 Z1 h- k        texting=True,
& Z1 n! W. T* ~+ ^4 V3 e0 Z        # status="threads" 启用多线程爬虫
        # Thread_num 为线程数目,默认为1 单线程
# n. L1 z/ P7 H7 ]        status="threads",
5 d: w0 b2 b. U0 ~. r# f% w        Thread_num=3,
8 E+ T: d7 v7 L% F        ###
& M, n" h& L2 a( M        write_SQL={
            'host':'localhost',
            'post':'3306',
) Y* C# Z+ `8 A3 d/ a0 g( `            'user':'root',
% q7 S  @4 B) T; v7 m            'password':'123456',
3 f' k0 V7 P) Q+ R$ C            'db':'example',
4 ^& t8 X5 \& X4 C2 x9 m2 v* m2 `5 B' r            'table':'example'
$ q0 ?" y4 A& O) r0 C            }
+ p! D1 w5 {4 K, N; k8 l$ P6 x).run()

第十一种玩法：多进程爬虫
特点：
爬虫速度加快，
更好的利用了进程。
% N/ b. Z5 Z: F3 g3 _' C- q
缺点：暂无
4 d9 n. v! ~9 |# e6 ^* q' q3 |* o: \
：return None

' N- b9 H, v0 H! E" x2 j& cfrom simple_crawl import request
! Z' t' H! L% `0 @( h2 y; Rrequest.parse(
' x* a2 M8 M: J2 s  R& O        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
        #login="taobao",
- N- n) v, t1 P        type_url = "text",
# @4 p# _" p4 p2 G        Parsing = 'xpath',
8 H0 I0 a. c: Q3 }( O) V4 f0 @        label = {
            'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
            'name':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/text()',str],
$ Q; Z6 X  H# N9 Q' N            'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
/ X; B: A6 s! g/ v6 }6 x$ o            },
        write='result.txt',
        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
& I: b. V4 }) L9 U3 c8 \( z7 _        page=[True,"now_url.txt"],
        #clean=True,
' q; O; y5 f; M( d        texting=True,
        # status="multiprocessing" 启用多进程爬虫
2 t. _/ z% ]3 C% @& P        # cpu_count 为启动代码核心数,默认为系统核数一半
        status="multiprocessing",
1 o8 N0 K, N4 _; _0 K% u4 A; s        cpu_count=2,
6 M, z3 b. Y: U# z6 U        ###
        write_SQL={
            'host':'localhost',
            'post':'3306',
1 \. d3 W. s8 n& k. I            'user':'root',
) k5 M$ N4 b" K  y) K7 T            'password':'123456',
) j. }/ O" q; w" j9 u2 h            'db':'example',
$ z4 X. I2 y* \" _5 u8 f8 u% f            'table':'example'
$ k- q  x$ G* R            }
).run()

第十二种玩法：异步多线程爬虫
特点：
爬虫速度加快，
7 B( Z9 n" k* ?异步使得爬虫无等待时间，
同时使用多线程速度明显加快。

0 f' p% M* r8 r4 O) g% i0 j缺点：暂无

：return None
# I4 [% q* G' [3 Z' g
  v" w" t5 _5 c* hfrom simple_crawl import request
request.parse(
        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
        #login="taobao",
        type_url = "text",
- u7 v9 h% T4 s/ b* P6 y        Parsing = 'xpath',
        label = {
- F4 t- @2 F6 W- S- ^            'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
  f- o3 ?! v/ o            'name':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/text()',str],
& I8 G* I# g+ p/ E0 r            'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
            },
        write='result.txt',
* Q7 s3 T5 j8 W. V. h; G9 Q        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
        page=[True,"now_url.txt"],
        #clean=True,
        texting=True,
" @2 F0 {' c! v( G  X% p        # sem 参数为异步引擎数目,默认为5
        # 其他参数同上
9 d4 t& h6 F8 [: m' }' s        status="aiohttp",
        Thread_num=3,
        sem=5,
1 V0 N! H4 i8 |. n8 P5 ~, [- a; l        ###
        write_SQL={
            'host':'localhost',
0 i8 q  C7 V: }            'post':'3306',
! ~) f; R. d' U$ B9 p            'user':'root',
7 P% c! ]$ T8 u# q, @9 N            'password':'123456',
8 R2 v1 L9 k! Y; t# q) Q            'db':'example',
/ h: x' |; j0 S/ G% u3 `4 _/ U            'table':'example'
' _' u. D* s. K0 e/ ]+ o8 {7 l2 L            }
).run()
- |5 V* N- U1 S" `# S. G
第十三种玩法：异步多进程爬虫
1 {4 D$ b& V- h特点：
! D( r, b) s( _2 `8 C; \! U/ Q爬虫速度加快，
异步使得爬虫无等待时间，
' W+ J1 O, T) C2 o* ]同时使用多进程速度明显加快。

9 G6 m6 u- Q3 f  C" m& m缺点：暂无

：return None

$ W" R2 R3 d+ G" h2 Rfrom simple_crawl import request
request.parse(
( z3 O3 |. y& X# V        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
        #login="taobao",
        type_url = "text",
        Parsing = 'xpath',
. F" @- L! f, i+ j' t* t# J# _        label = {
            'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
            'name':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/text()',str],
            'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
. i8 y% U* E6 _. Y8 G, C& M  U            },
4 S" x, K2 K( g7 v7 v8 v7 y, A        write='result.txt',
        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
4 t4 j. s! C% ?" |' r        page=[True,"now_url.txt"],
        #clean=True,
        texting=True,
        # 参数如上
* k2 k4 F5 i; u% P8 F; l        status="between",
6 Z' }! x0 \. z* B$ }        cpu_count=1,
8 g  m9 C  f6 ^' j4 b        sem=5,
+ y/ q; s5 ^. \( ^8 |        ###
, J2 r; N7 A% [7 t        write_SQL={
% x1 q" V% }& V8 u- n7 {            'host':'localhost',
6 g4 c, p5 w8 H2 }4 r            'post':'3306',
            'user':'root',
6 L8 {& M, P3 Q4 E# B            'password':'123456',
$ B7 G! ?! f6 ^8 {            'db':'example',
7 ~3 |5 E; L* B2 ~+ v            'table':'example'
3 {  z3 P# B7 D: h$ r            }
6 r( U: I/ {4 L. Y) X% ?* |( T).run()


功能介绍完毕🤞
最后还是希望你们能给我点一波小小的关注。
( ?" y# f! B2 W1 [/ j奉上自己诚挚的爱心💖
4 ?  F% A0 n6 _, C7 E* q————————————————
5 A2 A% d4 \' P6 A6 Y$ l版权声明：本文为CSDN博主「꧁༺北海以北的等待༻꧂」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_45414559/article/details/106005684


) L+ x+ q# H; o/ h/ k

738391227

66666666666666666666666666666