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

zhangtt123

仅需一行代码写爬虫–simple_crawl
simple_crawl
; @* Y# C$ v: J4 }仅需一行代码即可达到爬虫效果
项目地址(欢迎star):https://github.com/Amiee-well/crawl
* N& w. y8 X: w* W+ U' b使用方法
pip install simple_crawl
  w( u* T5 D2 Y. A( S
4 q9 A( }, p, Z% P### 以下源代码为简单介绍,详细功能介绍再源代码之下
+ c4 c2 g( X- Q# x& j, n% Afrom simple_crawl import request
" Q( m, l. q' K3 z$ V: xrequest.parse(
        # status 参数为运行状态,支持单线程多线程多进程协程以及联合
4 L: u7 B9 a" p' b( Z$ B        status="aiohttp",
        # url 参数为爬虫网址,单线程状态为字符串格式,特殊状态为列表格式
' w/ S8 {' K: D& \# k% ^        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
( y$ z3 t. W6 x. [# f. D# j+ l        # login 参数为获取登陆信息,如淘宝等网址需要登陆信息
' C2 v" d# K: o, Y: R: A2 O    #login="taobao",
    # type_url 参数为返回源代码格式,支持text和json,默认返回text
( X3 D6 ]3 P2 ~$ [    type_url = "text",
6 l" Z+ g' e8 ]$ w9 P/ o    # Parsing 参数为解析方法,支持re、xpath和beautifulsoup
8 W9 j* M! J! P& u    Parsing = 'xpath',
    # label 参数为爬虫解析过程,字典格式,详情见下方
    label = {
            'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
' T5 C" \& @6 ^1 Z6 B% |" 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]
2 _+ d; O1 \/ N4 |  g6 D     },
     # write 参数为爬虫结果保存,支持txt、csv、pkl、json,注:特殊状态爬虫信息容易混乱
     write='result.txt',
     # next_url 参数为下一页爬虫地址,@必须为href,仅支持单线程爬虫
     next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
* u9 v) [' B5 {# }% C1 E     # page 参数为断续笔记,第一个参数是否启用笔记,第二个参数选填默认page.txt,仅支持单线程爬虫
: L7 A" P3 s; h3 H# s2 Z3 N2 Z     page=[True,"now_url.txt"],
! J5 m5 w" c/ j# v& ]- k     # clean 参数为是否进行数据清洗,防止大量爬虫收集无用信息
$ W$ g7 o) b, \# V7 C     #clean=True,
# S& ]- }& f# g/ y) S     # texting 参数为是否选择连续爬虫,避免爬虫过程中出现非代码问题报错结束爬虫程序
4 S) O( e. q# n' ?     texting=True,
     # Thread_num 为多线程数,默认为1单线程,支持多线程状态和异步状态
     Thread_num=3,
     # cpu_count 为多进程数,默认为1单进程,支持多进程状态和联合状态
+ H7 z6 r. u. M4 D0 t3 Y( b: C     cpu_count=1,
     # sem 为异步控制数,默认为5同时启动,支持异步状态和联合状态
# C( n0 }1 Z, y. w& X; ?5 n     sem=5,
4 x2 v4 c# s( _+ y. C" d     # write_SQL 为是否写入数据库,默认否
  _+ |: b5 N3 @0 v: d! u     # host 参数默认localhost
     # post 参数默认3306
     # user 参数默认root
2 G; ~; ^$ {+ ?( p5 c* r: }     # password 参数必填,必须正确
: D% C* J+ `& v6 H' |1 ^     # db 参数为即将存入的数据库名,若不存在自动创建
     # table 参数为即将存入的数据表名,若不存在自动创建
) n5 I) g4 x: q6 q- M1 F5 J     write_SQL={
         'host':'localhost',
         'post':'3306',
         'user':'root',
         'password':'123456',
/ A% {& _+ c" ?3 V9 r3 J, o; f* }         'db':'example',
, S' l; d7 [+ n6 _# H: s         'table':'example'
3 F! P8 q) R' @$ M" x" @      }
).run()

介绍一下crawl参数设置：

'''
1 z  t. ]# c2 ^6 [7 ?' D! t, K' W' \单行代码爬虫程序执行
:param status:启用爬虫类型,支持普通爬虫、多进程爬虫、多线程爬虫、异步爬虫、异步多进程爬虫,参数请参考文档
- j. T( n% F* l+ z- _:param url:即将请求的url地址,仅支持get请求
:param type_url:请求url后返回格式,支持text和json格式返回
:param Thread_num:即将启动多线程个数,默认为1单线程
  M. b; v  H4 B- i" G:param sem:协程信号量,控制协程数,防止爬的过快,默认为5
:param cpu_count:运行爬虫使用多进程cpu核数,默认为系统核数一半
:param login:模拟网站登陆,保存登陆信息
7 q: A) A6 l. G9 g8 Q- w:param Parsing:爬虫方式,支持re、xpath以及bs4方法
:param texting:是否启用连续爬虫,爬虫程序异常报错后重新启动爬虫,
! g/ D3 T; ^: v  m2 T6 e7 E( e+ s                       多次报错结束程序,默认否
:param label:选择器内容,字典格式保存,
. V4 W( k3 g5 @- o5 T$ }3 a0 R2 y                     字典值为列表格式,第一个参数为选择器,第二个参数为转换类型
/ w1 O- B3 W! J: x4 ]                     第一个参数必填,第二个参数默认str类型
6 W' z# ]$ ~) ^- @( a6 _:param write:是否写入文件,支持txt格式、csv格式、json格式以及pkl格式,默认否
- ~( ?2 j* s% H( F:param next_url:是否跨页爬虫,选择器内容使爬虫继续翻页爬虫
:param page:是否选择断续笔记接手下次爬虫处理,默认否
" H0 m  F8 p% i( f5 }6 F:param clean:是否进行简单类型数据清洗,默认否
:param write_sql:是否写入数据库,默认否
( t& a+ t$ B) _1 `1 B# b                         'host'默认为'localhost','post'默认'3306','user'默认'root',
                         'password':'密码','db':'数据库','table':'数据表',
2 K5 k, d' z' _. i                         检测库是否存在,若不存在则创建,若存在则直接插入,
2 ]/ j" ]! o& F                         检测表是否存在,若不存在则创建,若存在则直接插入
2 E" p% b: ^+ u/ ~* h4 G/ n! j:return True
'''
介绍玩法
8 T" E% z6 L' l# M9 O! y) b' T1 b接下来介绍的均为调用第三方库的情况下运行：

( ?' b2 X/ m& W* P4 {; m% p6 i4 Qfrom simple_crawl import request
第一种玩法：输出源代码
- b* R2 a: }4 ]. N0 J调用requests库进行源代码请求。

特点：
请求失败则调用ip池处理重新请求访问，
( r7 w: w, B; ]$ c" R! m出现五次失败默认网址输入错误。
支持text以及json字符串返回。默认text。

缺点：
/ y- U+ V2 t7 @, y) L6 c" i暂时只能进行get请求，不支持post访问

：return text or json
7 {& ?" C8 l6 u- `
. j( N; M' q/ J; W/ S* z6 mrequest.parse(
! Q) N( s, P! S        url = "https://www.douban.com/group/explore",
  @9 y* H1 M$ C- W) a        type_url = "text"
$ z: t+ ?, k9 P).run()
# return text

第二种玩法：模拟网站登陆并保存信息
调用DecryptLogin库请求登陆访问。

ps：DecryptLogin库为大佬皮卡丘写的一个很不错的模拟网站登陆库，在此引用一下，因为单行爬虫原因不支持账号密码登陆，我将大佬写的二维码登陆使用过来了。再次感谢大佬开源
2 j& P, }( I; a6 t4 w# w% C在此放出文档地址
DecryptLogin库中文文档：https://httpsgithubcomcharlespikachudecryptlogin.readthedocs.io/zh/latest/
7 f4 s% E7 k! B" V* T& B2 l& Q8 n
特点：
2 v2 E/ i0 f* ^5 ?, |1 U2 R将DecryptLogin库中二维码继承到此库（非二次开发）
* C5 Z4 F7 j1 c9 T* A+ D支持QQ群、QQ空间、QQ安全中心、淘宝、京东和斗鱼登陆（大佬登陆库中所有的二维码登陆）
4 s: d! v0 X+ q保存session.pkl信息到本地方便下次登陆运行

" A2 v! [/ M* D1 r% h, |缺点：
8 I& U( Z6 w( N# [session.pkl登陆信息过时无法自动删除。
导致下次登陆疑似cookie无法正常登陆。
' a8 R; r4 k9 M& I
:return session

# f& t* ^3 G+ e9 lrequest.parse(
        # 臭不要脸的推广一下我的店铺
        url="https://shop574805287.taobao.com/",
. q4 V% u5 s) K3 Q        login="taobao"
).run()
# return text
0 o0 A% ]0 B* ]/ f8 k6 v
" h# _8 P1 L. w3 P& O$ G( f8 T第三种玩法：爬取网站信息
) r( s  `, n* D爬虫库自然少不了爬虫的过程
' M' Y0 Y  y" M, l+ N$ u+ d
特点：
$ r! x! k7 Y1 W# a4 `2 [9 j支持re库，xpath解析以及bs4选择器。
爬取方法为字典格式。单方面输出。
字典键为保存的字段名称。
, T1 Y  I9 o* V3 r6 e1 [字典值为列表格式：第一个参数为选择器，第二个参数为转换类型。第一个参数必填，第二个参数默认str类型。

( N% N$ p; Y, J: B& [0 B5 R) N缺点：暂无（等待小伙伴们发现）
( L  j2 ~3 ~- o9 J
：return reptile_results

request.parse(
8 R( m/ T' [" @' ^$ Y' w$ @        url='https://www.douban.com/group/explore',
; C) X( c1 Q! x) r        # 字符串格式,选择器方法。
    Parsing = 'xpath',
- D* b' u* p# w    # 字典格式,参数如上。
8 S8 x' @7 J% A. ~+ V) I$ ~    label = {
% V; Q1 Y& _9 ]        'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
6 {8 j$ @& {: W5 M) U        'name':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/text()',str],
6 J# D" j) w8 \1 f) U; n- |        'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
8 k  N+ h! \: X+ q! r        }
).run()
# return reptile_results（list）
/ o8 |6 @& a, d1 K) i* F9 j: D
* d$ s6 v" T$ j6 ^6 X% p第四种玩法：自由保存信息
0 W: X- _' b* h/ l1 F目前版本支持保存txt、csv、json以及pkl四大主流文件。日后版本更新将发布更为全面的保存方法。
; g5 v8 @/ ]& e' |
特点：
写入文件均为数据格式传入文件。
且输入格式规范方便阅读and省事。

缺点：
保存格式仅四种，
不方便用户之后读写操作。
4 K  K( B& n$ l& d
/ w0 g* Z  h! |* Z8 J：return file

2 e8 E$ i; [" j( r: M& \0 qrequest.parse(
        url='https://www.douban.com/group/explore',
  o  R9 T0 o! _: o' J, r    Parsing = 'xpath',
0 d1 {. N0 P* \6 q# I, F, H    label = {
' ~6 H" t2 W+ A        'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
( `8 g! G6 q7 ~- \        '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]
) H9 E) j8 g  Z( q9 R        },
/ p' `1 s3 D/ m) `    # 字符串格式,具体保存位置填写
( Y; b, y4 O; C* a! H2 z# x    write='result.pkl'
$ }- R% }7 L  M$ T$ u3 P3 |).run()
# return file

第五种玩法：读取下一页 url 地址继续爬虫
4 z5 @1 r8 s6 w这也是每个人都担心的问题，仅仅一行代码怎么可能翻页爬虫。这还真能做到哦~

  k  z+ t& E4 g& @) `  R特点：
继承之前的Parsing参数选择器选择方法。
在这里可读取到解析后的下一页 url 网址。
& w1 v  Q% t& L/ f# }" _# |) _0 ^" ?方可继续进行爬虫处理。方便用户使用。
2 ]; a9 d2 F. _6 m
缺点：
若爬虫时下一页 url 地址改变，便结束爬虫。
只能爬取所给 url 地址中的信息。
# ?' W' O9 @- ?. X* \无法进行某一界面的多个网页爬取返回。
! w( g; ~6 f* ?造成访问页面单一流失。
9 k* o2 z8 U- c: [. y
( j  L& |6 Z4 ~4 _! i, r4 n, S：return None
% i+ N( |+ x# W  L( w
request.parse(
+ u6 O+ i" h) C9 G) N9 p        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],
        'name':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/text()',str],
/ n/ R. {, M' j- z- W! n. Z6 J* G        'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
        },
    write='result.pkl',
# h" q4 i& ?* j  G2 k& L8 E( _    # 字符串格式,根据Parsing方法继续请求下一页a中href
    next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
$ F  x0 s; q; e5 u6 Q- U4 |* E( u).run()
. w; Q9 ^: D  E, d, V0 c# return None
7 A& c- c: k7 A0 o2 ^
第六种玩法：爬虫网页保存
& s# P) x+ `" ]( I! ^听说过爬虫断续重连的朋友应该懂得这是个什么神仙操作。每次爬虫运行期间好好的，睡一觉醒来发现代码报错了。。。这就是个很难受的事，还不知道之前爬取到哪一页了，只能重新爬虫了啊！

3 g0 S% p- g; S1 c( H! O4 P& a特点：
; P; S5 j: o" `* ]- Y" [+ x/ Q0 G持续输出断续笔记。
将此次爬虫的 url 地址保存到一个文本文档内部。
下次读取文本文档即可快速进行直接断掉的爬虫 url 地址继续爬取所需。

& `; ?2 x& G: g: I* [3 ~缺点：
( w6 [: `* L3 K9 h. @- F读取内容不单一。
" Z8 [) i3 H; I; k" L* Q导致下次爬虫无法正确读取上次爬虫留下的痕迹。
8 L$ @0 B& k3 B& r0 R5 i3 L+ y' {
：return url_file
% g- B8 e( A2 r! F7 }  c* {! X
2 [. `3 O) Y& F! mrequest.parse(
* v  @$ X- ?$ {9 D" M    url='https://www.douban.com/group/explore',
    type_url='text',
    #login='taobao',
  t5 h. o' \' N& I9 a    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],
6 ^  e, {0 y5 ]/ Q& j        'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
) i- J5 z/ z  g        },
    write='result.pkl',
( r. X0 e# Z# h9 @, B5 ]    next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
    # 第一个参数为是否需要断续笔记。
    # 第二个参数为断续笔记保存位置。
    page=[True,'url_page.txt']
; ?9 C+ m! v, _6 s0 [" S4 |).run()
# return url_file

第七种玩法：简单数据清洗
" e# ?4 h" {% P* s* z数据拿下后，直接保存到本地有些大佬可能觉得很辣鸡，连清洗都不清洗就存入本地了？那得拿到多少废数据脏数据。那么接下来介绍一下清洗参数。
+ Q0 }! h2 X( u& S& g  x
特点：
" X5 o# K+ K" C" m' p3 O: d本人曾写过一个底层数据清洗。
% v4 h4 K: k/ h& T能将列表格式数据进行归分清洗。
主要内容请参考另一篇文章
如下连接：数据清洗

( p. v  Z" \4 x+ Q; g缺点：
数据清洗格式简单。
8 M% G* N8 g" R/ T! p) }  o, Q# I% v数据清洗内容单一。
无法完全做到绝对清洗。
有待改善。
- K' z% }; c. n3 Q
' X$ j6 z- m& F3 b' G3 }1 }2 q! U：return keyword_list, value_list

" G9 l2 O# n1 b/ O0 i$ E7 A. Orequest.parse(
    url='https://www.douban.com/group/explore',
8 b' S1 ^9 X. z$ V; `# u; T    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],
        'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
6 Q: j& R! A, K8 i        },
+ }' J4 }* ^, e$ ?* ?& l    write='result.pkl',
    next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
    page=[True,'url_page.txt'],
* p' o$ c; G' Z    # bool类型,默认不清洗
* ]$ O' ?* \8 ^$ h, f" e5 c    clean=True
).run()
* {' l9 P: O8 t9 h
: a1 E* O) M% @6 K, |第八种玩法：爬虫存入数据库
: G) `' U5 p, x  L! ?; {存到txt、存到csv、存到json、存到pkl，那也太low了吧。现在流行的数据库用不了么？那是不可能的。。

特点：
信息存入MySQL数据库。
; {; [: d- Y2 O% g$ a* @: N可连接docker远程数据库。
数据库的库名可以不存在。
数据库的表名可以不存在。
. W% p% |8 [- i根据之前传入字典键与值参数判断表类型。
自由建立数据表传入信息。
/ I: r$ D; u7 L3 |, G
缺点：
仅支持MySQL数据库。

：return SQL

" u% A2 n. z9 c& |; crequest.parse(
6 ~5 o$ w% M% T2 Q    url='https://www.douban.com/group/explore',
    Parsing = 'xpath',
/ c  p1 G4 l# m  D- C) z" O2 p    label = {
* m7 j; Z+ p/ w' {        'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
, j$ R1 u) ~' ~/ l1 e        '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]
- _  B, L" U% G        },
    write='result.pkl',
    next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
$ }( o2 Z% J" ?# F, N    page=[True,'url_page.txt'],
    clean=True,
2 c6 g: }' ]/ c1 `; {9 S! h    # 字典格式,
    # host可有可无,默认localhost
6 a- {, C- J$ Z    # post可有可无,默认3306
    # user可有可无,默认root
    # password必要参数,数据库连接密码
    # db必要参数,数据库即将存入的库名
    # table必要参数,数据库即将存入的表名
, r% a: G2 A/ c" D7 }+ b    write_SQL={
, l% ^% J2 y6 }+ F        'host':'localhost',
        'post':'3306',
        'user':'root',
        'password':'123456',
        'db':'example',
        'table':'example'
& ~$ V* Y& Z4 j        }
    ).run()

第九种玩法：重新启动爬虫
爬虫最让人厌烦的就是被一个不痛不痒的错误信息给终止爬虫了，比如意外的远程断开链接等低级非代码错误，报错之后还得重新启动断续爬虫，就显得很麻烦。我做了一期爬虫程序异常报错后重新启动爬虫，多次报错结束程序。

& ?. `, D  |0 w/ Y特点：
8 @' T) C, F8 g' U$ B检测报错重新启动爬虫
无需手动处理错误信息

缺点：
无法收集子线程错误。

：return None

request.parse(
, ^7 O. O3 x7 u( S. c+ r: e$ A& x        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
6 g- G6 V4 r0 n: C4 b2 i        #login="taobao",
/ R) ^, Z7 U. M( @" P" `        type_url = "text",
        Parsing = 'xpath',
        label = {
4 _4 {: x' b0 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],
            'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
- D. z6 x" ?- @. F4 Y; }6 {' T7 S* R            },
( u: O% a! [3 [3 D9 ]        write='result.txt',
        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
        page=[True,"now_url.txt"],
        # texting 参数为是否启用连续爬虫
        # 爬虫程序异常报错后重新启动爬虫
5 D) Q( Z$ M! p" _& Q; H" Z. Y        texting=True,
        ###
        write_SQL={
" t6 O5 |) e9 F0 @$ m; D3 j6 d: d9 Z            'host':'localhost',
8 m+ b! y0 f/ i* b/ G& @+ C            'post':'3306',
            'user':'root',
            'password':'123456',
* l# j- a# s, l. @+ ?' |( t            'db':'example',
            'table':'example'
            }
9 X& Q2 ]0 F6 o# c' `).run()
1 Y, ]* t# k$ [6 J1 b1 I1 }
第十种玩法：多线程爬虫
3 L5 E$ W* U3 X* q2 U' H特点：
爬虫速度加快，
; T  r; I3 c1 E* n更好的利用了线程。
* |; Y$ p( E+ ?. p# a
/ o. \2 Y+ @9 I  _/ B缺点：暂无

：return None

6 E/ ?2 M/ O" n( K* orequest.parse(
        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
        #login="taobao",
        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],
            'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
7 O2 m" [( l8 T8 @8 l# e            },
1 y8 c  J4 O! G; M3 o! u        write='result.txt',
3 a" A" Q- a2 W8 _        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
        page=[True,"now_url.txt"],
        #clean=True,
( I! z& C, _1 H        texting=True,
        # status="threads" 启用多线程爬虫
        # Thread_num 为线程数目,默认为1 单线程
        status="threads",
- ]3 c4 Z' j# Z        Thread_num=3,
        ###
8 ^) B0 Y3 M# Q7 `; C. g        write_SQL={
, g1 o2 `8 P* j4 t% ~; y9 x            'host':'localhost',
, P2 P! @) o* r/ B            'post':'3306',
5 v$ W- o. r& h* u            'user':'root',
            'password':'123456',
            'db':'example',
            'table':'example'
            }
( z/ V5 [+ s( J: B7 q! ]).run()

第十一种玩法：多进程爬虫
特点：
7 b" g; Q/ x' c8 g( e) {* c爬虫速度加快，
, A$ w3 t# Y; [3 \2 ^5 e2 X7 s更好的利用了进程。

缺点：暂无

：return None
4 g! k' q" r' B2 s+ ~
from simple_crawl import request
; f+ {- {! N4 V6 @' ]request.parse(
! l1 [7 I: H1 t4 Q4 T$ k) F        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
+ {1 Y/ U( z' @7 K! ]  {" z        #login="taobao",
7 y$ X( g: q1 p! W1 v9 _        type_url = "text",
        Parsing = 'xpath',
6 H9 d; L4 p7 i& |        label = {
8 s/ O; _! ^, A& 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],
$ e$ o, C+ L5 U* c% q! F: g; }            '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"],
        #clean=True,
) I( N7 {- p4 [6 R& Q4 E/ V        texting=True,
        # status="multiprocessing" 启用多进程爬虫
/ I5 ?+ E3 Q" \1 K4 P% [        # cpu_count 为启动代码核心数,默认为系统核数一半
        status="multiprocessing",
& j, W) S2 U6 h        cpu_count=2,
7 r  ^! \$ L& z! Y* \: H        ###
& b) ?# ~& h" C* @! C: [9 `, K( `        write_SQL={
            'host':'localhost',
& |" p4 H1 T6 G7 I            'post':'3306',
# i2 C) p0 S6 b4 _, w            'user':'root',
            'password':'123456',
            'db':'example',
% J4 U0 }, O; z) \9 a1 h  P            'table':'example'
            }
).run()

5 z7 x4 y9 D- i' V9 S5 L第十二种玩法：异步多线程爬虫
& _( o9 i5 G( U) p; K' s特点：
爬虫速度加快，
- `0 P6 D# f% @' G% x, s+ G/ g异步使得爬虫无等待时间，
同时使用多线程速度明显加快。
" j" F) y9 L8 O+ x! L0 J
/ Z% [  h- v+ X2 E3 H缺点：暂无
8 k3 f1 Z" U2 l' B& Q( T
0 T, y' U4 }! r# o6 m1 B! j：return None

from simple_crawl import request
; u4 C9 X. `# trequest.parse(
        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
        #login="taobao",
        type_url = "text",
        Parsing = 'xpath',
        label = {
" I! ~8 P$ e; 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],
            'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
, ~( o' f1 ~" X- ?/ q$ \1 Y9 l9 p1 m            },
9 O" B7 Q4 s% j8 {  r+ j        write='result.txt',
9 ]2 u+ B& x7 d5 b        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
        page=[True,"now_url.txt"],
% V! @0 f1 [8 r3 s1 O7 V        #clean=True,
        texting=True,
        # sem 参数为异步引擎数目,默认为5
        # 其他参数同上
: E6 N3 t: l# ]- A8 F0 O5 r9 g' i        status="aiohttp",
! X( y3 ?: K6 q% r9 N2 j9 z        Thread_num=3,
        sem=5,
        ###
        write_SQL={
            'host':'localhost',
            'post':'3306',
            'user':'root',
            'password':'123456',
0 K' z' E2 r  R! `( n, f            'db':'example',
            'table':'example'
5 Z( X9 E4 y: @7 F            }
).run()
* H6 Q6 v# m- l: ~& T
6 s; q# n' ~+ r. ?* M+ J第十三种玩法：异步多进程爬虫
特点：
爬虫速度加快，
% ^3 T. M* N# h+ b1 c; @, G异步使得爬虫无等待时间，
同时使用多进程速度明显加快。

( L( p' L; b/ o# o' t缺点：暂无
+ \% O) F& R0 W/ Q
) _2 i4 L9 `8 V9 w' d; `5 a/ A* T+ d" \：return None
; E! g8 J6 M6 i# x* R
from simple_crawl import request
0 q. W, \4 p0 ~3 u: d" `request.parse(
        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
        #login="taobao",
! J4 R) M; s5 y/ |9 {        type_url = "text",
        Parsing = 'xpath',
        label = {
# G; ]8 Z! `: z/ 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]
            },
- d/ h5 q4 X/ N! h$ O' m# Z3 g4 l  F        write='result.txt',
        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
        page=[True,"now_url.txt"],
7 Y: |# P9 u. B8 F( a% i        #clean=True,
8 @  D* G7 W5 F& K2 Z        texting=True,
1 m' Y% K( ~0 V6 D; n" z: G# G1 l        # 参数如上
        status="between",
  q% r/ W2 E" @3 I6 g, j3 O7 ^        cpu_count=1,
' i1 G- B! R6 `, f1 e        sem=5,
* H$ A, W( n: f        ###
        write_SQL={
/ {8 o% P$ n! X9 J5 G5 _            'host':'localhost',
            'post':'3306',
. j+ x/ A" L: j            'user':'root',
            'password':'123456',
( t: [, X$ b# e5 ?" V            'db':'example',
! H* @) ^7 U4 M( G( ^$ N            'table':'example'
            }
5 R$ B/ ]: O; k% Z. n7 t% ?% z# _).run()


+ F* c3 ]# K: d1 L- y; M9 M* m% r功能介绍完毕🤞
* n8 K9 r& Z! x! V最后还是希望你们能给我点一波小小的关注。
. f- W2 l" \4 P8 E奉上自己诚挚的爱心💖
————————————————
版权声明：本文为CSDN博主「꧁༺北海以北的等待༻꧂」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_45414559/article/details/106005684
3 i$ G# P' v* Z5 e

$ f" n5 y: j' q# q8 S' c7 [

738391227

66666666666666666666666666666