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

zhangtt123

仅需一行代码写爬虫–simple_crawl
simple_crawl
仅需一行代码即可达到爬虫效果
项目地址(欢迎star):https://github.com/Amiee-well/crawl
使用方法
" i* P$ s; V" cpip install simple_crawl
& {( e- F# Y6 A; c
### 以下源代码为简单介绍,详细功能介绍再源代码之下
from simple_crawl import request
5 N1 s8 x; `7 Y: e" yrequest.parse(
! ^& L8 {( X. b" z6 [8 J3 U3 G        # status 参数为运行状态,支持单线程多线程多进程协程以及联合
        status="aiohttp",
0 p3 J4 o7 g4 T( B+ J3 p# m/ D        # url 参数为爬虫网址,单线程状态为字符串格式,特殊状态为列表格式
        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
        # login 参数为获取登陆信息,如淘宝等网址需要登陆信息
# B) f  u5 J* \% E% [    #login="taobao",
    # type_url 参数为返回源代码格式,支持text和json,默认返回text
* o3 K/ N1 t% Q1 |2 G. X8 o& n% }    type_url = "text",
    # Parsing 参数为解析方法,支持re、xpath和beautifulsoup
    Parsing = 'xpath',
: D% h) I. s: Y( o! D8 S3 a    # label 参数为爬虫解析过程,字典格式,详情见下方
& {/ f* l0 c( H' G    label = {
! S4 h7 V  h1 h            'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
; O) Z5 l# H5 w; o- E            'name':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/text()',str],
( Q' H1 R- `2 B7 f            'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
* s0 [' c9 ]; n$ m  {     },
     # write 参数为爬虫结果保存,支持txt、csv、pkl、json,注:特殊状态爬虫信息容易混乱
- \% U: U1 G% ]2 A! k     write='result.txt',
     # next_url 参数为下一页爬虫地址,@必须为href,仅支持单线程爬虫
     next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
     # page 参数为断续笔记,第一个参数是否启用笔记,第二个参数选填默认page.txt,仅支持单线程爬虫
: r9 Z; b9 a, u. \+ k% [     page=[True,"now_url.txt"],
; |. f! ]' f: S# W* t     # clean 参数为是否进行数据清洗,防止大量爬虫收集无用信息
     #clean=True,
     # texting 参数为是否选择连续爬虫,避免爬虫过程中出现非代码问题报错结束爬虫程序
0 N. w  W2 r7 C4 @7 x! p     texting=True,
     # Thread_num 为多线程数,默认为1单线程,支持多线程状态和异步状态
$ P. ^2 R4 R5 P$ s     Thread_num=3,
     # cpu_count 为多进程数,默认为1单进程,支持多进程状态和联合状态
/ o: s, ~& N. Q' A     cpu_count=1,
     # sem 为异步控制数,默认为5同时启动,支持异步状态和联合状态
4 n# f5 w" `% T     sem=5,
     # write_SQL 为是否写入数据库,默认否
4 j+ S( }& }6 y     # host 参数默认localhost
     # post 参数默认3306
     # user 参数默认root
     # password 参数必填,必须正确
     # db 参数为即将存入的数据库名,若不存在自动创建
# F; ~3 _. K; F- I3 g6 [3 T     # table 参数为即将存入的数据表名,若不存在自动创建
5 S$ a, i6 m8 ?; s  R4 n! K     write_SQL={
# n' u3 @* r' x         'host':'localhost',
+ [' }! c" b5 J0 y         'post':'3306',
         'user':'root',
         'password':'123456',
! }1 P# c8 b% k         'db':'example',
         'table':'example'
      }
! W) f& ^  |! W8 @: g, J. t).run()

介绍一下crawl参数设置：
3 }/ R2 R& f  b: {7 d: F. ]
4 p8 S; u% ?3 V  t, G'''
5 u4 p! A  X/ |0 h$ g2 b$ U* T/ P3 f单行代码爬虫程序执行
:param status:启用爬虫类型,支持普通爬虫、多进程爬虫、多线程爬虫、异步爬虫、异步多进程爬虫,参数请参考文档
:param url:即将请求的url地址,仅支持get请求
; o' r# Q2 R/ N( W, M  o:param type_url:请求url后返回格式,支持text和json格式返回
:param Thread_num:即将启动多线程个数,默认为1单线程
, R& n; ~4 @" }/ h3 f7 }:param sem:协程信号量,控制协程数,防止爬的过快,默认为5
0 K2 ?/ L5 x; `8 Z9 [+ A:param cpu_count:运行爬虫使用多进程cpu核数,默认为系统核数一半
:param login:模拟网站登陆,保存登陆信息
:param Parsing:爬虫方式,支持re、xpath以及bs4方法
:param texting:是否启用连续爬虫,爬虫程序异常报错后重新启动爬虫,
% Q  d% ^, w/ t                       多次报错结束程序,默认否
:param label:选择器内容,字典格式保存,
                     字典值为列表格式,第一个参数为选择器,第二个参数为转换类型
  h3 W/ z9 _& o                     第一个参数必填,第二个参数默认str类型
& e9 ^9 D! h/ ]/ ?6 t7 t:param write:是否写入文件,支持txt格式、csv格式、json格式以及pkl格式,默认否
' C3 o* Q3 s( y, f( n1 p6 i:param next_url:是否跨页爬虫,选择器内容使爬虫继续翻页爬虫
- z! V& d: x) e/ u$ x:param page:是否选择断续笔记接手下次爬虫处理,默认否
- e! y' y& |2 ?' Q, K2 \9 Z:param clean:是否进行简单类型数据清洗,默认否
2 t9 i' e) Y$ B: ?( f( K:param write_sql:是否写入数据库,默认否
% e5 ^& G3 [8 Z0 ~; H9 g                         'host'默认为'localhost','post'默认'3306','user'默认'root',
                         'password':'密码','db':'数据库','table':'数据表',
                         检测库是否存在,若不存在则创建,若存在则直接插入,
0 q# U0 X( d/ l                         检测表是否存在,若不存在则创建,若存在则直接插入
/ c: m! o0 |5 o2 r$ B) }:return True
'''
9 G2 N; \) j! H8 Z- F7 E介绍玩法
接下来介绍的均为调用第三方库的情况下运行：

% K- F8 u" ^1 a$ ffrom simple_crawl import request
0 Q' F/ ^9 p* R  |: W9 O) ~* X第一种玩法：输出源代码
+ L& S( v/ E: X5 \* J+ B9 k调用requests库进行源代码请求。
% \9 X" K( i& o. D0 L
7 E* R- f9 R9 f特点：
8 z7 E1 }+ `, U! P! }; L请求失败则调用ip池处理重新请求访问，
出现五次失败默认网址输入错误。
, k; h4 d6 B" R/ y6 n支持text以及json字符串返回。默认text。

缺点：
; h2 t* n2 H$ l% b# P) `( D暂时只能进行get请求，不支持post访问
2 Q, S3 e8 k' Q
：return text or json
$ k% ~+ `. k8 n* W
request.parse(
        url = "https://www.douban.com/group/explore",
        type_url = "text"
).run()
/ K% _* Y$ Q' s# return text

2 t) Y6 e5 S" F; C第二种玩法：模拟网站登陆并保存信息
7 b8 L! \9 c: l$ S调用DecryptLogin库请求登陆访问。
2 B5 C, d( h; k% n  a
ps：DecryptLogin库为大佬皮卡丘写的一个很不错的模拟网站登陆库，在此引用一下，因为单行爬虫原因不支持账号密码登陆，我将大佬写的二维码登陆使用过来了。再次感谢大佬开源
% g  l7 y, Y8 [: R( [( }; Y在此放出文档地址
DecryptLogin库中文文档：https://httpsgithubcomcharlespikachudecryptlogin.readthedocs.io/zh/latest/
) |" Y' }" W8 m0 c4 h9 A
  p! r( t/ d) n/ e特点：
' h$ P$ r, O* @! G) D0 f5 D1 a将DecryptLogin库中二维码继承到此库（非二次开发）
3 n8 ?8 ?4 s& z) f& i6 ~支持QQ群、QQ空间、QQ安全中心、淘宝、京东和斗鱼登陆（大佬登陆库中所有的二维码登陆）
9 f5 o+ H5 m7 t' |3 r7 K保存session.pkl信息到本地方便下次登陆运行
5 X5 `# |' Y( M( B) z
% h0 s/ W) Q5 l6 h; N缺点：
" f" Q3 P6 e* U$ osession.pkl登陆信息过时无法自动删除。
导致下次登陆疑似cookie无法正常登陆。
% P$ F9 q# U$ ?8 M3 j0 e) e) M! F6 g
+ f; s; F! c& j+ R:return session
" Q4 {4 }! S8 o0 w
5 U& _; ?+ ]8 c6 xrequest.parse(
        # 臭不要脸的推广一下我的店铺
        url="https://shop574805287.taobao.com/",
        login="taobao"
).run()
& s8 Q* D8 j* ^# return text
& b$ ~4 j$ |* t. ?) ^
第三种玩法：爬取网站信息
爬虫库自然少不了爬虫的过程
& Z: R& i, u5 }
特点：
8 }7 K# ^& c$ s! ~支持re库，xpath解析以及bs4选择器。
8 x4 p/ j; }2 S爬取方法为字典格式。单方面输出。
字典键为保存的字段名称。
字典值为列表格式：第一个参数为选择器，第二个参数为转换类型。第一个参数必填，第二个参数默认str类型。

缺点：暂无（等待小伙伴们发现）

：return reptile_results
, E* N9 d0 A0 F
request.parse(
5 o6 u# F. r  E* u( C        url='https://www.douban.com/group/explore',
' @; D& G2 V( p% B3 z8 g6 I        # 字符串格式,选择器方法。
0 |" L8 l% R$ J" A0 @+ `& Y" P' |    Parsing = 'xpath',
    # 字典格式,参数如上。
    label = {
        'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
- f  k$ h( |4 }) c# M        '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+ |, O0 U+ g3 I. H# I        }
, D+ N  o; u9 y% Z! @$ i).run()
# return reptile_results（list）

第四种玩法：自由保存信息
0 c. _9 f. t+ p$ m3 ^0 O- Y目前版本支持保存txt、csv、json以及pkl四大主流文件。日后版本更新将发布更为全面的保存方法。
2 `1 J3 F0 K& v  Y9 c
特点：
写入文件均为数据格式传入文件。
: H+ T* j! ?6 V/ x9 d. E- O且输入格式规范方便阅读and省事。
- N, J" p0 `# }) m2 {
8 f$ H- Z+ `1 o$ ]缺点：
2 `5 D( u4 x) k& u  c保存格式仅四种，
不方便用户之后读写操作。
1 o& n3 }: x/ w+ b+ T
：return file
0 f( e' }6 E9 ?$ z0 x4 o. }
" L/ p2 S7 x) F3 o% X1 v: K3 c. |request.parse(
        url='https://www.douban.com/group/explore',
7 P1 D0 O1 F, h    Parsing = 'xpath',
    label = {
7 u7 R. o0 H3 b, K- F( x7 z) r        'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
, G: d  E2 Y4 K# }  S6 o3 T        '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'
' J2 ?* D! L$ R: T( Y& O  l).run()
# return file
! P9 |) ?/ f6 g6 d
第五种玩法：读取下一页 url 地址继续爬虫
5 }; V- o$ i2 @* Z这也是每个人都担心的问题，仅仅一行代码怎么可能翻页爬虫。这还真能做到哦~
: u8 t( H; c# ^9 W- ?9 k; c7 [: z
特点：
继承之前的Parsing参数选择器选择方法。
& }2 F- p8 M* e# T8 a) b/ V在这里可读取到解析后的下一页 url 网址。
方可继续进行爬虫处理。方便用户使用。
. R( _$ m# p( p& Y  s" E) Y; K4 \
$ Q4 ^2 x0 n. |2 M缺点：
2 U0 o( R. q8 J) l8 i* w若爬虫时下一页 url 地址改变，便结束爬虫。
只能爬取所给 url 地址中的信息。
无法进行某一界面的多个网页爬取返回。
. y2 ~9 Y4 U. R1 M造成访问页面单一流失。
. o' {3 i8 T8 A% {8 \2 ~
：return None

request.parse(
2 u- g% \& h  \# t+ N" Z$ H! f4 T        url='https://www.douban.com/group/explore',
$ m: r! k  ]7 Z) f( w; ~0 W    Parsing = 'xpath',
0 s& t; [) S. P  n7 x( O" |. a& {    label = {
' X2 r3 ~, x" n$ D* K9 n# t- O        'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
4 C0 \4 q8 N* X- W) r: v, V        '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 O/ P5 g" N3 j- Q( W: B        },
1 J8 I% ]5 f5 P5 _' _    write='result.pkl',
    # 字符串格式,根据Parsing方法继续请求下一页a中href
% C7 i3 t4 m. y    next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
) r7 B' S' S8 ~7 J).run()
  x. \: L1 D( b1 E1 }# return None
% D$ }2 {# _. g  X. k4 b: {3 i
第六种玩法：爬虫网页保存
& D4 B( K& n& h听说过爬虫断续重连的朋友应该懂得这是个什么神仙操作。每次爬虫运行期间好好的，睡一觉醒来发现代码报错了。。。这就是个很难受的事，还不知道之前爬取到哪一页了，只能重新爬虫了啊！
7 i; }9 x8 K8 K: u" F$ v* t. L/ x; |
2 q  I+ i6 g6 I  ], p- T: P特点：
$ \; Q/ S" @  r) O8 _7 r持续输出断续笔记。
将此次爬虫的 url 地址保存到一个文本文档内部。
下次读取文本文档即可快速进行直接断掉的爬虫 url 地址继续爬取所需。
* [% T& L5 T: k$ H
缺点：
# |. C* a6 F- a+ O读取内容不单一。
. ]. T1 k- t& C: H' S. }导致下次爬虫无法正确读取上次爬虫留下的痕迹。

* w& u5 E) X+ b* Y4 B( O7 D：return url_file

request.parse(
5 A7 m$ k8 M5 i% k) K( Q. y    url='https://www.douban.com/group/explore',
    type_url='text',
' B+ z7 M6 b3 U& K6 r: C    #login='taobao',
    Parsing = 'xpath',
  Y$ S$ @& M% Z    label = {
        'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
- k; r& t, r8 K8 a- c. P# G2 z        '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]
        },
. X) v8 a* _7 A8 C    write='result.pkl',
- U2 t6 \  p& ^4 _    next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
2 ]1 Y4 G# k& ?5 G4 f/ ~, P" m    # 第一个参数为是否需要断续笔记。
" j. q6 L( W2 @& }: k3 f    # 第二个参数为断续笔记保存位置。
    page=[True,'url_page.txt']
).run()
# return url_file
* K; K' c' d- |
( ^/ Y) u5 S: R/ b8 j第七种玩法：简单数据清洗
数据拿下后，直接保存到本地有些大佬可能觉得很辣鸡，连清洗都不清洗就存入本地了？那得拿到多少废数据脏数据。那么接下来介绍一下清洗参数。

/ V6 w3 ~: L% a& D2 [特点：
' v$ f* J$ I* Q8 L* u1 i本人曾写过一个底层数据清洗。
; _- F. A8 N$ W6 ]/ C$ F能将列表格式数据进行归分清洗。
主要内容请参考另一篇文章
如下连接：数据清洗
; X3 p3 U( |" O
缺点：
数据清洗格式简单。
数据清洗内容单一。
- i4 C0 I- e6 [( X  H8 {无法完全做到绝对清洗。
, c7 a/ E* h$ B: @) [有待改善。

：return keyword_list, value_list

/ B2 H2 z% E- a, U8 L+ E& trequest.parse(
    url='https://www.douban.com/group/explore',
    Parsing = 'xpath',
    label = {
6 y! r# n; [2 {8 H! r, k2 w        '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],
7 ~/ K5 S6 s( o        'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
. j. e- v6 c9 B9 r+ w& D) Y: c        },
/ T4 c$ w% d/ S* G/ _    write='result.pkl',
    next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
    page=[True,'url_page.txt'],
5 E- x3 X* B: f    # bool类型,默认不清洗
    clean=True
).run()

* f/ X! S3 K0 w( y+ J" P第八种玩法：爬虫存入数据库
存到txt、存到csv、存到json、存到pkl，那也太low了吧。现在流行的数据库用不了么？那是不可能的。。
$ i; d7 ^( P6 l4 Y7 ~
  ?& @+ ~$ x! p  k+ P特点：
信息存入MySQL数据库。
- X0 r! a. t% G) p! I可连接docker远程数据库。
数据库的库名可以不存在。
# g; D! `  p# X& [. R数据库的表名可以不存在。
根据之前传入字典键与值参数判断表类型。
自由建立数据表传入信息。
  A8 k' F. V5 R8 t( c
缺点：
仅支持MySQL数据库。

* I  Z1 ^* I3 j& l: [5 x) s- _1 f4 z7 I：return SQL

% W/ k  M% p7 y# x# Qrequest.parse(
    url='https://www.douban.com/group/explore',
" W' _! E4 ?6 ?+ i5 c# i    Parsing = 'xpath',
. D( L, s- O8 W# f% U    label = {
9 G$ ^5 F) v5 L        'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
% F. W% X! ^  i; o0 L        '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]
& c; J  W* `1 [) w        },
; e, a' W! ]; j    write='result.pkl',
    next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
7 |8 Q  P' J# R  l    page=[True,'url_page.txt'],
    clean=True,
" u1 k) J% Y3 i7 D" d8 t. Z- r1 Q    # 字典格式,
$ |- ^+ z3 K3 j9 Q! E! v5 ?    # host可有可无,默认localhost
    # post可有可无,默认3306
    # user可有可无,默认root
* H* b1 g! b4 Y! `4 @+ G    # password必要参数,数据库连接密码
% Q5 e9 R" n# H* U. f    # db必要参数,数据库即将存入的库名
    # table必要参数,数据库即将存入的表名
    write_SQL={
4 x% w) k) z  t% j6 z6 o3 b        'host':'localhost',
        'post':'3306',
        'user':'root',
% ]+ Z& ?; x& Z. f. S        'password':'123456',
        'db':'example',
5 {' w. H4 P8 c0 g  H        'table':'example'
        }
    ).run()
2 L- u' e5 t8 p: `+ ]
$ W/ Z( `3 q5 t第九种玩法：重新启动爬虫
爬虫最让人厌烦的就是被一个不痛不痒的错误信息给终止爬虫了，比如意外的远程断开链接等低级非代码错误，报错之后还得重新启动断续爬虫，就显得很麻烦。我做了一期爬虫程序异常报错后重新启动爬虫，多次报错结束程序。

; U( b1 J5 X* N: ~特点：
/ f+ f1 i6 P! e  ?8 ~" [$ r检测报错重新启动爬虫
9 ?) o7 v! P7 o+ O4 D4 P5 P' F无需手动处理错误信息

3 Q4 N3 z% @, n7 q# _# X* n( K缺点：
2 U9 N  `8 s2 D8 h' @/ C无法收集子线程错误。
  ?' i$ O+ k! Y* A( g
：return None

1 F/ L7 s2 E* \: X2 z" P* n9 _/ O* brequest.parse(
( r: Z2 W( C! `+ a; J9 f* n% y        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
8 b, J3 L+ n* O- r$ k5 e        #login="taobao",
" T0 J6 U6 f. Y) V        type_url = "text",
        Parsing = 'xpath',
- M) ]; z( d' H  \& {7 d9 U        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]
            },
+ q' A/ A' Q7 J        write='result.txt',
7 D+ h. T, B1 H8 y* F% g        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
        page=[True,"now_url.txt"],
        # texting 参数为是否启用连续爬虫
+ o% M- }  y, W/ G/ C2 A        # 爬虫程序异常报错后重新启动爬虫
5 P# D/ h. _; }- y4 q* q- m# X: @        texting=True,
        ###
        write_SQL={
. ~& F, U$ c4 I  r            'host':'localhost',
            'post':'3306',
5 Y) A& `# M: m) ?8 W            'user':'root',
            'password':'123456',
) u2 S7 o9 f- g            'db':'example',
            'table':'example'
            }
  o8 e4 t2 s) z+ A/ L).run()

/ e% V( @  Q4 ]" R第十种玩法：多线程爬虫
特点：
% W( |- c( v% C4 e$ D) \" ]# a爬虫速度加快，
更好的利用了线程。

缺点：暂无
& ^  }2 Z: Z, h/ c0 q4 |
：return None

request.parse(
        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
        #login="taobao",
7 r8 t. D5 k' ^% m+ [/ z2 h        type_url = "text",
        Parsing = 'xpath',
        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],
0 Z* W  S8 c) ^7 M2 _1 t1 b2 i            'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
  u: M2 X. [% Z. ^! i9 }( L            },
        write='result.txt',
        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
        page=[True,"now_url.txt"],
+ |! L% l  C* l1 ?        #clean=True,
$ @6 B# B, k# o        texting=True,
        # status="threads" 启用多线程爬虫
        # Thread_num 为线程数目,默认为1 单线程
        status="threads",
. A& K5 w  I+ n( k+ V) A        Thread_num=3,
( A) x, s. h. x: Y4 u+ P        ###
        write_SQL={
            'host':'localhost',
- ~- G" i  v  X) }) Z+ {3 s            'post':'3306',
. Y8 ?. W4 g, _: S3 |; O' k            'user':'root',
            'password':'123456',
            'db':'example',
            'table':'example'
            }
).run()
$ S+ W! N, @1 F- E9 y& y2 ~8 f: m
- E# ^1 y. N' @/ n2 x5 h& [9 \第十一种玩法：多进程爬虫
0 c, ?* q8 K' t/ ?" P( D, ^特点：
! l0 r& d+ c& Z8 Q爬虫速度加快，
更好的利用了进程。

, A8 |* Z) l( T: i- w4 o缺点：暂无
5 `* V2 d  F% q$ w& _, g1 ]
：return None

- F# }* R7 {. u: Qfrom simple_crawl import request
request.parse(
        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
4 g: x# B# @7 A        #login="taobao",
        type_url = "text",
5 R/ o4 i7 B, ?5 m        Parsing = 'xpath',
        label = {
0 v! B" W3 T1 E8 L: _1 W            'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
5 K8 z6 Q1 R7 E! r5 Q8 @1 s            '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]
            },
+ e" E) U! A5 v" W) o" G( i# u        write='result.txt',
* g: |' U& O  `+ K        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
- t; |1 L; N5 c  f" z        page=[True,"now_url.txt"],
        #clean=True,
        texting=True,
        # status="multiprocessing" 启用多进程爬虫
        # cpu_count 为启动代码核心数,默认为系统核数一半
" B% N) }/ z3 O        status="multiprocessing",
% x8 m% T' ~: T' B5 J6 G        cpu_count=2,
2 @! i, s  t; n3 L+ K- A; |        ###
6 e' V& r. A! Z' l6 J        write_SQL={
+ ]0 ?; m* g- x            'host':'localhost',
            'post':'3306',
# F7 B( ?5 i& C, A* m            'user':'root',
$ e" z1 [/ z0 n            'password':'123456',
+ s3 m; M# m, @$ u, \            'db':'example',
            'table':'example'
* F8 k; v% U9 a            }
).run()

" ^$ \; @5 d6 ~1 f$ t1 l第十二种玩法：异步多线程爬虫
特点：
爬虫速度加快，
: u& P& k/ M# S3 ^# O" N异步使得爬虫无等待时间，
同时使用多线程速度明显加快。
$ v+ c- ?# `2 {& A, d3 y  q
缺点：暂无

7 q  X/ E9 d1 B& r$ G! A7 u：return None
! e* f/ O! V+ W0 O5 d! X9 c
! h7 J+ q$ Z  Bfrom simple_crawl import request
request.parse(
9 F0 b' M: s. l3 m' f+ A        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
) @8 \: x5 _4 S        #login="taobao",
        type_url = "text",
        Parsing = 'xpath',
        label = {
            'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
5 [+ L3 Q% r3 k# i2 \' _4 }$ I            '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]
9 ~  D4 }$ ?" L5 Y( p$ z. m            },
% }& q* j* Q; r* L, M2 K: f        write='result.txt',
! V, m+ O7 P* M3 q" f        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
        page=[True,"now_url.txt"],
        #clean=True,
        texting=True,
        # sem 参数为异步引擎数目,默认为5
        # 其他参数同上
        status="aiohttp",
        Thread_num=3,
        sem=5,
        ###
        write_SQL={
            'host':'localhost',
) `* l  c+ t5 }            'post':'3306',
8 C7 V* [% q: O. u0 C! l: T            'user':'root',
% f+ `4 _; u# G4 w/ p. a+ G            'password':'123456',
: X7 e- @  K) G! T9 n/ m; ^. B1 q            'db':'example',
            'table':'example'
# O$ G: I5 p7 m5 `. [            }
) I0 Y- g$ X; O- D/ z).run()
" J/ w7 e( M7 f. o' d/ I
5 h3 T9 E5 Z9 K第十三种玩法：异步多进程爬虫
4 h0 J2 L1 p$ E% ?$ L7 \& `5 n, \$ G特点：
爬虫速度加快，
异步使得爬虫无等待时间，
同时使用多进程速度明显加快。
8 n& X' d% M. \1 _8 j
4 n2 p4 i% N. j6 O: Y缺点：暂无

：return None
" q* U6 O6 C. b
  f" g: j+ s5 n3 \' _' Zfrom simple_crawl import request
3 |& _( P& I* e5 w1 z" xrequest.parse(
        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
- N* ^7 R, g5 q        #login="taobao",
' P2 P& d7 G5 f- j        type_url = "text",
        Parsing = 'xpath',
  W8 H; Y$ @$ Y  }$ P) U        label = {
. D% H' F! ]/ D* K6 P            '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],
0 q1 }* l6 c( b5 n            'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
            },
        write='result.txt',
+ B: Q. Q- q% S; q) ]/ g2 }4 r" i+ B        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
        page=[True,"now_url.txt"],
        #clean=True,
        texting=True,
        # 参数如上
8 {+ D( w0 _- W/ P/ M  Y        status="between",
        cpu_count=1,
3 u& @+ G' \" q        sem=5,
        ###
' p; @& @$ l4 X) `        write_SQL={
            'host':'localhost',
            'post':'3306',
3 q- E) j$ N& \8 G( r) o; D& q1 u            'user':'root',
            'password':'123456',
- G! [) v& @% a% K8 L( ^            'db':'example',
. b, A' D$ O+ `            'table':'example'
            }
).run()

# H3 V$ F' h# D- k1 r; k5 b' e7 d
功能介绍完毕🤞
最后还是希望你们能给我点一波小小的关注。
/ n" d- k  N- _7 Z: A! n9 i奉上自己诚挚的爱心💖
. T& T  I. T! O& C8 o————————————————
* k6 c' o0 m6 e% {版权声明：本文为CSDN博主「꧁༺北海以北的等待༻꧂」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
6 G2 Y: a% y; d原文链接：https://blog.csdn.net/qq_45414559/article/details/106005684

738391227

66666666666666666666666666666
, ?5 p- v% R& u% V