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

zhangtt123

仅需一行代码写爬虫–simple_crawl
# f! ]3 ^7 N! R2 Msimple_crawl
3 }* A0 r2 V+ h+ _仅需一行代码即可达到爬虫效果
& s0 Z7 n6 K! c* O项目地址(欢迎star):https://github.com/Amiee-well/crawl
8 F& l7 z1 c8 _6 k/ x6 z; X2 ?使用方法
pip install simple_crawl
: z" z- l- w6 f% z
### 以下源代码为简单介绍,详细功能介绍再源代码之下
; i2 b& G& J- S- X5 lfrom simple_crawl import request
! [. n) [) R2 y! K  y9 t; {request.parse(
5 h# y" }' R6 k. d" r        # status 参数为运行状态,支持单线程多线程多进程协程以及联合
$ p4 ^# j! {, Y! T: q! T        status="aiohttp",
        # url 参数为爬虫网址,单线程状态为字符串格式,特殊状态为列表格式
, O2 x( H; T; H        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
        # login 参数为获取登陆信息,如淘宝等网址需要登陆信息
1 Z1 y3 A( O2 e& h    #login="taobao",
    # type_url 参数为返回源代码格式,支持text和json,默认返回text
  N% p" |9 B! m. f    type_url = "text",
6 ]- C9 A) W* v8 i    # Parsing 参数为解析方法,支持re、xpath和beautifulsoup
    Parsing = 'xpath',
' K5 @) u- X7 }; f    # label 参数为爬虫解析过程,字典格式,详情见下方
    label = {
            'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
. u0 F* h. W- f0 o            'name':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/text()',str],
/ G+ B! d# f, ]- K% Y            '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',
     # next_url 参数为下一页爬虫地址,@必须为href,仅支持单线程爬虫
     next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
     # page 参数为断续笔记,第一个参数是否启用笔记,第二个参数选填默认page.txt,仅支持单线程爬虫
# o, D7 B% p5 R) Y, G3 z     page=[True,"now_url.txt"],
7 _9 Y0 |9 ], @9 Y% k     # clean 参数为是否进行数据清洗,防止大量爬虫收集无用信息
8 r0 \, M) o5 `     #clean=True,
6 \7 \2 s; s' s1 q$ l     # texting 参数为是否选择连续爬虫,避免爬虫过程中出现非代码问题报错结束爬虫程序
     texting=True,
     # Thread_num 为多线程数,默认为1单线程,支持多线程状态和异步状态
     Thread_num=3,
     # cpu_count 为多进程数,默认为1单进程,支持多进程状态和联合状态
* |+ v# o+ Q3 ?! _2 I# }     cpu_count=1,
4 w% O6 X3 p/ w1 w( m     # sem 为异步控制数,默认为5同时启动,支持异步状态和联合状态
     sem=5,
+ h" t- h& U9 ]4 O9 Q     # write_SQL 为是否写入数据库,默认否
+ }) i0 n8 X% b( J6 T8 \     # host 参数默认localhost
- ~3 e$ J7 G$ B2 l9 ^     # post 参数默认3306
     # user 参数默认root
! o1 R& q( s4 T8 k1 C! _     # password 参数必填,必须正确
2 I% B3 K% X1 g/ H5 B6 F2 r     # db 参数为即将存入的数据库名,若不存在自动创建
% S  T9 M: d( d; g2 `! ?     # table 参数为即将存入的数据表名,若不存在自动创建
2 ]4 k0 n7 g* H) T; T2 e     write_SQL={
         'host':'localhost',
         'post':'3306',
         'user':'root',
         'password':'123456',
         'db':'example',
. n$ L% K7 ^3 z* ]/ i% N# u5 Z3 T         'table':'example'
      }
).run()

介绍一下crawl参数设置：

5 p5 @9 r& D' ?'''
单行代码爬虫程序执行
: @8 r% ?9 ^; E$ e6 k! k:param status:启用爬虫类型,支持普通爬虫、多进程爬虫、多线程爬虫、异步爬虫、异步多进程爬虫,参数请参考文档
:param url:即将请求的url地址,仅支持get请求
:param type_url:请求url后返回格式,支持text和json格式返回
:param Thread_num:即将启动多线程个数,默认为1单线程
:param sem:协程信号量,控制协程数,防止爬的过快,默认为5
:param cpu_count:运行爬虫使用多进程cpu核数,默认为系统核数一半
4 v9 ~0 F; ]1 ^$ K:param login:模拟网站登陆,保存登陆信息
) R! P: M- Y  c:param Parsing:爬虫方式,支持re、xpath以及bs4方法
0 X: z' u& h% B7 y8 h( ~:param texting:是否启用连续爬虫,爬虫程序异常报错后重新启动爬虫,
                       多次报错结束程序,默认否
0 ~9 X7 A& d2 J3 w:param label:选择器内容,字典格式保存,
                     字典值为列表格式,第一个参数为选择器,第二个参数为转换类型
                     第一个参数必填,第二个参数默认str类型
:param write:是否写入文件,支持txt格式、csv格式、json格式以及pkl格式,默认否
:param next_url:是否跨页爬虫,选择器内容使爬虫继续翻页爬虫
:param page:是否选择断续笔记接手下次爬虫处理,默认否
4 N' p' G  a$ z:param clean:是否进行简单类型数据清洗,默认否
:param write_sql:是否写入数据库,默认否
                         'host'默认为'localhost','post'默认'3306','user'默认'root',
" h6 G4 G3 J4 P4 }5 |                         'password':'密码','db':'数据库','table':'数据表',
! e& N; _, G" T* y) y. T                         检测库是否存在,若不存在则创建,若存在则直接插入,
                         检测表是否存在,若不存在则创建,若存在则直接插入
1 k) Z; k9 G. @% X/ J$ P" I7 J:return True
'''
6 O8 R& l6 i) @& R. p  Q' M介绍玩法
接下来介绍的均为调用第三方库的情况下运行：
7 t- d2 g" O1 E1 H
0 e$ I, `7 o% \+ ^0 {. L. Ufrom simple_crawl import request
1 B( d1 M% S5 N6 A第一种玩法：输出源代码
2 ~/ m$ K6 c$ H6 y3 L; X调用requests库进行源代码请求。

特点：
请求失败则调用ip池处理重新请求访问，
出现五次失败默认网址输入错误。
支持text以及json字符串返回。默认text。
5 g0 `! R3 k$ I- c% [
缺点：
2 u# s& `/ c% e  f9 y7 p4 o! s/ f& a暂时只能进行get请求，不支持post访问

$ l" M4 }( e2 L- e：return text or json

request.parse(
        url = "https://www.douban.com/group/explore",
        type_url = "text"
).run()
# return text

& ?' t- o+ s( m1 i% J) F/ j" M! |第二种玩法：模拟网站登陆并保存信息
调用DecryptLogin库请求登陆访问。
& `9 f7 f3 b! y+ r8 t& s
0 F% V; H, Y: s. W* }, h& i0 z. wps：DecryptLogin库为大佬皮卡丘写的一个很不错的模拟网站登陆库，在此引用一下，因为单行爬虫原因不支持账号密码登陆，我将大佬写的二维码登陆使用过来了。再次感谢大佬开源
在此放出文档地址
DecryptLogin库中文文档：https://httpsgithubcomcharlespikachudecryptlogin.readthedocs.io/zh/latest/

特点：
8 J; @1 E7 w* s5 \. A- z* v将DecryptLogin库中二维码继承到此库（非二次开发）
3 Q. }5 t3 }% p  q支持QQ群、QQ空间、QQ安全中心、淘宝、京东和斗鱼登陆（大佬登陆库中所有的二维码登陆）
, D* z- \- p! @9 K保存session.pkl信息到本地方便下次登陆运行
* B! r+ P5 K3 S
缺点：
session.pkl登陆信息过时无法自动删除。
4 k& L7 j* K" ~/ D9 O. W导致下次登陆疑似cookie无法正常登陆。

$ q/ C$ e! ~, \# Q( @* R:return session
+ [$ ?0 `2 f+ w- ]
request.parse(
        # 臭不要脸的推广一下我的店铺
% m% G3 |) N( @, n        url="https://shop574805287.taobao.com/",
) G4 }, Q  ?. j  L( k* h: d        login="taobao"
).run()
# return text

# y0 f1 E6 \4 g第三种玩法：爬取网站信息
% M4 |$ S0 u3 m- r) G# j4 n6 u  `爬虫库自然少不了爬虫的过程

特点：
支持re库，xpath解析以及bs4选择器。
爬取方法为字典格式。单方面输出。
字典键为保存的字段名称。
5 h" d7 s5 a1 ]4 @% i, I字典值为列表格式：第一个参数为选择器，第二个参数为转换类型。第一个参数必填，第二个参数默认str类型。

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

# j* k6 G- r% E; ~* J6 y' ^- N：return reptile_results
$ X2 p! C9 _! e# ?) B) l
request.parse(
; _& {" r- a3 s* p+ L% @        url='https://www.douban.com/group/explore',
        # 字符串格式,选择器方法。
$ z: H$ H% D* C* z3 ?4 Y    Parsing = 'xpath',
/ x) t. y2 o# }9 j$ R" E8 m5 x    # 字典格式,参数如上。
. h, S6 n3 d/ K5 H9 ^% d5 f3 t    label = {
! A" U" P2 Y$ J: s. R        '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],
8 ]9 U2 B3 {* n# o0 o' m2 i  ~        'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
        }
).run()
# return reptile_results（list）
8 g& h9 {6 W  J+ w
  o. d* ^/ L. R4 O0 p第四种玩法：自由保存信息
0 |6 M5 x+ s# u$ v$ {0 G1 C2 M目前版本支持保存txt、csv、json以及pkl四大主流文件。日后版本更新将发布更为全面的保存方法。

特点：
写入文件均为数据格式传入文件。
且输入格式规范方便阅读and省事。
" f  d, c7 b6 j
缺点：
6 E4 o: ?; [% U# ~, D1 p, l1 Z保存格式仅四种，
不方便用户之后读写操作。

：return file

request.parse(
        url='https://www.douban.com/group/explore',
    Parsing = 'xpath',
  h) O5 i$ g8 @: ~6 v    label = {
# [2 S8 Z+ R$ c! 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],
% l/ z9 ^: q  i; S9 O! Y! `- k# ?        'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
4 ?9 i+ `- T6 P% c  U/ D        },
    # 字符串格式,具体保存位置填写
" ]2 F9 U, Y6 h' V. u2 @% `% r    write='result.pkl'
. u* K; c$ S5 ]! e$ s).run()
# return file
% S. s/ H: Q% t
第五种玩法：读取下一页 url 地址继续爬虫
5 ~& {# \& }( D; ~这也是每个人都担心的问题，仅仅一行代码怎么可能翻页爬虫。这还真能做到哦~

. ^5 T4 l7 q! E* g8 I特点：
继承之前的Parsing参数选择器选择方法。
在这里可读取到解析后的下一页 url 网址。
0 r, u; Z7 i' f$ J2 e方可继续进行爬虫处理。方便用户使用。

缺点：
若爬虫时下一页 url 地址改变，便结束爬虫。
4 h" u8 l% t' z% p% Z  B只能爬取所给 url 地址中的信息。
无法进行某一界面的多个网页爬取返回。
造成访问页面单一流失。

9 V+ G* C; F4 M2 j. w$ y：return None
4 O3 K9 U1 B& V# S2 i' P
request.parse(
        url='https://www.douban.com/group/explore',
    Parsing = 'xpath',
    label = {
- j8 D* X/ {1 K' ?6 U/ j; c/ f& K        'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
+ w; T- L+ U3 e" Y- 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]
5 @. `$ r) C" G8 M* ?* w: f        },
8 Z* O0 o/ h* K2 }$ A    write='result.pkl',
: V) Z8 r8 _$ F8 U# I& t    # 字符串格式,根据Parsing方法继续请求下一页a中href
- I3 Y/ F8 r) |    next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
).run()
% [+ d5 [; _" M  j# }# n/ A, `# return None

3 s+ s3 {, J6 K7 U1 ]& z8 n/ f, \第六种玩法：爬虫网页保存
5 H3 B/ V# z, L+ H听说过爬虫断续重连的朋友应该懂得这是个什么神仙操作。每次爬虫运行期间好好的，睡一觉醒来发现代码报错了。。。这就是个很难受的事，还不知道之前爬取到哪一页了，只能重新爬虫了啊！

& M. H8 S8 Y3 u: p* b& N& v2 g! a特点：
持续输出断续笔记。
将此次爬虫的 url 地址保存到一个文本文档内部。
下次读取文本文档即可快速进行直接断掉的爬虫 url 地址继续爬取所需。
6 G( v* b4 J& ~5 }- h/ j$ _, `: ~1 r
缺点：
, b2 d( M( @( E读取内容不单一。
3 d5 m& C7 S. R/ P  ~导致下次爬虫无法正确读取上次爬虫留下的痕迹。

：return url_file

request.parse(
- ]. M) g2 S* R& k  ?    url='https://www.douban.com/group/explore',
    type_url='text',
$ e% I' @, @, |3 |6 p, ^    #login='taobao',
    Parsing = 'xpath',
  V" t, s8 T* x& i- y* N- Z    label = {
) {  h7 ~. S* C: D$ ?% C, R        '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]
        },
, g( i! V! [' v1 l" G    write='result.pkl',
    next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
    # 第一个参数为是否需要断续笔记。
7 X5 k8 b7 M8 E    # 第二个参数为断续笔记保存位置。
    page=[True,'url_page.txt']
).run()
% \  b+ i2 R' u# \% V4 m# return url_file
* z! K( t9 ^6 p" M0 a
第七种玩法：简单数据清洗
数据拿下后，直接保存到本地有些大佬可能觉得很辣鸡，连清洗都不清洗就存入本地了？那得拿到多少废数据脏数据。那么接下来介绍一下清洗参数。

1 u8 ?  v4 C8 ^; Y特点：
0 n9 [5 ?+ Z8 x; h本人曾写过一个底层数据清洗。
能将列表格式数据进行归分清洗。
主要内容请参考另一篇文章
如下连接：数据清洗
- b$ y! u- j$ B6 s6 Z) D  ^
缺点：
. z7 p6 d5 l' d  N6 \' L数据清洗格式简单。
' m: x  s: _. [! H0 A数据清洗内容单一。
无法完全做到绝对清洗。
. S9 M* }$ h/ ~1 c+ E有待改善。

：return keyword_list, value_list
( W& y- ?" T! C% ]2 J7 y
" Q$ X/ G3 N( S* S1 I4 urequest.parse(
' d2 l, c4 m, }: G9 Z8 n" a    url='https://www.douban.com/group/explore',
    Parsing = 'xpath',
! b+ n9 `: Z# @    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]
        },
- X# R+ {+ m  X" t% Q    write='result.pkl',
    next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
    page=[True,'url_page.txt'],
    # bool类型,默认不清洗
8 q$ z' f! m9 P    clean=True
).run()

第八种玩法：爬虫存入数据库
9 q- g. d4 f9 E0 H& K) f存到txt、存到csv、存到json、存到pkl，那也太low了吧。现在流行的数据库用不了么？那是不可能的。。

特点：
1 ]0 L  n* W5 y  h, l: p信息存入MySQL数据库。
可连接docker远程数据库。
5 m: z1 i& N/ a3 D9 I+ Q数据库的库名可以不存在。
数据库的表名可以不存在。
) s3 W) r  t# @/ U根据之前传入字典键与值参数判断表类型。
+ q- R  \- ]/ i9 |. h% \自由建立数据表传入信息。
7 _3 _: w+ v" F2 ?( x8 e- E
缺点：
仅支持MySQL数据库。

5 E+ D* N* Q  y9 M：return SQL

request.parse(
    url='https://www.douban.com/group/explore',
    Parsing = 'xpath',
    label = {
        'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
8 c& F4 W$ i4 `        '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',
% M5 O2 H, I# o# u# O0 m" a3 I    next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
" C# q0 h# O! I, A    page=[True,'url_page.txt'],
# J/ d6 w" u' U: ?9 u8 X! ^    clean=True,
0 k+ c4 k0 X1 k8 U! u9 a& m! w9 O    # 字典格式,
/ p, [& p3 I& \: V& s    # host可有可无,默认localhost
    # post可有可无,默认3306
) C) P2 s9 B$ G1 f) s  t8 {    # user可有可无,默认root
4 b; ?8 E8 g3 B/ \    # password必要参数,数据库连接密码
& K6 n+ H) d# t9 n( q" x* t    # db必要参数,数据库即将存入的库名
+ m+ P6 c! y8 l% u6 e    # table必要参数,数据库即将存入的表名
    write_SQL={
3 c$ {: m# a1 l+ Y# V. y- }        'host':'localhost',
        'post':'3306',
        'user':'root',
        'password':'123456',
; x  H) G( W& p" b        'db':'example',
        'table':'example'
        }
$ x: L# F( Z  [: O( s4 O/ k    ).run()
. s3 w+ R3 |  i, m& f7 {3 }
第九种玩法：重新启动爬虫
爬虫最让人厌烦的就是被一个不痛不痒的错误信息给终止爬虫了，比如意外的远程断开链接等低级非代码错误，报错之后还得重新启动断续爬虫，就显得很麻烦。我做了一期爬虫程序异常报错后重新启动爬虫，多次报错结束程序。
; u9 {% n3 X8 c/ |1 @* f
特点：
检测报错重新启动爬虫
% V; ?5 N7 D9 C# z无需手动处理错误信息

6 X/ F! _" e8 ~/ C! x缺点：
& e3 Y0 f" Q2 ]- ~! S. M无法收集子线程错误。
0 G7 L) d- ~$ i, ]
; ]- |$ g3 X* D8 v6 C：return None

2 K6 ]- T& h8 Drequest.parse(
        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
        #login="taobao",
1 Z' c! r5 K) w        type_url = "text",
0 @4 x1 m, e3 t4 U  [        Parsing = 'xpath',
( V3 K2 u0 G2 v* Y+ R8 E( w" L5 |        label = {
! S: \8 [+ d) _1 R8 \            'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
1 @  ~" I" l( q3 ?            '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]
: l3 ^3 l/ {" t$ @; {0 Y/ u            },
3 g* ]$ Z7 d% n& |        write='result.txt',
        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
# ]4 {' x6 W; z6 N+ d        page=[True,"now_url.txt"],
( o% n7 q/ L( M( G" Y, \- p/ {        # texting 参数为是否启用连续爬虫
9 e. u& N2 @% s& v3 H# X        # 爬虫程序异常报错后重新启动爬虫
        texting=True,
        ###
        write_SQL={
            'host':'localhost',
            'post':'3306',
! ~! C3 T6 g$ c            'user':'root',
. p: i( p4 c$ l$ Q            'password':'123456',
% c# C* ?- \4 {$ P  m            'db':'example',
            'table':'example'
            }
( B+ u. @( B$ w3 \( f: e7 `).run()
5 f, z8 m8 f7 b+ h
第十种玩法：多线程爬虫
: Y5 g; e- L6 l8 ]" R# ]' [特点：
8 f  T# T' ~* S* ^爬虫速度加快，
更好的利用了线程。

& [6 b$ q" E9 V) |缺点：暂无

# J. S' m& w  W+ m% X2 Z; {- o：return None
! Q# N0 E- N1 N  o3 h
request.parse(
, q7 ]+ I  }& _9 w" s, G        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
        #login="taobao",
5 D- H  K8 c/ Q0 h2 p" H' H( ~        type_url = "text",
        Parsing = 'xpath',
        label = {
7 Y6 E# ]. E) C4 I6 r7 Y; k# D            'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
( K3 k5 {$ o1 z2 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]
( V. l, t3 i9 v; Q1 H4 W( o+ H            },
; H) D+ I, _: {) y4 c        write='result.txt',
        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
5 U9 c; j. }) m4 b1 W" u0 f  u        page=[True,"now_url.txt"],
        #clean=True,
4 `3 N' Q- @/ H3 H( Y0 H" k        texting=True,
        # status="threads" 启用多线程爬虫
" t* F$ L! M" I# n+ x        # Thread_num 为线程数目,默认为1 单线程
        status="threads",
" }  B6 W$ P( v1 ~5 B! o! h+ o        Thread_num=3,
        ###
        write_SQL={
" r; t4 Y: k6 {' o            'host':'localhost',
            'post':'3306',
& ^" p. v4 c$ m4 M: o5 X  B            'user':'root',
- E' v1 S6 r$ h            'password':'123456',
+ o6 B5 b8 n5 h            'db':'example',
" N# }- Z- E- C  e, V# ]8 h: _+ C            'table':'example'
  d; t6 e8 h7 `& G) s( R            }
).run()
7 L" j$ f- I" ]9 _3 U5 I5 _% \/ y5 V
9 Y( Z7 s+ Y6 \- o$ O+ u5 O第十一种玩法：多进程爬虫
特点：
爬虫速度加快，
5 N: g! @/ F6 I8 e* o更好的利用了进程。

缺点：暂无
$ G/ T/ |: _0 ]. S
：return None

from simple_crawl import request
request.parse(
0 F; f. ?' F2 {1 o        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
3 J) f+ u' f6 @0 |& J: T+ y; c4 C        #login="taobao",
7 `& \3 a  B  s- P3 s        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],
7 w6 L) q. y/ d7 y  O            'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
            },
/ O8 J- e" D( c' Q2 q0 H* K% z        write='result.txt',
        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
# E& I% n' N. Y4 H, U        page=[True,"now_url.txt"],
+ r5 \& g! x  K4 A6 k# N4 }) a0 r        #clean=True,
7 r& Y! v2 z' k; b. `        texting=True,
4 s: i% `* s+ |+ S        # status="multiprocessing" 启用多进程爬虫
        # cpu_count 为启动代码核心数,默认为系统核数一半
" M. U- m6 K- q        status="multiprocessing",
6 s" F: w- x  @1 e0 B  F4 O1 y        cpu_count=2,
        ###
8 c. R' n. W, P        write_SQL={
( X0 N; }- T- N9 w* ]8 _4 L, u" Z  O& |            'host':'localhost',
+ \6 l; G7 Q6 o2 j            'post':'3306',
8 S/ ]1 t& x; _8 w: `            'user':'root',
            'password':'123456',
- H6 J- `/ @% l7 o            'db':'example',
$ w0 [; ]: e" E' C" E' P            'table':'example'
            }
% y; G4 o2 r/ B5 W3 g).run()

第十二种玩法：异步多线程爬虫
  ]1 H! D5 Z; |特点：
& T3 d0 X/ E6 }$ s# S爬虫速度加快，
7 s. _+ H& `' C- z7 S5 t& V0 b异步使得爬虫无等待时间，
同时使用多线程速度明显加快。
* C/ L* i! Y* x4 c
  R2 U9 D" ~" [  ?4 J- ^+ o缺点：暂无
0 B' r* q! q  A
：return None
- U/ V$ |+ H  ^) c1 k* i
from 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",
' m0 F* F( x* }4 X1 w1 S# @5 k        Parsing = 'xpath',
- q/ [3 B" l  w- n$ Y        label = {
9 c: f( \: [! s. _: ]& o+ s" s            'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
$ |9 ~! h4 g/ Z' C: Q1 w4 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]
; ]  f- @. U3 m' h) F# V' J. w            },
        write='result.txt',
1 b6 {( Y* s. ^! `  X        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
2 P/ ~$ U- V# d. Y) X% V3 v2 Q        page=[True,"now_url.txt"],
        #clean=True,
        texting=True,
1 C. W; e  \( z7 r$ a# H, X" q& U        # sem 参数为异步引擎数目,默认为5
        # 其他参数同上
1 X/ a: \& a/ n  Q: r        status="aiohttp",
        Thread_num=3,
( V/ @! |' W0 O0 C" u        sem=5,
- S6 `' b; H0 |( a' g        ###
        write_SQL={
+ R0 h" c# c$ p1 ^, p            'host':'localhost',
            'post':'3306',
            'user':'root',
( Q  E$ ]! f: }            'password':'123456',
            'db':'example',
            'table':'example'
  f+ w  Q& G- w- T8 h( l6 J            }
).run()

第十三种玩法：异步多进程爬虫
特点：
爬虫速度加快，
. T$ T9 N/ ~8 l* o- `6 ~- T异步使得爬虫无等待时间，
同时使用多进程速度明显加快。
, I  r/ p  R3 d) a6 Y
缺点：暂无

. P. g8 S- y8 Z# q+ ~：return None

) F/ X0 D! p2 |0 Q" A/ I% S6 Ffrom simple_crawl import request
& Q0 |" R# h$ [' i- Crequest.parse(
        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
        #login="taobao",
9 \4 C8 H- c+ P' |, S7 X        type_url = "text",
' R1 f2 d+ q0 o, f* I- g8 A4 }- K        Parsing = 'xpath',
        label = {
1 c+ d5 j1 s# s: Z            '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],
* Y- f; ~$ v# T- p& z  x            'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
            },
        write='result.txt',
        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
        page=[True,"now_url.txt"],
) x# |5 `5 E% c, V- t        #clean=True,
5 N4 \+ `- g' c4 D        texting=True,
        # 参数如上
        status="between",
+ K/ s+ o) s1 c: j        cpu_count=1,
1 u0 Y7 n3 G+ z2 h+ b' M  k        sem=5,
        ###
        write_SQL={
2 n# y  ]) F( e            'host':'localhost',
            'post':'3306',
            'user':'root',
/ r6 I& K0 S- D1 }& C            'password':'123456',
            'db':'example',
  Y: T8 k7 @$ Q2 h7 c            'table':'example'
: ~$ W; C( C7 H; Z8 y) R            }
  {2 a0 G/ U4 Z0 E4 z' B; ]).run()
9 k" _. m% n2 r* D, N' \

功能介绍完毕🤞
最后还是希望你们能给我点一波小小的关注。
奉上自己诚挚的爱心💖
' t1 y) F4 B: f————————————————
% V) T7 `7 |6 |( Q* r+ ^版权声明：本文为CSDN博主「꧁༺北海以北的等待༻꧂」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
" w$ l- a, i, f3 n' x原文链接：https://blog.csdn.net/qq_45414559/article/details/106005684
( g& F7 O2 I  ]
6 x: s& X" \' Q) k3 G
0 O5 [- ^( e  N( c6 g( k$ n

738391227

66666666666666666666666666666