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

zhangtt123

仅需一行代码写爬虫–simple_crawl
simple_crawl
- F5 N! y0 o& G# N7 q- H仅需一行代码即可达到爬虫效果
项目地址(欢迎star):https://github.com/Amiee-well/crawl
使用方法
pip install simple_crawl

/ [; K6 X0 E7 ]$ @### 以下源代码为简单介绍,详细功能介绍再源代码之下
6 |$ T7 J: x) T7 Q0 Efrom simple_crawl import request
- w1 W9 a3 d8 `4 n0 }request.parse(
% h2 v! l6 ]' t6 q9 d        # status 参数为运行状态,支持单线程多线程多进程协程以及联合
7 c1 z; Y3 \8 g2 }1 g( v  {        status="aiohttp",
        # url 参数为爬虫网址,单线程状态为字符串格式,特殊状态为列表格式
        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
. m! `! H  K9 i5 q        # login 参数为获取登陆信息,如淘宝等网址需要登陆信息
    #login="taobao",
( m' O5 z% G3 G4 |, X# k8 R0 c! s    # type_url 参数为返回源代码格式,支持text和json,默认返回text
: r; \1 C1 |  Q# A8 R5 ~% y    type_url = "text",
8 y; S+ T" b' m* D5 A    # Parsing 参数为解析方法,支持re、xpath和beautifulsoup
    Parsing = 'xpath',
    # label 参数为爬虫解析过程,字典格式,详情见下方
% ~* E% S7 [) o    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],
* v4 \% o* B* v  {! _- C            'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
6 j) \, A, `+ r     },
/ l2 m: s% E, f; U6 E) o3 Z     # write 参数为爬虫结果保存,支持txt、csv、pkl、json,注:特殊状态爬虫信息容易混乱
     write='result.txt',
     # next_url 参数为下一页爬虫地址,@必须为href,仅支持单线程爬虫
3 }3 q1 g* q: s, G; b4 W$ y; C     next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
( P7 y" m( z' K/ b! K     # page 参数为断续笔记,第一个参数是否启用笔记,第二个参数选填默认page.txt,仅支持单线程爬虫
     page=[True,"now_url.txt"],
+ R- n! J- c& s/ _% v     # clean 参数为是否进行数据清洗,防止大量爬虫收集无用信息
" H' B! W- q+ a' D0 Q     #clean=True,
     # texting 参数为是否选择连续爬虫,避免爬虫过程中出现非代码问题报错结束爬虫程序
/ ^$ @; q6 P% z  V" y' @8 n     texting=True,
8 ^1 l6 @& b; B: v; C0 l     # Thread_num 为多线程数,默认为1单线程,支持多线程状态和异步状态
     Thread_num=3,
     # cpu_count 为多进程数,默认为1单进程,支持多进程状态和联合状态
# j' h. a  J, S; l; N$ H     cpu_count=1,
: m/ F! J- r6 z     # sem 为异步控制数,默认为5同时启动,支持异步状态和联合状态
8 V$ o# C) a6 c) g! o     sem=5,
/ X4 ~& y6 b9 q' s" o     # write_SQL 为是否写入数据库,默认否
: c2 Z: N' N! ^6 a     # host 参数默认localhost
     # post 参数默认3306
     # user 参数默认root
     # password 参数必填,必须正确
     # db 参数为即将存入的数据库名,若不存在自动创建
9 H% }/ F( p8 |: F     # table 参数为即将存入的数据表名,若不存在自动创建
1 U! [9 Q" q0 W     write_SQL={
         'host':'localhost',
         'post':'3306',
% @( K, q7 h$ y         'user':'root',
         'password':'123456',
         'db':'example',
         'table':'example'
' j; k* v. G6 [4 n% K% `      }
).run()
9 [4 p) @  V3 {' E9 _% H
/ x: M/ `7 B8 `. o1 E介绍一下crawl参数设置：

'''
单行代码爬虫程序执行
:param status:启用爬虫类型,支持普通爬虫、多进程爬虫、多线程爬虫、异步爬虫、异步多进程爬虫,参数请参考文档
+ X  C- ]; q. R# |: }! e:param url:即将请求的url地址,仅支持get请求
2 h0 C& ^# e% X* \) b! `:param type_url:请求url后返回格式,支持text和json格式返回
, e5 a; w* Q/ V# f# A& ^& `:param Thread_num:即将启动多线程个数,默认为1单线程
:param sem:协程信号量,控制协程数,防止爬的过快,默认为5
:param cpu_count:运行爬虫使用多进程cpu核数,默认为系统核数一半
# }1 y1 n# [% u0 T) {" Z7 R- i:param login:模拟网站登陆,保存登陆信息
1 `, |6 M& y5 r5 F! _2 [. T/ g:param Parsing:爬虫方式,支持re、xpath以及bs4方法
! G8 N( F2 z/ ?- A2 h/ d7 s:param texting:是否启用连续爬虫,爬虫程序异常报错后重新启动爬虫,
                       多次报错结束程序,默认否
:param label:选择器内容,字典格式保存,
/ ~' i! R/ s" \& _. i                     字典值为列表格式,第一个参数为选择器,第二个参数为转换类型
                     第一个参数必填,第二个参数默认str类型
:param write:是否写入文件,支持txt格式、csv格式、json格式以及pkl格式,默认否
9 m  S* v+ T5 }* ?:param next_url:是否跨页爬虫,选择器内容使爬虫继续翻页爬虫
1 h& y& _- n, p1 d" _:param page:是否选择断续笔记接手下次爬虫处理,默认否
  p5 N: V8 w9 \! q) [7 q:param clean:是否进行简单类型数据清洗,默认否
:param write_sql:是否写入数据库,默认否
9 S, g. w! ~0 z# k/ }                         'host'默认为'localhost','post'默认'3306','user'默认'root',
* i+ \6 G: y8 `# m0 G0 |                         'password':'密码','db':'数据库','table':'数据表',
                         检测库是否存在,若不存在则创建,若存在则直接插入,
' T2 B. m' S) T                         检测表是否存在,若不存在则创建,若存在则直接插入
:return True
'''
介绍玩法
接下来介绍的均为调用第三方库的情况下运行：

from simple_crawl import request
9 I" S4 |' V! X  w第一种玩法：输出源代码
* W3 J* |7 i1 Z1 P; C8 A调用requests库进行源代码请求。
! L) ?+ a; B2 y1 D) N# Z9 E
( ?* H% z8 h4 F4 \$ C特点：
- [% b, Q( v, ~! v请求失败则调用ip池处理重新请求访问，
) Y3 y5 v! z2 h; {2 Y! P出现五次失败默认网址输入错误。
' c' g6 H) O: J; {3 s  E" x8 ?/ n支持text以及json字符串返回。默认text。

缺点：
2 ~! i! ^2 B, E' [; U暂时只能进行get请求，不支持post访问
4 h) n6 H  Q- m% I
：return text or json

5 |: Z' R! F1 H  x- m0 Frequest.parse(
% i1 u3 V- ?' b. E8 s) [        url = "https://www.douban.com/group/explore",
        type_url = "text"
  y3 X) w! i1 q( F" c).run()
# return text

第二种玩法：模拟网站登陆并保存信息
! u5 C- N, u. v$ K+ e3 s1 U调用DecryptLogin库请求登陆访问。

) }8 j4 G3 O; G( }ps：DecryptLogin库为大佬皮卡丘写的一个很不错的模拟网站登陆库，在此引用一下，因为单行爬虫原因不支持账号密码登陆，我将大佬写的二维码登陆使用过来了。再次感谢大佬开源
在此放出文档地址
DecryptLogin库中文文档：https://httpsgithubcomcharlespikachudecryptlogin.readthedocs.io/zh/latest/
2 t. [3 Q. b# @  Z" o" q4 \
6 ]4 E$ }" P4 c8 s特点：
+ U4 K6 ?# C, d将DecryptLogin库中二维码继承到此库（非二次开发）
支持QQ群、QQ空间、QQ安全中心、淘宝、京东和斗鱼登陆（大佬登陆库中所有的二维码登陆）
保存session.pkl信息到本地方便下次登陆运行
! w3 r; B$ w5 g( {" q# M
缺点：
session.pkl登陆信息过时无法自动删除。
导致下次登陆疑似cookie无法正常登陆。

:return session
0 n6 H7 l0 o) A3 R# g; _7 [
' Q* l( ]+ _: t8 a8 u3 @0 |" [request.parse(
        # 臭不要脸的推广一下我的店铺
        url="https://shop574805287.taobao.com/",
, b3 A; w6 i0 [3 W1 G" `        login="taobao"
8 n- `9 @: D: c# e- j/ n1 b! M).run()
# return text
/ R* G) f4 K  v( j; }- {% S; E; i
/ o1 l( M* C6 `9 f$ T第三种玩法：爬取网站信息
- I3 ?/ Y* y4 h8 `+ k4 a爬虫库自然少不了爬虫的过程
- ]: r, A2 A8 f3 Q# k8 @/ A
% ]3 D$ G3 w! S( V特点：
# U) ~, \: a' t! |  T" i9 e/ a支持re库，xpath解析以及bs4选择器。
爬取方法为字典格式。单方面输出。
字典键为保存的字段名称。
# }5 N% W) y$ H  ?/ w, L( [7 o# _字典值为列表格式：第一个参数为选择器，第二个参数为转换类型。第一个参数必填，第二个参数默认str类型。
1 Y* A! J& k7 Q5 ?
缺点：暂无（等待小伙伴们发现）

：return reptile_results

, Y( G; P: C1 t5 X$ X# Lrequest.parse(
        url='https://www.douban.com/group/explore',
        # 字符串格式,选择器方法。
    Parsing = 'xpath',
    # 字典格式,参数如上。
" N: v9 z- {6 b: ?& ]$ s4 a7 w6 C    label = {
5 W% l" _7 S, ?  d  q+ N        'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
$ p+ \* {2 m0 @- E8 ?/ 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]
0 `8 ]+ a0 S! H5 f        }
).run()
# return reptile_results（list）

$ k' b$ x" \) c2 x第四种玩法：自由保存信息
& X, t3 u, D* L: q目前版本支持保存txt、csv、json以及pkl四大主流文件。日后版本更新将发布更为全面的保存方法。

特点：
写入文件均为数据格式传入文件。
且输入格式规范方便阅读and省事。
. O. N% ?% y" {
缺点：
; W  Z# n. [( j1 L5 j! p: v保存格式仅四种，
不方便用户之后读写操作。
8 n% K/ f' n2 ~' U- x
：return file
6 G/ M" a. {* `% t/ r2 G1 w
request.parse(
        url='https://www.douban.com/group/explore',
    Parsing = 'xpath',
( K0 g5 P  d/ P" z    label = {
1 _% K  K  j2 c+ j/ h' E( m  ~/ r- q        'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
# P/ t& d& ]6 d        'name':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/text()',str],
3 X- Y' P) b* c# u1 R$ l+ R        'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
% h5 r; o5 x) n- [+ T' r3 s        },
( N4 Q' z/ M. ^: ^- P* y9 I' x    # 字符串格式,具体保存位置填写
7 K( `' n$ c" i" g# v5 z1 T    write='result.pkl'
).run()
# return file
4 R% |& Z' w8 V7 C% ^
第五种玩法：读取下一页 url 地址继续爬虫
这也是每个人都担心的问题，仅仅一行代码怎么可能翻页爬虫。这还真能做到哦~

6 h' m" k% e; b; q; T6 T1 C特点：
继承之前的Parsing参数选择器选择方法。
$ \6 p. r& U5 M- o& b在这里可读取到解析后的下一页 url 网址。
4 |. g# Y& F% e方可继续进行爬虫处理。方便用户使用。

缺点：
" ?$ p% o% x0 o+ ^! \! Q% g若爬虫时下一页 url 地址改变，便结束爬虫。
0 `1 `) |  n2 L- P只能爬取所给 url 地址中的信息。
无法进行某一界面的多个网页爬取返回。
造成访问页面单一流失。
$ L1 e9 e+ m8 A+ K
：return None

request.parse(
        url='https://www.douban.com/group/explore',
% [+ E$ J" m7 g! ^( y2 \    Parsing = 'xpath',
    label = {
        'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
' K; \9 N" U; U2 y" r8 N7 A, |        '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]
; s0 q1 R8 e- V        },
    write='result.pkl',
    # 字符串格式,根据Parsing方法继续请求下一页a中href
    next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
).run()
' D7 p( R5 g+ {# Q: X% t# return None

第六种玩法：爬虫网页保存
听说过爬虫断续重连的朋友应该懂得这是个什么神仙操作。每次爬虫运行期间好好的，睡一觉醒来发现代码报错了。。。这就是个很难受的事，还不知道之前爬取到哪一页了，只能重新爬虫了啊！
2 `' t. m* v& L+ V
6 G0 I# T  Q) b1 D& o1 {, a特点：
( @5 l  H" y. O2 w1 P; w# Z持续输出断续笔记。
* D  O9 v6 Z/ `2 }将此次爬虫的 url 地址保存到一个文本文档内部。
下次读取文本文档即可快速进行直接断掉的爬虫 url 地址继续爬取所需。
( S# z, |4 w% Y( |
% K6 _1 f8 h! w! n& G缺点：
读取内容不单一。
; f$ W+ R  W4 N$ N导致下次爬虫无法正确读取上次爬虫留下的痕迹。

：return url_file
' ^/ ?0 b- Z, ?0 t( d
4 g- e5 T8 b- O6 p. S4 E, ]request.parse(
    url='https://www.douban.com/group/explore',
    type_url='text',
+ o; [+ R8 w# [+ [! D( J  F. }! v4 W    #login='taobao',
    Parsing = 'xpath',
$ a5 V. K7 M# v    label = {
0 g( v' u! |3 ~) H4 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],
+ T2 m) i+ b! F5 K0 x        'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
" n& O6 L1 ]- ]& B' R        },
    write='result.pkl',
) O' @  M7 m6 v4 R7 d2 U$ w4 s% y    next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
    # 第一个参数为是否需要断续笔记。
# w2 e- v: S1 u    # 第二个参数为断续笔记保存位置。
6 P  a% J0 s6 O# t; S7 S4 g' ]    page=[True,'url_page.txt']
% [& t6 i! l4 y9 T7 v).run()
- w4 D  _0 d  z* o# return url_file

第七种玩法：简单数据清洗
$ {# V& R- p1 U  r& r数据拿下后，直接保存到本地有些大佬可能觉得很辣鸡，连清洗都不清洗就存入本地了？那得拿到多少废数据脏数据。那么接下来介绍一下清洗参数。

特点：
本人曾写过一个底层数据清洗。
# R1 Z: }. A# F能将列表格式数据进行归分清洗。
主要内容请参考另一篇文章
! ~" o+ ^1 |! A7 Z' l: ^! p如下连接：数据清洗

缺点：
数据清洗格式简单。
数据清洗内容单一。
  N( J7 N" d, v: t9 L( z! b无法完全做到绝对清洗。
有待改善。

：return keyword_list, value_list
" S0 P0 D6 D4 [  {$ Z' w# I
6 w% H  i5 b, U  l4 srequest.parse(
' I4 N! x2 W6 F. c    url='https://www.douban.com/group/explore',
% O: n2 h* B& ^" _* O. V0 x* Q- Q    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]
        },
& S/ n. i6 X  p: N( o' m    write='result.pkl',
    next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
    page=[True,'url_page.txt'],
( g3 W& G! }  H' C" _' _8 ^    # bool类型,默认不清洗
1 ]6 B5 v1 `0 p( _  [    clean=True
).run()
; Z. ?, \, A" L; }  |$ |
+ J" }( g( |  A; i# h' `第八种玩法：爬虫存入数据库
存到txt、存到csv、存到json、存到pkl，那也太low了吧。现在流行的数据库用不了么？那是不可能的。。

特点：
信息存入MySQL数据库。
可连接docker远程数据库。
# }, R' W/ a2 _- X数据库的库名可以不存在。
数据库的表名可以不存在。
根据之前传入字典键与值参数判断表类型。
自由建立数据表传入信息。

+ R8 O4 l( ^7 L3 K缺点：
仅支持MySQL数据库。
( N4 H. \1 N8 {0 N( M
：return SQL
2 A8 i8 p# c0 `7 h
9 L9 c& f8 \3 ?9 o1 arequest.parse(
) M$ p% G) s: V" o! Q1 X; }" a    url='https://www.douban.com/group/explore',
4 [1 t' q" R, G( I: h    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]
        },
9 l9 ~; D( Q+ R    write='result.pkl',
- p3 _1 w$ P. B# Q; J    next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
    page=[True,'url_page.txt'],
# [/ [; J% {6 p4 \. D    clean=True,
    # 字典格式,
1 Q3 ?3 Y8 r4 s4 _5 J& P+ s    # host可有可无,默认localhost
    # post可有可无,默认3306
8 ^' S9 T! j, ?2 p8 ^( B$ h    # user可有可无,默认root
' ?6 I+ L( }; A9 T    # password必要参数,数据库连接密码
. C% j: M" c1 P7 L" X    # db必要参数,数据库即将存入的库名
& E) f4 \* B' k7 C  V    # table必要参数,数据库即将存入的表名
    write_SQL={
( v. [( Y1 A2 d3 q0 m  c* d# N        'host':'localhost',
# F) J( f0 G. F4 {" e( i0 E# i        'post':'3306',
) P: t( i0 B& x& Y  G7 x' U0 ]- M        'user':'root',
* i: }" z$ V' H' F        'password':'123456',
0 \# q$ v  r  C. B        'db':'example',
        'table':'example'
7 O( F0 t! X0 M        }
2 s2 m# e8 q. b* s) M3 z    ).run()

9 h. B: R& A4 r3 r/ h第九种玩法：重新启动爬虫
% _+ H  @  N9 ~: n- n, k爬虫最让人厌烦的就是被一个不痛不痒的错误信息给终止爬虫了，比如意外的远程断开链接等低级非代码错误，报错之后还得重新启动断续爬虫，就显得很麻烦。我做了一期爬虫程序异常报错后重新启动爬虫，多次报错结束程序。
: q5 I7 t6 l% b
' {9 t  j6 m! f* Q  n; |3 D特点：
: \% T+ C& W/ g* j7 c+ U$ N$ H4 G检测报错重新启动爬虫
无需手动处理错误信息

缺点：
无法收集子线程错误。
1 o* s; Q$ ~& ?' O' g/ O
：return None
8 Z4 U' N  J2 o8 d7 v# ^( ]6 m; k
request.parse(
( b/ B% Z# w+ l/ D; T        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
        #login="taobao",
0 ]5 R6 e# F" |' r. ?0 U+ K        type_url = "text",
2 E5 i- ^: m% O. a, }/ @        Parsing = 'xpath',
) Q$ R- ^0 A# W# y- }" }3 T$ @        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 m; T4 U! k% i: D9 M9 n' O; }            },
! r, y: I# u4 A% f( ]* q        write='result.txt',
        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
5 [; x3 }+ {2 a7 L* R  \        page=[True,"now_url.txt"],
        # texting 参数为是否启用连续爬虫
$ X7 Q" i; ~$ R+ P4 e' s        # 爬虫程序异常报错后重新启动爬虫
        texting=True,
1 M. {! C! o2 E$ f2 @8 d( L2 z        ###
        write_SQL={
            'host':'localhost',
% h# v0 Q% Z; H& S* r0 e            'post':'3306',
+ G9 y+ x5 @3 `5 e6 _+ Y" ~& s            'user':'root',
) g$ X& M% E7 i) R  @- F            'password':'123456',
' ^% J, B% t5 {3 L) X            'db':'example',
! t" X$ u  E& ?/ C            'table':'example'
            }
) t9 \  K  u. E' o).run()

第十种玩法：多线程爬虫
5 ]7 s/ W: {% I9 y* i" Z特点：
爬虫速度加快，
更好的利用了线程。

缺点：暂无
2 ], |3 g& {" K' n- q7 P- y
& A: M5 k; [8 ~5 ?' ~5 _：return None

( Y+ m. d! [( }, L8 Lrequest.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],
" n- D9 H6 ?- 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]
            },
" i% ?1 O( o: C' G$ O        write='result.txt',
        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
6 w+ B/ G9 z' `$ p5 x! f3 t        page=[True,"now_url.txt"],
$ F8 ]) T" z) d3 C5 w        #clean=True,
$ Y3 r' h- L! B) C9 P- o* @; o        texting=True,
        # status="threads" 启用多线程爬虫
1 ?; ?% ^+ V7 D- ~" r& i        # Thread_num 为线程数目,默认为1 单线程
        status="threads",
        Thread_num=3,
        ###
        write_SQL={
$ c! ?- W2 [  m2 j            'host':'localhost',
            'post':'3306',
            'user':'root',
            'password':'123456',
. _* S6 x9 S+ B$ G+ C4 ^- `/ q            'db':'example',
8 d3 T, \$ }2 S4 r9 p            'table':'example'
            }
6 P+ P' h* m3 z2 [! I% ]).run()

9 J7 z5 c) e) z& H/ B2 _0 f. z第十一种玩法：多进程爬虫
5 D. g) A4 Y* Z5 ~& G! H+ ]# g特点：
爬虫速度加快，
- d( G5 C" H: g% z3 q6 y更好的利用了进程。

4 |7 _! i( T- e5 n& h: [5 v缺点：暂无

; i* G9 Y5 l& }  X- e% R：return None
* r+ Y' G2 ?) M% T8 ^" |% U
" G* D# V: u, Sfrom simple_crawl import request
4 w: w3 h( `; q  k& P7 t0 m1 frequest.parse(
! a; Y" b$ f: i* Z5 M        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
0 z* v( [' b8 e( E; T        #login="taobao",
. L0 A* ~, f6 S) C( X4 ~7 f        type_url = "text",
4 G& E9 L/ T: k( ]        Parsing = 'xpath',
% d! ~* R9 J8 ~" |5 [        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]
            },
! C$ a5 g2 l3 [  c        write='result.txt',
        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
, G- g% ]. [" Q: m2 p        page=[True,"now_url.txt"],
        #clean=True,
        texting=True,
        # status="multiprocessing" 启用多进程爬虫
( I' Z/ T& J. T+ K) f1 s        # cpu_count 为启动代码核心数,默认为系统核数一半
1 B$ w3 A2 a8 }, [" w# u( H        status="multiprocessing",
        cpu_count=2,
        ###
        write_SQL={
. y% Y3 g( B; M7 r+ f0 u, N. F! J            'host':'localhost',
            'post':'3306',
: n5 X& i2 _; ^! ]            'user':'root',
) b0 ?) |  W! a1 k2 {            'password':'123456',
' U" B! @. k" v, R' K' z            'db':'example',
" }2 p9 W3 X- e: a6 ^            'table':'example'
            }
' G6 l. _3 S; v3 @: M" Q1 S: {).run()
! A# ^2 N0 {1 K7 e" M
第十二种玩法：异步多线程爬虫
特点：
爬虫速度加快，
5 {, w6 Q0 j  y4 d! s/ Z异步使得爬虫无等待时间，
同时使用多线程速度明显加快。

2 m8 z! S& B0 U& v( i缺点：暂无

, O/ s! s0 R) k：return None
+ g9 `) j3 O1 C: N
from simple_crawl import request
request.parse(
$ g! H, l: W. @8 a% X( ~6 {        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
, d3 r2 \$ i2 f6 B0 o        #login="taobao",
        type_url = "text",
        Parsing = 'xpath',
        label = {
            'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
6 j- w5 e7 h. z% x+ g            '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 @4 ?& i1 S3 c; t. L            },
5 |* c8 O! I1 F        write='result.txt',
        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
        page=[True,"now_url.txt"],
        #clean=True,
; _" M# `  t, B# M        texting=True,
1 |2 ~6 ~; F3 d, j" _# a        # sem 参数为异步引擎数目,默认为5
        # 其他参数同上
5 w% o4 L# f9 L& ?2 i        status="aiohttp",
: \* Z; r$ U( F: b        Thread_num=3,
        sem=5,
" A1 o6 T8 n2 w3 _        ###
5 K( B9 u: [, M9 U: z0 B" x        write_SQL={
            'host':'localhost',
' C, W9 f5 e4 J4 f. M            'post':'3306',
, _4 |# ~3 Y# B8 s            'user':'root',
! g' f$ }( Z+ @3 I. O            'password':'123456',
            'db':'example',
            'table':'example'
* p7 ^( u3 H0 g3 d            }
).run()
* k- e8 u* g- K6 @! F1 n
第十三种玩法：异步多进程爬虫
特点：
爬虫速度加快，
异步使得爬虫无等待时间，
* W# T$ M0 R9 \7 D" I3 {+ C同时使用多进程速度明显加快。
$ h0 c0 }( B1 ]8 L
缺点：暂无
! l: h: W2 c7 D; a
/ i2 T+ y' O4 z：return None
6 R. k4 [( ~& |/ f$ F) ]: K2 A
from simple_crawl import request
0 A4 Q7 r5 P6 v% ]4 X, ^: @2 Lrequest.parse(
        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
        #login="taobao",
        type_url = "text",
: h& L: T! w2 K% D! F        Parsing = 'xpath',
        label = {
3 ^* U, f1 r6 V4 B0 O' Z. ]- m            '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]
            },
8 e! D! k: t- X& f; C        write='result.txt',
; H1 u  X! T, ?4 y( }% |% ~        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
- s7 F; o6 _. f: S6 K1 c        page=[True,"now_url.txt"],
        #clean=True,
1 U, Q: `8 z1 e1 k, D+ x        texting=True,
; K* B0 M, \3 W7 L7 w        # 参数如上
1 n' v- k& Z$ z3 K, L- b! k        status="between",
3 G1 L' d3 b" |5 t! Z/ O        cpu_count=1,
" _! i* ~7 z- B' {4 B0 x        sem=5,
; r+ a, W5 x9 S: k: J. g, {        ###
        write_SQL={
            'host':'localhost',
+ R7 v, k7 x9 r+ K            'post':'3306',
$ U) Z% e' d6 N! V2 |2 g            'user':'root',
' f: i/ _" B1 W2 h8 z& N            'password':'123456',
            'db':'example',
            'table':'example'
6 N, j  G9 V# i            }
" S* ]$ Q* G) H5 i).run()


% v8 ~* t1 \9 o2 Q功能介绍完毕🤞
最后还是希望你们能给我点一波小小的关注。
奉上自己诚挚的爱心💖
————————————————
+ {. Q- X" l: T版权声明：本文为CSDN博主「꧁༺北海以北的等待༻꧂」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_45414559/article/details/106005684
6 s% R6 C% |( e

738391227

66666666666666666666666666666