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

zhangtt123

仅需一行代码写爬虫–simple_crawl
$ i! z0 L# u# |) z  n- U6 n* {simple_crawl
+ j1 u6 U+ v3 c& }仅需一行代码即可达到爬虫效果
项目地址(欢迎star):https://github.com/Amiee-well/crawl
2 N/ h0 V3 g6 m1 F. t5 [/ E1 Y# I使用方法
pip install simple_crawl

### 以下源代码为简单介绍,详细功能介绍再源代码之下
! q, b; c8 ]" {4 T8 r+ }from simple_crawl import request
3 L) U* d6 R  Y2 e$ v$ i# Vrequest.parse(
& O- D2 n) k' e, [, W! T! v        # status 参数为运行状态,支持单线程多线程多进程协程以及联合
        status="aiohttp",
- u) ~5 \: |- E+ e        # url 参数为爬虫网址,单线程状态为字符串格式,特殊状态为列表格式
2 ]7 b2 Y! V5 M* q: e# |" g        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
; p" x- r/ ^8 m; O4 b( ~        # login 参数为获取登陆信息,如淘宝等网址需要登陆信息
    #login="taobao",
, F6 M* N5 q5 d8 K1 q    # type_url 参数为返回源代码格式,支持text和json,默认返回text
( a) W& T1 o7 L+ M    type_url = "text",
6 i8 ?6 ~; |( n" D4 a- J6 J    # Parsing 参数为解析方法,支持re、xpath和beautifulsoup
    Parsing = 'xpath',
2 }* a% ]3 S2 v- n! }7 G    # label 参数为爬虫解析过程,字典格式,详情见下方
1 U7 C/ S- |( ~    label = {
. z  D- Q) P+ Y# y            '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]
1 l9 A2 A$ o* e! X9 h- ]& y1 k     },
% M# V& ~! c1 K5 b; Q8 ?" a0 x" }2 h9 b     # write 参数为爬虫结果保存,支持txt、csv、pkl、json,注:特殊状态爬虫信息容易混乱
     write='result.txt',
     # next_url 参数为下一页爬虫地址,@必须为href,仅支持单线程爬虫
7 ~' B) v% |  {- v! f$ [     next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
     # page 参数为断续笔记,第一个参数是否启用笔记,第二个参数选填默认page.txt,仅支持单线程爬虫
     page=[True,"now_url.txt"],
% J2 w: t  y; ]  n     # clean 参数为是否进行数据清洗,防止大量爬虫收集无用信息
     #clean=True,
     # texting 参数为是否选择连续爬虫,避免爬虫过程中出现非代码问题报错结束爬虫程序
$ b8 v6 z" `; X# N9 d7 @     texting=True,
2 w6 a, d* ]' _4 w     # Thread_num 为多线程数,默认为1单线程,支持多线程状态和异步状态
     Thread_num=3,
1 a, [/ _' I1 x8 u" f4 Y0 }4 X     # cpu_count 为多进程数,默认为1单进程,支持多进程状态和联合状态
     cpu_count=1,
     # sem 为异步控制数,默认为5同时启动,支持异步状态和联合状态
     sem=5,
     # write_SQL 为是否写入数据库,默认否
# L4 |& ]. [+ Y+ p7 P) ^     # host 参数默认localhost
     # post 参数默认3306
     # user 参数默认root
     # password 参数必填,必须正确
4 ?' T4 V6 g9 Q6 n0 B5 `4 g     # db 参数为即将存入的数据库名,若不存在自动创建
' T8 A8 m( {" L     # table 参数为即将存入的数据表名,若不存在自动创建
     write_SQL={
& F) n6 V' g( O: C. W0 R  K! g         'host':'localhost',
         'post':'3306',
+ J  C. Q3 ?8 Y$ C" E5 w2 a1 c( ]4 g0 H         'user':'root',
         'password':'123456',
         'db':'example',
         'table':'example'
+ f5 W  D5 E( w* Q$ B6 \! l      }
).run()
6 x' U9 Z7 {% J5 j& `# N, j
# b( D$ B4 I4 x* i5 W5 e介绍一下crawl参数设置：
9 T$ h% P1 s# B9 K* J
9 z+ \: S# j* O- K" l" z'''
( t8 u2 d/ h, _5 s- ~1 K单行代码爬虫程序执行
& k' q: P8 v0 X, ?9 B& Y:param status:启用爬虫类型,支持普通爬虫、多进程爬虫、多线程爬虫、异步爬虫、异步多进程爬虫,参数请参考文档
:param url:即将请求的url地址,仅支持get请求
8 W) p9 i' i' O:param type_url:请求url后返回格式,支持text和json格式返回
:param Thread_num:即将启动多线程个数,默认为1单线程
. q3 M* U1 ?- t+ W& ?' f:param sem:协程信号量,控制协程数,防止爬的过快,默认为5
& v- C. F3 h% O( I- d( d1 A& a:param cpu_count:运行爬虫使用多进程cpu核数,默认为系统核数一半
7 P" x( h# C( K5 ^1 U* n# \; c: P:param login:模拟网站登陆,保存登陆信息
9 B0 ~* S6 |  b- M, a( M8 W4 ?:param Parsing:爬虫方式,支持re、xpath以及bs4方法
:param texting:是否启用连续爬虫,爬虫程序异常报错后重新启动爬虫,
                       多次报错结束程序,默认否
:param label:选择器内容,字典格式保存,
6 E+ l8 f: Q0 O/ h                     字典值为列表格式,第一个参数为选择器,第二个参数为转换类型
                     第一个参数必填,第二个参数默认str类型
:param write:是否写入文件,支持txt格式、csv格式、json格式以及pkl格式,默认否
:param next_url:是否跨页爬虫,选择器内容使爬虫继续翻页爬虫
4 o4 W# w# b3 e1 f, n:param page:是否选择断续笔记接手下次爬虫处理,默认否
# `( |: A% A& x3 W$ h) C8 {:param clean:是否进行简单类型数据清洗,默认否
- N2 f) o# s1 Q, W# g0 X:param write_sql:是否写入数据库,默认否
                         'host'默认为'localhost','post'默认'3306','user'默认'root',
7 v1 t: ?5 r2 J: Z! O" v) z+ D7 Y                         'password':'密码','db':'数据库','table':'数据表',
                         检测库是否存在,若不存在则创建,若存在则直接插入,
                         检测表是否存在,若不存在则创建,若存在则直接插入
6 W; f1 s  Q% u( E2 o:return True
'''
% q. e; f6 b; G* N" {介绍玩法
接下来介绍的均为调用第三方库的情况下运行：
2 E1 E6 A7 o% H8 v; A. Q
from simple_crawl import request
8 L- R4 ?+ R$ A8 c第一种玩法：输出源代码
调用requests库进行源代码请求。

特点：
请求失败则调用ip池处理重新请求访问，
* T5 o$ s4 n) g9 q" m出现五次失败默认网址输入错误。
5 L" f& R+ J0 k$ K8 j* N7 b支持text以及json字符串返回。默认text。
7 r& M3 Y# J' D* i# z/ O
缺点：
暂时只能进行get请求，不支持post访问

. _8 B8 d& N9 b% ^* g：return text or json

request.parse(
. Y9 l" o7 H0 k* D7 u9 S) b        url = "https://www.douban.com/group/explore",
        type_url = "text"
6 ~" N6 n5 p/ O' a9 h2 n).run()
: g" V" r4 D3 }" R9 e, b# return text

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

7 \  D7 ~* q) y* h; ~3 t/ Yps：DecryptLogin库为大佬皮卡丘写的一个很不错的模拟网站登陆库，在此引用一下，因为单行爬虫原因不支持账号密码登陆，我将大佬写的二维码登陆使用过来了。再次感谢大佬开源
! D6 D( t) m) ]3 i: D9 ^( \+ m在此放出文档地址
DecryptLogin库中文文档：https://httpsgithubcomcharlespikachudecryptlogin.readthedocs.io/zh/latest/
) S2 h2 e* }; X1 N; N
特点：
4 Z5 C. e' K& a: H/ q# o将DecryptLogin库中二维码继承到此库（非二次开发）
, Z5 d; \6 Z; y; {. q: @5 k支持QQ群、QQ空间、QQ安全中心、淘宝、京东和斗鱼登陆（大佬登陆库中所有的二维码登陆）
9 {$ J- S7 r1 `* {保存session.pkl信息到本地方便下次登陆运行

缺点：
$ M6 O$ A( x- |! l- |- J6 }session.pkl登陆信息过时无法自动删除。
) s7 q/ y. A2 T& w导致下次登陆疑似cookie无法正常登陆。
$ F4 a! o, F' ]4 {+ |* e3 Z) P
3 i  _9 h; R* Z9 v: M+ g, V% D:return session

request.parse(
+ q6 ]( q1 `1 b/ t* q" t) F        # 臭不要脸的推广一下我的店铺
1 w# }  w6 n* ~( L5 ~; @/ S        url="https://shop574805287.taobao.com/",
' D+ H  \+ k0 ~  D% o        login="taobao"
) y5 A. N$ Z, y, E# a- q* [).run()
. U8 O6 O8 ~" ]: [1 j3 W! L# return text

第三种玩法：爬取网站信息
* r8 E% W) |/ x爬虫库自然少不了爬虫的过程

9 a, ^* Z% B2 R: X% G特点：
) W6 ?' K# C" F  d支持re库，xpath解析以及bs4选择器。
' S: v' ?6 c3 H6 x0 U爬取方法为字典格式。单方面输出。
字典键为保存的字段名称。
字典值为列表格式：第一个参数为选择器，第二个参数为转换类型。第一个参数必填，第二个参数默认str类型。
+ A. H7 d0 T. o
3 b# W% B/ y* m- K- f& ?缺点：暂无（等待小伙伴们发现）

：return reptile_results
: n* B) z. R6 ^( ~
" _/ L" d' [. `request.parse(
  b$ c: q- H! s* J9 {        url='https://www.douban.com/group/explore',
        # 字符串格式,选择器方法。
- ~. Z% F5 j1 S, {* m* z, h    Parsing = 'xpath',
    # 字典格式,参数如上。
6 v6 S2 Z% ]) `& k8 x    label = {
8 ?/ h; u2 D& D$ [8 r- q: _        '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]
& C: W+ G2 j( o2 ~# o5 ^4 l        }
).run()
# return reptile_results（list）
3 \% v$ j7 l# O& q1 W" U
" v1 F2 h* k3 j3 Q) k4 D第四种玩法：自由保存信息
$ z; g1 E( c7 B目前版本支持保存txt、csv、json以及pkl四大主流文件。日后版本更新将发布更为全面的保存方法。
% Z+ _" ^1 u" @. i) n% U
特点：
写入文件均为数据格式传入文件。
且输入格式规范方便阅读and省事。

6 u' O/ a  ]# k- c6 ]缺点：
保存格式仅四种，
不方便用户之后读写操作。

：return file
" c7 {% O' e! }8 e% f) w  _$ o8 U' D
request.parse(
        url='https://www.douban.com/group/explore',
, _& I2 y# }  V$ |    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]
        },
    # 字符串格式,具体保存位置填写
5 Z' B$ w! [' o. N9 X    write='result.pkl'
* r! \: Y$ F6 C2 z).run()
6 s# i) w; {* M' ]* j" O# return file
( x, V2 L# s9 j. g: z5 c0 j9 i
2 L5 K) A2 U) m第五种玩法：读取下一页 url 地址继续爬虫
! W' u' O1 S5 o, x这也是每个人都担心的问题，仅仅一行代码怎么可能翻页爬虫。这还真能做到哦~

% K& \/ \1 K( E. @  A! x特点：
6 `5 l& i- Z. Q继承之前的Parsing参数选择器选择方法。
在这里可读取到解析后的下一页 url 网址。
方可继续进行爬虫处理。方便用户使用。
8 d: x) {8 T6 c- |5 w& z6 u3 }
缺点：
若爬虫时下一页 url 地址改变，便结束爬虫。
! l( n/ p: ?. b' d只能爬取所给 url 地址中的信息。
无法进行某一界面的多个网页爬取返回。
造成访问页面单一流失。

：return None

request.parse(
        url='https://www.douban.com/group/explore',
$ \; s4 o9 q* O: Q    Parsing = 'xpath',
    label = {
' s$ s9 J9 t5 f. l. ]        '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],
4 S/ T. k0 M  Y$ ^* k9 R* E% m        'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
& {* ~% A/ u$ [, S' z) q, X4 _, o& t1 |        },
* D5 }* q. q: |* u4 t$ D    write='result.pkl',
# s0 v* {% x: p- f3 y9 E. _: Q    # 字符串格式,根据Parsing方法继续请求下一页a中href
' B% Q$ ]6 ~: ?! I    next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
0 i! h% S/ e7 t- {* R0 K6 v2 v).run()
# return None
; G7 z( L% u6 l9 r
+ S4 W; B! ^& Y' p第六种玩法：爬虫网页保存
2 S# t* @* ~* s( k听说过爬虫断续重连的朋友应该懂得这是个什么神仙操作。每次爬虫运行期间好好的，睡一觉醒来发现代码报错了。。。这就是个很难受的事，还不知道之前爬取到哪一页了，只能重新爬虫了啊！

特点：
, Y4 v1 ^$ }/ V0 D持续输出断续笔记。
将此次爬虫的 url 地址保存到一个文本文档内部。
下次读取文本文档即可快速进行直接断掉的爬虫 url 地址继续爬取所需。
& x1 c$ M. Q$ B
缺点：
1 Y8 W4 D6 a/ @- J读取内容不单一。
导致下次爬虫无法正确读取上次爬虫留下的痕迹。

( D. }  P3 a) Q2 a: M" T：return url_file

' i) e) L% Y3 I' y7 Zrequest.parse(
5 N& m& c/ g: W" P- W    url='https://www.douban.com/group/explore',
    type_url='text',
    #login='taobao',
    Parsing = 'xpath',
    label = {
: }: j6 u' B& j7 t; D        '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],
% T; [# W/ @& z$ v& j& |. |        'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
        },
: F8 y2 B- }5 A% f# K+ e- m    write='result.pkl',
8 x  Q. k( U+ Q; W    next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
    # 第一个参数为是否需要断续笔记。
    # 第二个参数为断续笔记保存位置。
. q3 j/ y6 x# T  H4 i9 C' f7 h' F5 }" y    page=[True,'url_page.txt']
! K' q# e0 \3 k" c).run()
# return url_file
1 v7 ^: h4 |  X2 ?6 j: }
第七种玩法：简单数据清洗
" c6 J! y( Y0 l0 q1 o数据拿下后，直接保存到本地有些大佬可能觉得很辣鸡，连清洗都不清洗就存入本地了？那得拿到多少废数据脏数据。那么接下来介绍一下清洗参数。

( ?( Z: }) s3 _特点：
3 _1 [" Z, Q( ?( @2 x本人曾写过一个底层数据清洗。
1 f3 [, v0 f2 d7 X# M+ x, e' M; c0 R能将列表格式数据进行归分清洗。
& }& w# |( z3 [/ C! P主要内容请参考另一篇文章
如下连接：数据清洗

& _2 ~* o# \! T& q$ n5 E- y缺点：
- w) K( W  B' k  \; p数据清洗格式简单。
数据清洗内容单一。
* E2 @) s! O/ E  j  B( M# J无法完全做到绝对清洗。
有待改善。

：return keyword_list, value_list
/ k+ j" T( u3 t7 }$ |1 j
9 e/ E) X  Y. |5 Frequest.parse(
, Q8 |% j# R) s$ J" w* D. J    url='https://www.douban.com/group/explore',
    Parsing = 'xpath',
# `" `5 u/ X1 ^* H6 u    label = {
+ }1 k0 \  {8 O: E7 o. R1 a) 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],
! O! A- `! b2 G0 I+ v8 j3 [        'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
        },
    write='result.pkl',
! s* K8 p% W$ n; h. D! S4 t    next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
    page=[True,'url_page.txt'],
    # bool类型,默认不清洗
8 q+ y1 w# g5 X6 x" F: R    clean=True
).run()

第八种玩法：爬虫存入数据库
, c, q4 f9 f" w( I存到txt、存到csv、存到json、存到pkl，那也太low了吧。现在流行的数据库用不了么？那是不可能的。。
# D/ y2 S# j  F) s3 r- U
特点：
信息存入MySQL数据库。
& P! p$ x4 p* W+ K- p) t可连接docker远程数据库。
  `3 \$ V0 K- {& e* g: y( K$ C数据库的库名可以不存在。
; P0 {4 T: P5 x% ^数据库的表名可以不存在。
根据之前传入字典键与值参数判断表类型。
( E. \: K" X8 O8 U% |自由建立数据表传入信息。
6 _" {: d- I# g, g4 Y9 E0 j
缺点：
' \  {7 |0 _) P" w- E7 e+ y6 G仅支持MySQL数据库。

：return SQL

request.parse(
    url='https://www.douban.com/group/explore',
    Parsing = 'xpath',
    label = {
1 Z* h0 n! C% X8 w  L6 a( c        '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],
* ^4 u1 P' p! n5 v        'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
. {& _# p# G9 N5 }        },
    write='result.pkl',
    next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
    page=[True,'url_page.txt'],
4 ^: b# c$ g+ q. E0 g/ b    clean=True,
    # 字典格式,
    # host可有可无,默认localhost
" E5 }* w9 y" H8 v6 f- J    # post可有可无,默认3306
+ G' t" D1 h; N# X    # user可有可无,默认root
    # password必要参数,数据库连接密码
    # db必要参数,数据库即将存入的库名
    # table必要参数,数据库即将存入的表名
    write_SQL={
        'host':'localhost',
        'post':'3306',
, U% C! _6 `2 y: q  n* y- m6 e& ~        'user':'root',
; U0 |$ A+ L5 y& \, i        'password':'123456',
& Y6 _! u, p! T* ]  l- C4 o) J        'db':'example',
) K' a3 J9 {& |" [$ E        'table':'example'
( w& |6 K& D% o2 b% _        }
; {" T+ U$ w8 I5 I9 j    ).run()
  {1 Q( c; \4 G7 [
第九种玩法：重新启动爬虫
3 f0 ~8 E8 _$ u: b4 u; p爬虫最让人厌烦的就是被一个不痛不痒的错误信息给终止爬虫了，比如意外的远程断开链接等低级非代码错误，报错之后还得重新启动断续爬虫，就显得很麻烦。我做了一期爬虫程序异常报错后重新启动爬虫，多次报错结束程序。

特点：
检测报错重新启动爬虫
无需手动处理错误信息
5 P  U5 V. t$ _7 `
1 ?+ B  ?( s3 Y/ C2 O缺点：
无法收集子线程错误。
- y/ v, x8 X. e/ K5 }, n
：return None

request.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',
4 j% A7 P* Y* r7 {5 X5 G- 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]
1 b& a: y/ I; P; g( u            },
        write='result.txt',
        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
        page=[True,"now_url.txt"],
        # texting 参数为是否启用连续爬虫
        # 爬虫程序异常报错后重新启动爬虫
        texting=True,
        ###
        write_SQL={
8 V6 S5 U; y" }( c$ A            'host':'localhost',
! I7 T+ R$ B3 N6 x            'post':'3306',
, G) @8 C; q& a$ z# B: j$ X            'user':'root',
4 ~+ l; K: ?( A1 j4 ]2 x8 S            'password':'123456',
            'db':'example',
            'table':'example'
            }
).run()

第十种玩法：多线程爬虫
% n2 T9 r2 u( F; {$ E: e' P特点：
* M, F: E* V( u, h爬虫速度加快，
更好的利用了线程。
  h. n' [# L7 g+ k( C2 v) S, }) N% c
0 ~3 z1 @% e* G" u4 n* r% }缺点：暂无

：return None

' S2 q) O- [" i7 crequest.parse(
) ^# Y$ R7 }+ k" y) b9 {        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
        #login="taobao",
        type_url = "text",
% |2 C+ Q( Q# f1 y$ 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],
            '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,
        texting=True,
        # status="threads" 启用多线程爬虫
        # Thread_num 为线程数目,默认为1 单线程
        status="threads",
1 \9 O9 [. B7 {3 D+ i        Thread_num=3,
: C& s* |: L+ R0 h( h. H- N        ###
        write_SQL={
            'host':'localhost',
  g0 C' I0 B6 f: E  y1 W! L            'post':'3306',
            'user':'root',
            'password':'123456',
            'db':'example',
- i: U9 V5 O/ J/ H* T3 A            'table':'example'
5 V  C6 c. o. g/ I; C& k0 Z            }
- ?* e$ I) @: S9 I( W).run()
/ G5 {) E* P: l( H8 f6 C
9 U1 [6 D0 y: q! r第十一种玩法：多进程爬虫
3 Z% B( S: J4 U* `# }  h# T4 W特点：
8 R% @! M! o1 f& S! g, L爬虫速度加快，
+ [# q# w. r' A+ l& w更好的利用了进程。
* {7 q; j- x! n6 N3 [5 X
缺点：暂无

：return None

5 a! A# C) a# V* m' a4 Tfrom simple_crawl import request
request.parse(
$ D# c$ _* V, }# \( v        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
$ {5 x" G3 ?' `( [3 @( h$ y        #login="taobao",
        type_url = "text",
* U4 |' e0 H/ g' p' ~( }        Parsing = 'xpath',
0 F9 h2 V: ]6 m        label = {
/ J  Y, v- K, A+ J  C! ]            'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
1 ]7 V2 j+ P( 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]
            },
        write='result.txt',
        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
        page=[True,"now_url.txt"],
        #clean=True,
        texting=True,
* `$ {/ a5 z" g4 K+ g3 `        # status="multiprocessing" 启用多进程爬虫
% F) {2 F7 c. G! b* d        # cpu_count 为启动代码核心数,默认为系统核数一半
        status="multiprocessing",
        cpu_count=2,
        ###
. _5 F9 i4 f# ~+ \0 Y        write_SQL={
            'host':'localhost',
# `8 U  ?; c  Q5 ~* L; A            'post':'3306',
6 x, }* f+ C+ H) x6 {' D            'user':'root',
            'password':'123456',
( }# ^( N* K6 k, d* L            'db':'example',
2 m% O6 @" i8 F/ m6 ?6 n" |            'table':'example'
- Z+ U, j; W9 H8 T9 O& B            }
5 A- b0 M3 t5 L8 L- c* w).run()
2 b, s/ g3 J# |2 L
第十二种玩法：异步多线程爬虫
" v, [4 v1 W) z' {  w6 o9 }" h特点：
爬虫速度加快，
异步使得爬虫无等待时间，
, @- h! `& Y- @5 r; Y  E同时使用多线程速度明显加快。
: h9 A, Q7 K5 [. Q/ ~) @+ e
  @- t) N/ e! ^; P% n缺点：暂无

：return None
$ `% k, _4 _, T7 B
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",
& U3 i7 S8 s6 F) T. E        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]
2 c$ A$ L: x* |! Y8 w( I            },
        write='result.txt',
9 h$ T( {) `8 H1 Z- Z0 g# c8 q/ m        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
        page=[True,"now_url.txt"],
, Z4 w2 L, C& Q0 x* e% O        #clean=True,
        texting=True,
. b: h! n+ n  Y+ B; \        # sem 参数为异步引擎数目,默认为5
        # 其他参数同上
3 f+ u$ q. @& ?) l        status="aiohttp",
        Thread_num=3,
        sem=5,
, l$ ^$ d3 ?0 C: j7 k1 S        ###
        write_SQL={
            'host':'localhost',
5 ~8 A  o; D7 R1 W7 k            'post':'3306',
            'user':'root',
            'password':'123456',
+ K4 c* p) J7 ~1 v            'db':'example',
: A% K8 a# I( m2 Q            'table':'example'
            }
).run()

第十三种玩法：异步多进程爬虫
特点：
爬虫速度加快，
- E0 R- x  c# a. X9 \! v' W4 L' i6 G6 W异步使得爬虫无等待时间，
1 V7 w7 c5 e5 c$ q6 T同时使用多进程速度明显加快。
6 {3 f9 r! C/ m5 k' X9 M
# `" j, t8 |5 M) V6 [0 h# U: I8 p缺点：暂无
8 r5 \  q$ Y% ^4 r
" [1 U8 S# _+ F2 m. x) {：return None
! r6 I" o, t/ b  |. S( S. @
from simple_crawl import request
request.parse(
  w9 t3 d  s6 V/ }3 ^/ [5 b) r2 s        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
. }/ y* x) t7 }/ n; B: W        #login="taobao",
- K( A. l. K2 y  f, A/ @        type_url = "text",
        Parsing = 'xpath',
        label = {
! o8 O6 M4 z* T5 m/ r            'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
5 l; N" d. }( b9 \, R; b4 V            'name':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/text()',str],
2 r( z2 z1 w! J& ^            'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
; z3 m/ M% |9 C* q            },
        write='result.txt',
        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
        page=[True,"now_url.txt"],
. c, I  m, a9 b/ k! [        #clean=True,
$ a; C5 y4 _1 C( @7 y        texting=True,
        # 参数如上
, r, q" ~) r' h# I5 x/ Z        status="between",
6 w% l" Q* W* G. s        cpu_count=1,
        sem=5,
        ###
1 ?$ h0 L* }9 g2 d4 M" k( T        write_SQL={
            'host':'localhost',
5 a/ d7 C6 j) n; U* p            'post':'3306',
            'user':'root',
6 s+ {3 L5 @# l: h1 \            'password':'123456',
            'db':'example',
# _6 p$ R; Q- Q            'table':'example'
- C6 l" F0 F9 K4 i            }
5 g6 x8 S! _' p0 [).run()

& h! q& P8 C! p' D7 u
4 s+ L* ~; p: |" \功能介绍完毕🤞
最后还是希望你们能给我点一波小小的关注。
奉上自己诚挚的爱心💖
————————————————
/ G, z- E# j" e' I版权声明：本文为CSDN博主「꧁༺北海以北的等待༻꧂」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_45414559/article/details/106005684
. O/ w, M3 H/ U+ D" Y
  a7 F2 w/ Q4 \4 B5 T1 Q+ ~
/ e. @; `6 m: s: ]& _

738391227

66666666666666666666666666666