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

zhangtt123

仅需一行代码写爬虫–simple_crawl
simple_crawl
9 P& `2 Z! U$ u' Z+ f仅需一行代码即可达到爬虫效果
" X! O0 a6 f4 C( I项目地址(欢迎star):https://github.com/Amiee-well/crawl
使用方法
pip install simple_crawl
& `9 F; d8 e6 [, w7 @5 T3 h$ H3 C% U8 K. Z
+ P% ~3 N  q" t. x### 以下源代码为简单介绍,详细功能介绍再源代码之下
from simple_crawl import request
; c/ c+ a4 W- v9 d, t6 xrequest.parse(
        # status 参数为运行状态,支持单线程多线程多进程协程以及联合
0 p' {+ z! I+ E5 ^$ x1 _        status="aiohttp",
6 Z7 K# Z5 b2 P% _' G        # url 参数为爬虫网址,单线程状态为字符串格式,特殊状态为列表格式
        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
. U+ D, E& l5 A6 K1 }        # login 参数为获取登陆信息,如淘宝等网址需要登陆信息
' r% R7 z, R: A7 f8 F" q    #login="taobao",
    # type_url 参数为返回源代码格式,支持text和json,默认返回text
    type_url = "text",
    # Parsing 参数为解析方法,支持re、xpath和beautifulsoup
    Parsing = 'xpath',
    # label 参数为爬虫解析过程,字典格式,详情见下方
" n) k8 h2 j6 d! m- E    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]
( \& a& Q6 l" L2 H     },
     # write 参数为爬虫结果保存,支持txt、csv、pkl、json,注:特殊状态爬虫信息容易混乱
9 e& J% _/ l) B! z7 r5 B# x- M+ K     write='result.txt',
     # next_url 参数为下一页爬虫地址,@必须为href,仅支持单线程爬虫
     next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
     # page 参数为断续笔记,第一个参数是否启用笔记,第二个参数选填默认page.txt,仅支持单线程爬虫
) x: W" q$ \/ o$ t9 [1 i$ K     page=[True,"now_url.txt"],
0 o3 e# R/ C4 d1 x4 i; S% O     # clean 参数为是否进行数据清洗,防止大量爬虫收集无用信息
     #clean=True,
; c! B9 K) C( t& T     # texting 参数为是否选择连续爬虫,避免爬虫过程中出现非代码问题报错结束爬虫程序
     texting=True,
     # Thread_num 为多线程数,默认为1单线程,支持多线程状态和异步状态
! t! x& \# d; \     Thread_num=3,
     # cpu_count 为多进程数,默认为1单进程,支持多进程状态和联合状态
     cpu_count=1,
     # sem 为异步控制数,默认为5同时启动,支持异步状态和联合状态
     sem=5,
2 {# \9 i' \0 c1 Z6 H2 C3 Y     # write_SQL 为是否写入数据库,默认否
0 G- g- [- `7 X/ r" C4 L, s     # host 参数默认localhost
- g0 N4 ~& b9 ^; x3 k     # post 参数默认3306
" z% Y8 i1 M3 t, t9 g) m% N     # user 参数默认root
0 F9 R$ i2 d! d     # password 参数必填,必须正确
     # db 参数为即将存入的数据库名,若不存在自动创建
     # table 参数为即将存入的数据表名,若不存在自动创建
+ \, h! K3 F- s+ f     write_SQL={
         'host':'localhost',
         'post':'3306',
  N( U9 F" B: i/ Q         'user':'root',
         'password':'123456',
- P4 @# Z' V6 |/ F         'db':'example',
         'table':'example'
      }
1 ~7 b9 `& D1 n) Q; o% V/ A9 r).run()
( \( U1 w9 g/ }$ ?- W
6 w# @; b# ?3 a3 r' b2 w介绍一下crawl参数设置：
/ m# w" p. W- S
'''
/ Y3 \7 S' X2 l单行代码爬虫程序执行
0 ?: B; \; Y2 n. n:param status:启用爬虫类型,支持普通爬虫、多进程爬虫、多线程爬虫、异步爬虫、异步多进程爬虫,参数请参考文档
:param url:即将请求的url地址,仅支持get请求
:param type_url:请求url后返回格式,支持text和json格式返回
  L1 k# D8 G. Y5 }8 V) K0 {: O2 G:param Thread_num:即将启动多线程个数,默认为1单线程
, H1 _9 H9 P/ E5 y& r& i; L:param sem:协程信号量,控制协程数,防止爬的过快,默认为5
" e) P4 R4 I: `0 k  r0 \:param cpu_count:运行爬虫使用多进程cpu核数,默认为系统核数一半
" z* s+ x* @1 [:param login:模拟网站登陆,保存登陆信息
:param Parsing:爬虫方式,支持re、xpath以及bs4方法
:param texting:是否启用连续爬虫,爬虫程序异常报错后重新启动爬虫,
                       多次报错结束程序,默认否
:param label:选择器内容,字典格式保存,
4 w4 D# Q" c  s- Y- `9 c, n                     字典值为列表格式,第一个参数为选择器,第二个参数为转换类型
. O- C- p$ F! m! k% g                     第一个参数必填,第二个参数默认str类型
:param write:是否写入文件,支持txt格式、csv格式、json格式以及pkl格式,默认否
* j* |' b7 f9 {:param next_url:是否跨页爬虫,选择器内容使爬虫继续翻页爬虫
:param page:是否选择断续笔记接手下次爬虫处理,默认否
:param clean:是否进行简单类型数据清洗,默认否
:param write_sql:是否写入数据库,默认否
                         'host'默认为'localhost','post'默认'3306','user'默认'root',
, B' V& |& c- O9 B                         'password':'密码','db':'数据库','table':'数据表',
7 k2 h' Y- F" t+ r/ _                         检测库是否存在,若不存在则创建,若存在则直接插入,
* b& `) W- v2 \& a# ], M1 J                         检测表是否存在,若不存在则创建,若存在则直接插入
: ^+ v" [. [- M% d8 z) d1 ~+ q( H:return True
'''
介绍玩法
接下来介绍的均为调用第三方库的情况下运行：
# v9 |9 ~, h& D7 d8 S' e
1 F0 F: K# \) j7 x$ xfrom simple_crawl import request
; }) k2 N0 |0 y: J, q; g. j第一种玩法：输出源代码
* d, J' x2 q& s9 y" z+ H调用requests库进行源代码请求。

$ o0 N+ B& @7 t" Q3 a特点：
% M* {0 u8 f' {1 e. x' g请求失败则调用ip池处理重新请求访问，
出现五次失败默认网址输入错误。
1 f. P/ }; k8 j1 N7 }5 `支持text以及json字符串返回。默认text。

缺点：
暂时只能进行get请求，不支持post访问

：return text or json
* w- Y# @4 }$ p; C4 E4 y3 D
request.parse(
        url = "https://www.douban.com/group/explore",
% s9 _% z. T# D6 B" _        type_url = "text"
: h$ f+ h5 F9 N# G4 Y- I/ M: k' d).run()
# return text

第二种玩法：模拟网站登陆并保存信息
调用DecryptLogin库请求登陆访问。
  }# Y: X/ u' ?' E; L2 U# Z8 z
8 e2 D+ d5 |5 m( {0 l% jps：DecryptLogin库为大佬皮卡丘写的一个很不错的模拟网站登陆库，在此引用一下，因为单行爬虫原因不支持账号密码登陆，我将大佬写的二维码登陆使用过来了。再次感谢大佬开源
在此放出文档地址
$ Z( Z9 B: ~: E# G# A) I# WDecryptLogin库中文文档：https://httpsgithubcomcharlespikachudecryptlogin.readthedocs.io/zh/latest/
% L' g& k/ S% J7 V3 }* ^6 @
- u( I9 ?/ U7 a0 R特点：
& j8 n+ {' a2 I8 H8 x% x将DecryptLogin库中二维码继承到此库（非二次开发）
支持QQ群、QQ空间、QQ安全中心、淘宝、京东和斗鱼登陆（大佬登陆库中所有的二维码登陆）
保存session.pkl信息到本地方便下次登陆运行
- \& M3 v* T) E% o0 L9 R
缺点：
session.pkl登陆信息过时无法自动删除。
5 H' I. A- N, n8 S* T导致下次登陆疑似cookie无法正常登陆。
1 |! w- [# P( W8 a
:return session
+ h& L! e0 d) l9 S: F
. n  B! H, m- Zrequest.parse(
+ h4 Y& w4 B! o5 d/ q9 o( c7 ~7 F        # 臭不要脸的推广一下我的店铺
        url="https://shop574805287.taobao.com/",
" j- j9 Q& H5 q$ @        login="taobao"
4 A, h& |4 [2 z; R7 o/ f).run()
# return text

第三种玩法：爬取网站信息
( ^6 M3 e* t/ u3 [' k7 r  ^: u# R: o爬虫库自然少不了爬虫的过程

特点：
8 [  [' N$ b0 j1 l( x$ _支持re库，xpath解析以及bs4选择器。
. s3 }, F, y  M. u# H" p/ }爬取方法为字典格式。单方面输出。
: b! J' t6 C' A  k% ?* Q" L/ q$ |字典键为保存的字段名称。
$ x7 ~) k( k' }* X; q  j) P  B字典值为列表格式：第一个参数为选择器，第二个参数为转换类型。第一个参数必填，第二个参数默认str类型。
( H, F6 z! @' l3 n* }
0 r! ]0 m- E; g# X6 F4 y8 c9 \  E, m, y' v1 S缺点：暂无（等待小伙伴们发现）
7 V3 e$ w- H6 h; L0 K+ ]1 @
：return reptile_results

/ q( K" ]. ]& F/ ~/ {request.parse(
        url='https://www.douban.com/group/explore',
        # 字符串格式,选择器方法。
! N& d8 K' X! Y6 E# F( B% Q    Parsing = 'xpath',
- _7 V$ K! T* u) Y* F. o& T    # 字典格式,参数如上。
    label = {
# M/ B4 |, k( K( w2 e) n7 T        'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
  H1 y3 s' ~3 H; 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]
8 i+ C6 N& n  X9 b        }
).run()
# return reptile_results（list）
5 @; B1 `* ?6 b; b5 \9 T/ P2 [
第四种玩法：自由保存信息
; q' \+ W' Z, ?0 L0 Q& k目前版本支持保存txt、csv、json以及pkl四大主流文件。日后版本更新将发布更为全面的保存方法。

特点：
写入文件均为数据格式传入文件。
且输入格式规范方便阅读and省事。

% Z. N8 n) ^0 }+ i缺点：
保存格式仅四种，
不方便用户之后读写操作。
; y' g9 x. {+ D2 i: J9 P
- Y8 w. V. h4 \1 W：return file

6 r( u; _) }5 k2 a& B0 Q$ n! Mrequest.parse(
! Z$ D( j, ?5 L. \  E        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],
, Y# K2 G' ~; O; l' x$ o4 J& X        'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
        },
; O; A( {" r. p0 T) d+ l# f/ M& B    # 字符串格式,具体保存位置填写
% Y+ F  r# m4 v" E$ F- x8 q3 L* M    write='result.pkl'
9 v: j/ i8 Q- n/ n0 d- P).run()
/ D( y3 f# t4 Q# return file
0 E/ `; V0 u, t
第五种玩法：读取下一页 url 地址继续爬虫
这也是每个人都担心的问题，仅仅一行代码怎么可能翻页爬虫。这还真能做到哦~

- ?% L; Y4 k: b/ c特点：
继承之前的Parsing参数选择器选择方法。
在这里可读取到解析后的下一页 url 网址。
" Z3 c  ~4 i$ O& o方可继续进行爬虫处理。方便用户使用。
, }5 F# D2 L6 X) d( b9 S5 w
缺点：
若爬虫时下一页 url 地址改变，便结束爬虫。
只能爬取所给 url 地址中的信息。
) y: r& v+ u7 }" p( V无法进行某一界面的多个网页爬取返回。
& W/ q" b/ ~3 s5 l造成访问页面单一流失。

：return None

request.parse(
* q! L. T! D1 H2 k  V" N. w        url='https://www.douban.com/group/explore',
( i5 H5 }. a( b, V( B+ f    Parsing = 'xpath',
) m1 B9 o) d% G% ~    label = {
        'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
, R1 y- |0 q- B, l0 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]
) O; ?2 u( e$ ^( l        },
    write='result.pkl',
    # 字符串格式,根据Parsing方法继续请求下一页a中href
5 t/ G2 r2 k2 `    next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
. @" o' r; G( x# H& t).run()
; f- I: b; f) W0 r( ~! a) g& n  W# return None
$ ^; Y1 @. K; [( x1 X" }
第六种玩法：爬虫网页保存
5 c: B+ t1 P4 x  O6 s0 [% \) e听说过爬虫断续重连的朋友应该懂得这是个什么神仙操作。每次爬虫运行期间好好的，睡一觉醒来发现代码报错了。。。这就是个很难受的事，还不知道之前爬取到哪一页了，只能重新爬虫了啊！

特点：
持续输出断续笔记。
3 b( u2 V2 z+ [: b, j将此次爬虫的 url 地址保存到一个文本文档内部。
  \7 X1 s+ T8 D2 [" C下次读取文本文档即可快速进行直接断掉的爬虫 url 地址继续爬取所需。
! p3 M9 ~  N1 G% t
' j5 }! d4 F1 j) r5 w缺点：
读取内容不单一。
导致下次爬虫无法正确读取上次爬虫留下的痕迹。
" g& L% o3 k( A0 F9 m, f, v
：return url_file

request.parse(
    url='https://www.douban.com/group/explore',
, `2 h3 X9 j* ]- J    type_url='text',
    #login='taobao',
    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]
3 ]4 P0 w& z3 q/ A# I        },
) B) \* z" ]8 a. n    write='result.pkl',
, [! U& F( e+ W$ u    next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
    # 第一个参数为是否需要断续笔记。
& i/ y3 H8 P" G/ M( d1 R" P' u. C) c    # 第二个参数为断续笔记保存位置。
    page=[True,'url_page.txt']
).run()
# return url_file
; ~2 k  c0 h$ r: y6 t6 ^
0 x4 X4 P+ G1 \7 n% p4 m第七种玩法：简单数据清洗
; n) L; L' X9 t7 O8 |5 \5 u2 R2 K数据拿下后，直接保存到本地有些大佬可能觉得很辣鸡，连清洗都不清洗就存入本地了？那得拿到多少废数据脏数据。那么接下来介绍一下清洗参数。

特点：
本人曾写过一个底层数据清洗。
能将列表格式数据进行归分清洗。
主要内容请参考另一篇文章
9 X: r) x3 X4 ^. L+ ^如下连接：数据清洗
  G8 B+ |8 J3 A7 n# J% y* _) q
缺点：
数据清洗格式简单。
% `+ ^9 ], ?7 L8 _( o% x数据清洗内容单一。
无法完全做到绝对清洗。
有待改善。
4 b  m8 i% B- l- M
0 a6 e9 f' {" q9 B2 y：return keyword_list, value_list
( x: d1 d  J2 G8 a2 A0 O" g
# y% \" n4 d8 yrequest.parse(
" g( \; {" h- }$ T% o' 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],
8 O2 [  l) L8 |" o        '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',
+ v. c2 j. M$ m8 a( P    page=[True,'url_page.txt'],
    # bool类型,默认不清洗
( o5 K6 Q- l( [; ?# @    clean=True
" O( j- ]  `0 [% k& [8 G).run()
: V/ g: J, C; x
! b% @* O" D/ C/ h0 m1 }1 u1 v第八种玩法：爬虫存入数据库
存到txt、存到csv、存到json、存到pkl，那也太low了吧。现在流行的数据库用不了么？那是不可能的。。
9 ?; F: J  Y  e& M- p9 s0 n
特点：
; W7 Q( f4 y; ^信息存入MySQL数据库。
可连接docker远程数据库。
* ^, Q( V0 `) A/ F9 ]9 ?数据库的库名可以不存在。
% h, n9 [( i! t" @/ R& c. K数据库的表名可以不存在。
& d0 L7 [8 t/ h% H& x根据之前传入字典键与值参数判断表类型。
自由建立数据表传入信息。

缺点：
2 u; w: X. _5 v仅支持MySQL数据库。

：return SQL
, [: }+ J9 K3 }# L
request.parse(
    url='https://www.douban.com/group/explore',
    Parsing = 'xpath',
* D( Z/ l% E; ~4 E) E    label = {
        'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
: P' N& `, @+ A! `) d5 R        'name':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/text()',str],
8 c8 x  @6 z* p2 ]9 u- b        'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
, J4 t0 w+ Q9 Y        },
    write='result.pkl',
    next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
    page=[True,'url_page.txt'],
    clean=True,
/ p8 q" ]  ^% @& ]9 ?    # 字典格式,
7 k  e; l: S7 s) i. P1 K! i! y    # host可有可无,默认localhost
& Q( [) V" w( |! K! `2 t    # post可有可无,默认3306
+ k9 j* N7 [  Y( {; a    # user可有可无,默认root
9 d' ]% `# X6 h+ \# D- y4 U    # password必要参数,数据库连接密码
. O6 A) \4 c! J/ T3 Z    # db必要参数,数据库即将存入的库名
  i9 N+ v. c  o) `+ ]9 U2 |    # table必要参数,数据库即将存入的表名
    write_SQL={
        'host':'localhost',
        'post':'3306',
. ]2 O' B4 X: u0 R! ?4 e* U        'user':'root',
        'password':'123456',
# m& s. T& @& j8 C        'db':'example',
2 ?$ X+ g! z' {6 B" Z        'table':'example'
        }
7 i7 \; I9 i  h# g    ).run()

- n" B( ]8 a- |! ?) E5 ~第九种玩法：重新启动爬虫
0 {7 h+ J: U# H# K1 g爬虫最让人厌烦的就是被一个不痛不痒的错误信息给终止爬虫了，比如意外的远程断开链接等低级非代码错误，报错之后还得重新启动断续爬虫，就显得很麻烦。我做了一期爬虫程序异常报错后重新启动爬虫，多次报错结束程序。

特点：
. b0 F# p! v! Y+ F: Q检测报错重新启动爬虫
无需手动处理错误信息
+ C- B7 R) K6 c  j% x7 d
缺点：
无法收集子线程错误。

8 c5 R; W7 H$ J; y  ]：return None
2 {# S9 q) G/ Z& P
4 q- e" p, h1 n+ {; I; B) Crequest.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 = {
4 f/ w" K/ }3 |7 q0 B            '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='result.txt',
        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
        page=[True,"now_url.txt"],
) W5 }& J  B/ Q3 R+ _% N1 I        # texting 参数为是否启用连续爬虫
6 R. T# |4 Y4 h" s  H0 h/ }        # 爬虫程序异常报错后重新启动爬虫
        texting=True,
        ###
        write_SQL={
4 Y% |0 E9 S( e# v" d& k            'host':'localhost',
            'post':'3306',
# i( m6 y  z% M; L            'user':'root',
            'password':'123456',
5 |, C; u6 i( \! M6 t# N            'db':'example',
5 k" H) ^5 `. X1 I& K! |  r            'table':'example'
; T3 ]' M6 Q# I            }
).run()
3 S7 F8 H4 F2 ~: V3 [' I2 P
: w+ c2 l* k" F% x5 O第十种玩法：多线程爬虫
1 }0 o) e7 T0 m( C特点：
爬虫速度加快，
+ y) f) r0 i; r0 I4 G. r更好的利用了线程。

缺点：暂无

：return None

% B# M: Z& y5 ^) I/ ?0 krequest.parse(
        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
        #login="taobao",
! J4 E8 a# S3 _# m        type_url = "text",
        Parsing = 'xpath',
) B* H! g9 {" N' Z        label = {
7 H& |4 m0 V0 Q- f* ^            '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],
* t6 e) P. B/ a( c8 }            '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',
4 @0 ^. ^3 v. B4 L        page=[True,"now_url.txt"],
* r) D7 D) p; D8 y- _! Z; o        #clean=True,
        texting=True,
0 @. V, m' R7 a$ R0 f        # status="threads" 启用多线程爬虫
        # Thread_num 为线程数目,默认为1 单线程
: }7 H( j# H& v- j        status="threads",
        Thread_num=3,
        ###
  m; U- w5 l4 D; _5 S* G( @; r3 p6 U/ P        write_SQL={
            'host':'localhost',
) P' _* G5 Y, g) O5 z4 o            'post':'3306',
            'user':'root',
/ K9 m' l1 E9 J            'password':'123456',
  B6 A$ _9 t' W/ w$ y( F5 ^            'db':'example',
0 D* U! @* E7 [% w* i0 }            'table':'example'
            }
0 c) t! O$ U  k).run()

8 }4 M7 f1 b9 v- V9 |6 \9 ^) V- u第十一种玩法：多进程爬虫
特点：
爬虫速度加快，
0 p# }1 b# ]& R6 H更好的利用了进程。
. h; f1 k) I3 f4 S2 a# Z
0 B. E8 n1 |9 S# j缺点：暂无

：return None
( K$ m3 A' ?4 t  m& c
( D) Y) t3 v9 u+ Yfrom 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",
3 {3 ~: h& {, W1 d3 E        type_url = "text",
        Parsing = 'xpath',
        label = {
! ?3 Y  r5 D# i! S. r$ I1 t# \0 v            'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
' W0 w- }4 D, O3 x            '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.txt',
4 y% w. F6 p- B) s' T        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
( j' F8 N6 T8 q+ d        page=[True,"now_url.txt"],
        #clean=True,
        texting=True,
        # status="multiprocessing" 启用多进程爬虫
1 l7 A, e, }* s' w        # cpu_count 为启动代码核心数,默认为系统核数一半
        status="multiprocessing",
        cpu_count=2,
; }0 a1 }9 T+ d; H0 n        ###
% Y0 Z8 x6 h$ k* W( D$ G        write_SQL={
  S5 I& r1 k  |2 P( s            'host':'localhost',
* z- e) Y9 I* `7 Y  f3 v            'post':'3306',
            'user':'root',
            'password':'123456',
            'db':'example',
4 c: Z( I+ l" u# k6 }            'table':'example'
* o* e) J# b9 \3 X* t; p            }
).run()
0 ?$ L3 {- U' d+ a; u" R
6 ^# t+ y7 o9 O6 J& S. L- k第十二种玩法：异步多线程爬虫
/ b+ r  ]* G3 I% v特点：
爬虫速度加快，
异步使得爬虫无等待时间，
" s1 Y+ ]: P4 h" v) W; E" k8 m" K( A同时使用多线程速度明显加快。

* X. X5 @/ }8 |6 p缺点：暂无
5 v6 }$ |, O$ b! y. ]& t
：return None

  k- j! q: m% l! f( I5 T8 X, afrom simple_crawl import request
request.parse(
- y. B' h0 O: V4 q+ ^9 }- {: Q% {        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 = {
8 t( d( c7 g" U* x0 i            'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
9 n1 G" n2 _# M- 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]
% q7 y( Y# y$ j5 n6 z' u            },
# Z; D& k5 B6 S  J* A: a/ Q, X        write='result.txt',
  |$ q1 u: P) t! O; p        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
# s* f" G+ R& y+ @8 L        page=[True,"now_url.txt"],
        #clean=True,
. R: j, U6 V0 z        texting=True,
& \' G* `8 T2 H# u; K; Q        # sem 参数为异步引擎数目,默认为5
8 S2 E3 B- v8 O. d" d3 Y        # 其他参数同上
        status="aiohttp",
8 _; j/ F" q  o1 a9 `! k        Thread_num=3,
$ S  c9 k+ n8 Y  f9 {" L. C$ d        sem=5,
        ###
, ~: f4 P0 E7 b        write_SQL={
            'host':'localhost',
7 R2 y0 S' z2 _3 n6 m% `, k            'post':'3306',
            'user':'root',
/ y& }/ J/ R. K' p, x/ H& Y4 k            'password':'123456',
7 ^0 ]; x3 c. c: _( R% @- m            'db':'example',
            'table':'example'
            }
: `, ?! A/ Q+ p3 l).run()
3 s$ E" w: @7 d! b! [) g
- d: d. ~" _) d7 m  {$ X! }第十三种玩法：异步多进程爬虫
3 v2 Y; q7 P. J特点：
8 O3 K) B: T( X8 ]  i爬虫速度加快，
异步使得爬虫无等待时间，
同时使用多进程速度明显加快。
5 t$ q: c* r0 A, n( j
缺点：暂无
; n, ~8 d# D9 H' I+ ]
9 _8 i; w7 K; V  |* i2 x2 h% D: O：return None
( q. a) C0 v; |$ C7 _
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",
2 w3 E6 R* O( u+ e8 O7 W        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]
            },
/ C4 v  v" \* K/ e9 |& B0 f  ^/ N: W        write='result.txt',
        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
        page=[True,"now_url.txt"],
/ F7 _% S9 t/ ~2 L6 h+ ~        #clean=True,
        texting=True,
( h, D3 j, P0 u3 p, O6 [        # 参数如上
        status="between",
6 T: n0 B0 S' c' k% t- l        cpu_count=1,
8 S- X, v4 d9 @7 p9 j+ V/ c# X        sem=5,
# c" R; @7 ^: I/ ]        ###
        write_SQL={
            'host':'localhost',
3 W) O, R/ z% p0 |/ L7 l            'post':'3306',
            'user':'root',
' o" A- E# m1 \) k" o( F: ^            'password':'123456',
2 K- T8 \1 N9 L& g& c7 R            'db':'example',
            'table':'example'
/ m  h6 S2 k5 b! q2 U4 U            }
  i5 D4 n+ v/ R. ]; R).run()

. K/ R# s, W% y  `0 w1 P6 b
功能介绍完毕🤞
最后还是希望你们能给我点一波小小的关注。
& Z1 f0 E8 N' c% O奉上自己诚挚的爱心💖
/ o' |/ ~0 L0 x/ x7 S2 `————————————————
5 B  M* N; i# H. n  i; i# a版权声明：本文为CSDN博主「꧁༺北海以北的等待༻꧂」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_45414559/article/details/106005684

738391227

66666666666666666666666666666
/ [/ u0 J/ v, U