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

zhangtt123

仅需一行代码写爬虫–simple_crawl
simple_crawl
仅需一行代码即可达到爬虫效果
* i+ K  N$ s" h0 d! ]# R9 n项目地址(欢迎star):https://github.com/Amiee-well/crawl
使用方法
& J- e% t6 U  g" Dpip install simple_crawl

! h7 Y8 b; }. u9 Z; u### 以下源代码为简单介绍,详细功能介绍再源代码之下
from simple_crawl import request
# |3 W) ^6 _6 K$ jrequest.parse(
        # status 参数为运行状态,支持单线程多线程多进程协程以及联合
        status="aiohttp",
        # url 参数为爬虫网址,单线程状态为字符串格式,特殊状态为列表格式
        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
& O3 T1 v2 ^" e) d* V, ~        # login 参数为获取登陆信息,如淘宝等网址需要登陆信息
    #login="taobao",
& o7 l: K7 F/ i- N4 F( [) ]+ P    # type_url 参数为返回源代码格式,支持text和json,默认返回text
    type_url = "text",
1 {4 J* E6 [; v* N' F    # Parsing 参数为解析方法,支持re、xpath和beautifulsoup
    Parsing = 'xpath',
/ v! }: d& h1 T% U9 o- I% X    # label 参数为爬虫解析过程,字典格式,详情见下方
0 O0 ?5 j: X3 g6 n. {; \  Z, t    label = {
) D% J$ e, ^7 b            'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
/ d7 j9 B& ~0 G$ M" C. q" b& P            'name':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/text()',str],
. K3 V. B- r9 o* S6 Z            'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
  G* m8 Q+ Y. K2 s     },
     # write 参数为爬虫结果保存,支持txt、csv、pkl、json,注:特殊状态爬虫信息容易混乱
     write='result.txt',
9 `7 P2 z' j2 N# B5 v     # next_url 参数为下一页爬虫地址,@必须为href,仅支持单线程爬虫
     next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
1 E1 t7 _7 _: J; d1 c- g9 A! L; a     # page 参数为断续笔记,第一个参数是否启用笔记,第二个参数选填默认page.txt,仅支持单线程爬虫
     page=[True,"now_url.txt"],
     # clean 参数为是否进行数据清洗,防止大量爬虫收集无用信息
     #clean=True,
$ [& ~; I& ?; p  K" Y4 C& Y, g     # texting 参数为是否选择连续爬虫,避免爬虫过程中出现非代码问题报错结束爬虫程序
     texting=True,
# R- X% g* Q! G     # Thread_num 为多线程数,默认为1单线程,支持多线程状态和异步状态
5 [4 x5 {; A2 }6 J% v1 R6 ^5 h5 h     Thread_num=3,
     # cpu_count 为多进程数,默认为1单进程,支持多进程状态和联合状态
* m0 |. w# l: n; B: x% J     cpu_count=1,
     # sem 为异步控制数,默认为5同时启动,支持异步状态和联合状态
0 O5 P) _2 r+ g     sem=5,
     # write_SQL 为是否写入数据库,默认否
     # host 参数默认localhost
' ]1 T8 K2 X0 P9 p4 ~4 z* }8 r     # post 参数默认3306
9 _0 @! m1 f8 Z% r4 `  L0 a% Y     # user 参数默认root
% `9 C  @- W  j  S" \     # password 参数必填,必须正确
  Q4 i: y) w9 A. x$ v; D4 N     # db 参数为即将存入的数据库名,若不存在自动创建
! u& ^0 d* q0 m& l6 _0 h     # table 参数为即将存入的数据表名,若不存在自动创建
  u3 l0 M! Y( r3 J' U) \% Z* r     write_SQL={
         'host':'localhost',
/ S5 y. Z7 t+ H  d, N$ Z         'post':'3306',
         'user':'root',
         'password':'123456',
         'db':'example',
         'table':'example'
+ P6 Z1 C# f4 M5 G      }
).run()
7 e1 m; t2 O5 `3 ~1 Q
) V7 L* H( J( o. N9 J介绍一下crawl参数设置：
5 G  F+ P) x* k# F* p/ n
4 x5 k1 I* m; J- |'''
9 M# d+ ]2 P0 I- r+ A1 W单行代码爬虫程序执行
- L- a& a2 M* Q0 t6 ~:param status:启用爬虫类型,支持普通爬虫、多进程爬虫、多线程爬虫、异步爬虫、异步多进程爬虫,参数请参考文档
:param url:即将请求的url地址,仅支持get请求
:param type_url:请求url后返回格式,支持text和json格式返回
" I* t' v  I6 @) b- ^" V:param Thread_num:即将启动多线程个数,默认为1单线程
$ o0 g: W* C" T' a5 m:param sem:协程信号量,控制协程数,防止爬的过快,默认为5
( r+ }- K% @! _:param cpu_count:运行爬虫使用多进程cpu核数,默认为系统核数一半
:param login:模拟网站登陆,保存登陆信息
+ @- X8 \( ~. f1 A2 b3 ], k:param Parsing:爬虫方式,支持re、xpath以及bs4方法
:param texting:是否启用连续爬虫,爬虫程序异常报错后重新启动爬虫,
                       多次报错结束程序,默认否
:param label:选择器内容,字典格式保存,
                     字典值为列表格式,第一个参数为选择器,第二个参数为转换类型
                     第一个参数必填,第二个参数默认str类型
:param write:是否写入文件,支持txt格式、csv格式、json格式以及pkl格式,默认否
:param next_url:是否跨页爬虫,选择器内容使爬虫继续翻页爬虫
/ s, v/ R" r+ J4 F. V! ~:param page:是否选择断续笔记接手下次爬虫处理,默认否
:param clean:是否进行简单类型数据清洗,默认否
:param write_sql:是否写入数据库,默认否
                         'host'默认为'localhost','post'默认'3306','user'默认'root',
% L" ~; n' T% s- w1 }, }: ^                         'password':'密码','db':'数据库','table':'数据表',
                         检测库是否存在,若不存在则创建,若存在则直接插入,
$ Y3 I0 r  x  o                         检测表是否存在,若不存在则创建,若存在则直接插入
8 L9 a. o/ D' C$ }  u:return True
2 s- o! r3 Y# `' Z( K'''
- G" t3 ?: t( T8 Q介绍玩法
接下来介绍的均为调用第三方库的情况下运行：

" ^3 m! F7 L* d# q* P- i" N; Xfrom simple_crawl import request
  o! ]' C; J, ^! ^# X1 |) H第一种玩法：输出源代码
调用requests库进行源代码请求。
% m2 k, z! k$ @3 ]+ y' M, n
特点：
0 n3 F; S: S: a" \/ g! G: n* [: v请求失败则调用ip池处理重新请求访问，
出现五次失败默认网址输入错误。
支持text以及json字符串返回。默认text。
! N2 o+ s$ U3 h, D' k! g
+ r3 W* g: h& [5 V缺点：
暂时只能进行get请求，不支持post访问
/ E) |. ]9 e# }. d
：return text or json

request.parse(
* X) ?! f+ q8 ~8 e5 X2 `. u        url = "https://www.douban.com/group/explore",
, l$ p4 f5 a1 n  s' b" h; i& K" X        type_url = "text"
).run()
# return text

第二种玩法：模拟网站登陆并保存信息
调用DecryptLogin库请求登陆访问。
6 ^" }" o4 l# q4 G" t
( W. k0 l0 v) y  q' z5 W1 s" aps：DecryptLogin库为大佬皮卡丘写的一个很不错的模拟网站登陆库，在此引用一下，因为单行爬虫原因不支持账号密码登陆，我将大佬写的二维码登陆使用过来了。再次感谢大佬开源
在此放出文档地址
* c1 ^5 `* k8 x- dDecryptLogin库中文文档：https://httpsgithubcomcharlespikachudecryptlogin.readthedocs.io/zh/latest/

特点：
将DecryptLogin库中二维码继承到此库（非二次开发）
$ |( }* b9 e; f, j  K( H! M支持QQ群、QQ空间、QQ安全中心、淘宝、京东和斗鱼登陆（大佬登陆库中所有的二维码登陆）
保存session.pkl信息到本地方便下次登陆运行

2 v" \; d: I3 c缺点：
( \- g, k* n% ^- W% asession.pkl登陆信息过时无法自动删除。
5 I: E$ j  Y! B* W% S2 J导致下次登陆疑似cookie无法正常登陆。
+ q( T; D+ L: V; Q
:return session
: Z1 g& X$ w! ?( H9 V) {& _$ H3 r
6 G7 o3 `3 X( D9 zrequest.parse(
        # 臭不要脸的推广一下我的店铺
        url="https://shop574805287.taobao.com/",
) D. E* \( V+ \0 ?* {, m$ b        login="taobao"
0 |! v( [- g- Z# A5 _).run()
: |) c- r' Y' k! |$ B; k& b6 P0 @# return text
) y' e3 A/ o% _
6 j) J* W: t: F  I8 V( s9 V第三种玩法：爬取网站信息
爬虫库自然少不了爬虫的过程

特点：
支持re库，xpath解析以及bs4选择器。
8 W& _9 m0 `! a% I, |" u; u爬取方法为字典格式。单方面输出。
  H- D+ R1 T. M字典键为保存的字段名称。
字典值为列表格式：第一个参数为选择器，第二个参数为转换类型。第一个参数必填，第二个参数默认str类型。
& ~7 X( T$ O; O* i$ A, f
缺点：暂无（等待小伙伴们发现）
9 N( I/ ^2 s6 [) q( x
：return reptile_results
- u" @( w( F0 n
request.parse(
        url='https://www.douban.com/group/explore',
        # 字符串格式,选择器方法。
7 Y8 I# ?: ]* A9 k) e    Parsing = 'xpath',
( N) r- P; g0 \) }$ v& ^4 t6 S( S    # 字典格式,参数如上。
    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]
  l1 e; s2 q8 A        }
).run()
# return reptile_results（list）
9 S. R; t4 X- S) D8 t
第四种玩法：自由保存信息
# V  e& i$ H& I9 i2 r5 ]目前版本支持保存txt、csv、json以及pkl四大主流文件。日后版本更新将发布更为全面的保存方法。

9 t( Q  a0 c1 X1 ?$ U特点：
( J' g' c# j7 n- y. c5 t& B写入文件均为数据格式传入文件。
且输入格式规范方便阅读and省事。

- J; r# m# q! [缺点：
保存格式仅四种，
$ d$ @0 a& {7 D" T% E" B% s6 Y不方便用户之后读写操作。
: P5 b4 r1 `. c  c
% p. f1 ^: I* _：return file
  y5 d, j" m* |2 q& D3 A
request.parse(
' E3 q$ \0 }7 b( w% B' G3 w6 H        url='https://www.douban.com/group/explore',
. y4 C7 j" I. q    Parsing = 'xpath',
    label = {
+ h1 Y/ U% R8 v- m9 L6 q        'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
6 W( m( D9 B; P, D2 n+ M8 u) I% Y        '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 L0 D: ^4 S4 G0 k# K/ T8 c    # 字符串格式,具体保存位置填写
4 o. @; z6 K0 n    write='result.pkl'
).run()
5 z' s' p0 E  T1 N7 o# return file
% J4 ~0 ~* S- D/ ]
第五种玩法：读取下一页 url 地址继续爬虫
7 r" Z$ U# o/ c7 O" T/ n4 f这也是每个人都担心的问题，仅仅一行代码怎么可能翻页爬虫。这还真能做到哦~

特点：
, w! h. ?* g& p0 A( w继承之前的Parsing参数选择器选择方法。
在这里可读取到解析后的下一页 url 网址。
# ^! F" ]2 y; i" c; K" L方可继续进行爬虫处理。方便用户使用。

缺点：
若爬虫时下一页 url 地址改变，便结束爬虫。
只能爬取所给 url 地址中的信息。
$ p8 x8 N# O. w- f1 _无法进行某一界面的多个网页爬取返回。
造成访问页面单一流失。

：return None
7 {; C# N+ Q" E& b, g4 x
request.parse(
        url='https://www.douban.com/group/explore',
    Parsing = 'xpath',
" [! n! c3 r! v7 P& f    label = {
* Q) e5 t2 R( }0 t0 d7 f/ g/ n+ u        'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
, v/ \6 g2 U* g  J6 Y' 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.pkl',
6 I8 {: Y) v( L" M8 X3 N1 J& r    # 字符串格式,根据Parsing方法继续请求下一页a中href
9 _$ ?$ S3 u- X& o1 k: w. m: T    next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
).run()
# return None
& {0 Y, n8 p( R0 @% K4 l! p% n4 r
0 B1 y4 y) e$ Q# x: q3 x7 R& P2 f' E第六种玩法：爬虫网页保存
听说过爬虫断续重连的朋友应该懂得这是个什么神仙操作。每次爬虫运行期间好好的，睡一觉醒来发现代码报错了。。。这就是个很难受的事，还不知道之前爬取到哪一页了，只能重新爬虫了啊！

特点：
持续输出断续笔记。
: c: l! c: S* E# \, n将此次爬虫的 url 地址保存到一个文本文档内部。
下次读取文本文档即可快速进行直接断掉的爬虫 url 地址继续爬取所需。

缺点：
/ R% I/ Z4 b7 [& b' u0 e读取内容不单一。
导致下次爬虫无法正确读取上次爬虫留下的痕迹。

$ F* J! c" R. p8 M& l5 {  O: i. O：return url_file

request.parse(
/ K; H  M( a% P( Z6 s    url='https://www.douban.com/group/explore',
    type_url='text',
    #login='taobao',
' a4 ^7 y& s1 X: l    Parsing = 'xpath',
    label = {
+ r( C( j& _: K, J/ G9 b        'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
( [5 X4 ]- l0 h        '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',
3 j( v2 H/ V; ~) u0 i6 i    next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
: `5 G+ G1 Z! y6 q* p1 M/ a$ B$ r& h# k5 Y    # 第一个参数为是否需要断续笔记。
+ ]/ Q: F$ j$ S1 ?( Z+ p    # 第二个参数为断续笔记保存位置。
4 j2 T6 d8 S) z* }0 F7 P" r    page=[True,'url_page.txt']
% V- J$ N; [! S' F).run()
# return url_file
1 w" m+ x& S  J' k- ]
& @0 u6 ]1 u! B  {! d" Q  C第七种玩法：简单数据清洗
数据拿下后，直接保存到本地有些大佬可能觉得很辣鸡，连清洗都不清洗就存入本地了？那得拿到多少废数据脏数据。那么接下来介绍一下清洗参数。

' t; x% H! }9 h) U) s" q5 g特点：
  i$ e* }  T: [. B$ l% q# s本人曾写过一个底层数据清洗。
能将列表格式数据进行归分清洗。
7 ]0 W6 O/ d0 S2 i+ o5 K) H5 X主要内容请参考另一篇文章
如下连接：数据清洗
3 s5 i# Q" r9 U" C2 s
7 q  V7 h9 r: G5 i, v$ O缺点：
数据清洗格式简单。
) w: ]5 z5 m5 J: G& H数据清洗内容单一。
无法完全做到绝对清洗。
5 i; q$ `; d0 x5 l2 g! f有待改善。
, q0 o, H4 x- }5 p# L" B
+ E2 h) q, T, }/ F- u：return keyword_list, value_list
8 D& P. ], Y0 o7 S! [2 |
request.parse(
/ j/ T& i# L6 }. h    url='https://www.douban.com/group/explore',
+ V* J8 C$ \5 Q: i9 P    Parsing = 'xpath',
! L* T! y! V- Y( a( T( C    label = {
        'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
2 i8 N* F. c3 |6 ?8 ~! N1 D& W; @        '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, I9 X) [0 g        },
    write='result.pkl',
4 k- c8 a4 e3 N& u6 d    next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
    page=[True,'url_page.txt'],
% j& W, T- K/ w& z' r& C: r    # bool类型,默认不清洗
& \7 s7 x) a5 G    clean=True
).run()

2 r/ `/ @' t- l( r' R9 p+ i, r( q! h" u第八种玩法：爬虫存入数据库
# |9 m. r! @7 b3 B+ T1 n1 F存到txt、存到csv、存到json、存到pkl，那也太low了吧。现在流行的数据库用不了么？那是不可能的。。
- C. y5 X4 W- J/ V
特点：
信息存入MySQL数据库。
9 c8 D. F% R. V8 ~可连接docker远程数据库。
+ M) U0 ?. F  E8 \+ [. s. j数据库的库名可以不存在。
数据库的表名可以不存在。
) j5 V; [$ u& ?5 F根据之前传入字典键与值参数判断表类型。
自由建立数据表传入信息。
0 r3 H+ s. R  a0 w
缺点：
% ]  Q4 E: B2 Q# r$ N& a仅支持MySQL数据库。

1 Y  J- o7 h5 k$ n) G：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],
* t) n: ^+ `5 V$ r0 ]        '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]
        },
$ {4 o% z2 i: s; `5 t    write='result.pkl',
  h: w2 @+ |' \: n, I+ U- x  Y    next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
: |. N4 S0 Q% F4 g6 D8 M9 L( v* ~( ]    page=[True,'url_page.txt'],
: L" i) s3 n% H' a/ @' h    clean=True,
    # 字典格式,
    # host可有可无,默认localhost
) E+ v; a) U$ q4 F2 [    # post可有可无,默认3306
    # user可有可无,默认root
# d0 a2 |( W2 e& M$ o) r    # password必要参数,数据库连接密码
# ~5 i7 l/ u  q    # db必要参数,数据库即将存入的库名
4 `% J. f# ?* p- J/ L    # table必要参数,数据库即将存入的表名
8 t- D, U8 V+ m3 O    write_SQL={
        'host':'localhost',
        'post':'3306',
1 Y( a) Y! x3 K0 `        'user':'root',
* g0 P2 Z1 o7 B4 S        'password':'123456',
        'db':'example',
        'table':'example'
8 f5 V; w2 l' V1 ]2 F5 H. {% f2 N        }
    ).run()
7 y5 T! t, ^& ]( h
第九种玩法：重新启动爬虫
爬虫最让人厌烦的就是被一个不痛不痒的错误信息给终止爬虫了，比如意外的远程断开链接等低级非代码错误，报错之后还得重新启动断续爬虫，就显得很麻烦。我做了一期爬虫程序异常报错后重新启动爬虫，多次报错结束程序。
7 o% C( Q8 {& {  Z+ }2 a
3 J% I8 o4 l: V& ^5 M特点：
检测报错重新启动爬虫
无需手动处理错误信息
# i1 }2 u( j+ @
缺点：
无法收集子线程错误。
" U+ J" {5 B' b/ p3 }
7 z9 J4 L7 E; Y( f' {* f9 E：return None
9 Z2 e4 x2 [0 O" m0 d
request.parse(
        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
        #login="taobao",
6 r4 t! i1 }3 J) ?        type_url = "text",
        Parsing = 'xpath',
! G7 v: r1 C) }2 \$ v4 @        label = {
5 q7 L7 U' {( k0 j8 ]4 F            'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
, W/ ?+ L9 V6 D9 ?1 y            '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',
! j' Y; @# d+ d% k: ?1 k' O        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
# j' A2 R- g# ?8 p( K1 m) r+ p        page=[True,"now_url.txt"],
6 H$ Z: Q7 l2 c        # texting 参数为是否启用连续爬虫
        # 爬虫程序异常报错后重新启动爬虫
* c" e# y- S+ p) E, N        texting=True,
: I/ _0 b* N" h1 g9 u        ###
2 ?. e: H2 E" x, G# O        write_SQL={
; p- ~5 Z: {* i) ]            'host':'localhost',
            'post':'3306',
& D7 l, ~3 i6 y+ \% k! `5 |  {            'user':'root',
            'password':'123456',
            'db':'example',
            'table':'example'
7 x3 L4 i$ p9 c, A3 `            }
).run()

第十种玩法：多线程爬虫
, P7 q% k  |" ?/ z特点：
爬虫速度加快，
更好的利用了线程。
% Y% t5 X0 ]2 F2 D; s/ a
; R- U# j" ], ]; ^9 d+ v; t缺点：暂无

, t& U; ~/ s/ v6 l1 e' c% a：return None
$ q6 d1 s! `* z+ Y# r, z! V! H
request.parse(
5 R$ h* s' K$ p        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
. _9 \3 J. ~- u0 D. `: V) N        #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],
- c6 U+ B' `: R  e: e            'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
2 N4 I% v) O9 g9 w6 j' Z  G+ s' E            },
* w. m' V' E/ o$ F% v+ T        write='result.txt',
        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
        page=[True,"now_url.txt"],
& H! x: C( b9 g2 c  O& E        #clean=True,
5 |2 t9 y6 b( a- _! }( A8 [        texting=True,
* b# A% U' [" D1 {6 y6 E8 v        # status="threads" 启用多线程爬虫
$ f; A9 c  Y1 I  N4 V7 N        # Thread_num 为线程数目,默认为1 单线程
! w: V2 X( `+ L0 X/ \        status="threads",
/ v( h# u0 y2 v2 p) `5 Q/ H        Thread_num=3,
        ###
! g) f- H4 `7 d! X5 i        write_SQL={
            'host':'localhost',
  m! S$ p8 R3 k            'post':'3306',
: l5 E1 u0 ]! O4 V            'user':'root',
2 [) q, K( t$ `/ {# f            'password':'123456',
3 s7 p2 e0 c2 |' `4 I            'db':'example',
4 _6 j. A% f7 K% P5 ?  f& J            'table':'example'
            }
).run()
" U1 G+ \* N9 t$ Z) Q$ u3 F
第十一种玩法：多进程爬虫
  |$ L9 F1 Q1 _6 l9 ^# z! Z  \5 l特点：
爬虫速度加快，
5 Y6 i# q' `; C, _/ b$ P/ o更好的利用了进程。

' }1 I6 F! E6 q+ @缺点：暂无
" z* T2 ?& S0 @- X
+ D6 C$ ?4 h, a/ Z5 \：return None

from simple_crawl import request
request.parse(
9 D8 N4 Y7 r3 w2 r        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
        #login="taobao",
5 ?$ N& v+ N3 m        type_url = "text",
        Parsing = 'xpath',
        label = {
- Z8 C% U4 m5 u1 j7 |5 e! i: q1 s            'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
# p0 O7 r" C# U- t; O. Y# ]            '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 _1 _) U5 ^0 J9 b            },
" L7 Q8 F5 E9 @: x, v6 G        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="multiprocessing" 启用多进程爬虫
        # cpu_count 为启动代码核心数,默认为系统核数一半
        status="multiprocessing",
- }0 ]8 q. A0 V1 {        cpu_count=2,
        ###
, O' A1 a) K0 Y/ z- r: J        write_SQL={
            'host':'localhost',
; j2 ]. h, b9 X2 c; U, ^0 K            'post':'3306',
1 w  g/ F. e- O8 Q            'user':'root',
            'password':'123456',
            'db':'example',
+ H8 F3 G4 b% E            'table':'example'
            }
! S( K; d1 B: X; U4 Q).run()

第十二种玩法：异步多线程爬虫
/ J' h3 t( a$ W: J特点：
爬虫速度加快，
异步使得爬虫无等待时间，
同时使用多线程速度明显加快。

缺点：暂无

7 C. W  O8 X9 o0 g" Z' i9 I' i' i：return None

6 Y! i9 s" J7 X+ B! f0 ofrom simple_crawl import request
" o: Z, \/ t: U& H; h& q* @! drequest.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],
- V2 c" N$ J. Z/ e2 e+ u- r            'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
3 B. ~8 {) k4 n; B( A, B9 ?( P+ k            },
/ W7 J* B, H/ [, [8 _        write='result.txt',
        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
' E) \& }4 N1 Q" {        page=[True,"now_url.txt"],
& i% Q/ j0 o3 g; k/ R0 R        #clean=True,
: ?) ~! L, |2 R* D1 m7 j+ O& _        texting=True,
        # sem 参数为异步引擎数目,默认为5
        # 其他参数同上
" `/ g8 S' r% v. T8 H  G        status="aiohttp",
        Thread_num=3,
        sem=5,
        ###
        write_SQL={
            'host':'localhost',
            'post':'3306',
6 \) Y3 v9 [6 ]+ k4 ^            'user':'root',
            'password':'123456',
            'db':'example',
5 B' A) m$ k1 {  \            'table':'example'
            }
- R* C: _+ E7 H8 ~2 ]2 a. U/ r).run()
( K3 z; b) k) ~, ]4 V
& O; A. ?- r, F  w0 e3 ?9 t第十三种玩法：异步多进程爬虫
0 A9 N9 _+ t1 B特点：
爬虫速度加快，
6 h$ L5 E2 w8 o( X. F+ o+ e* s异步使得爬虫无等待时间，
同时使用多进程速度明显加快。

缺点：暂无
" ~) s* c: G, G
：return None

from simple_crawl import request
8 g* _! G* k8 T* ]1 ^/ l8 Arequest.parse(
( D9 |$ ~, o+ z# S' {( Q        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
        #login="taobao",
        type_url = "text",
6 e2 b9 W* ?+ L0 ^4 F! p$ R9 }/ \        Parsing = 'xpath',
. \+ ^# [9 R# x0 _8 c        label = {
5 |/ F5 K2 ?6 @! G9 ?0 e: q" 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],
  @7 ?. @0 N1 H            '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"],
& M6 c6 g$ p& n% H3 a4 c2 j        #clean=True,
        texting=True,
9 C9 S/ e9 [! m- f8 @  X# v7 j        # 参数如上
        status="between",
        cpu_count=1,
        sem=5,
$ l: k, M6 b9 a4 B( N* t        ###
        write_SQL={
4 D1 D2 Y$ _: d- z' a0 Q  h            'host':'localhost',
            'post':'3306',
            'user':'root',
5 ]! _# J& c0 k            'password':'123456',
. ]; z2 E4 D; J: P            'db':'example',
            'table':'example'
            }
7 c; |' X; ~8 w).run()

* n4 m, y. W- Y4 ^( G4 L
- G1 L( k9 s+ A' D1 W0 k0 a功能介绍完毕🤞
) A0 v+ `& s. _5 Y2 p9 x6 [最后还是希望你们能给我点一波小小的关注。
奉上自己诚挚的爱心💖
7 s& C; S6 G5 I1 p, Y8 ~! P; O————————————————
版权声明：本文为CSDN博主「꧁༺北海以北的等待༻꧂」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_45414559/article/details/106005684

738391227

66666666666666666666666666666
! A3 v" W( p4 ?) l6 k: J( R