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

zhangtt123

仅需一行代码写爬虫–simple_crawl
9 n7 T1 C2 i' B4 h; k& zsimple_crawl
仅需一行代码即可达到爬虫效果
项目地址(欢迎star):https://github.com/Amiee-well/crawl
使用方法
, J5 j6 o0 ?# m* R, s3 Npip install simple_crawl

### 以下源代码为简单介绍,详细功能介绍再源代码之下
, M7 D* X. d/ i( k' a- i5 X% ffrom simple_crawl import request
# ]5 U; B7 `+ G3 W& Xrequest.parse(
7 x; m/ r: H& i6 t# |8 T        # status 参数为运行状态,支持单线程多线程多进程协程以及联合
        status="aiohttp",
        # url 参数为爬虫网址,单线程状态为字符串格式,特殊状态为列表格式
5 l3 ]* L. Y; R3 \7 N! f        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
        # login 参数为获取登陆信息,如淘宝等网址需要登陆信息
! V9 {3 S8 e' y% g0 o    #login="taobao",
    # type_url 参数为返回源代码格式,支持text和json,默认返回text
: D/ P) t3 F5 G8 W" C9 _9 X7 D    type_url = "text",
6 e. c* [, a* }! F" W6 {/ f$ F    # Parsing 参数为解析方法,支持re、xpath和beautifulsoup
    Parsing = 'xpath',
5 ]+ g6 s& _# l    # label 参数为爬虫解析过程,字典格式,详情见下方
    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]
. A5 ~% P6 B0 R$ i3 l" m% e- }$ `     },
     # write 参数为爬虫结果保存,支持txt、csv、pkl、json,注:特殊状态爬虫信息容易混乱
     write='result.txt',
' j$ |. @0 |  W9 K" W( O' Q. w4 _     # next_url 参数为下一页爬虫地址,@必须为href,仅支持单线程爬虫
     next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
     # page 参数为断续笔记,第一个参数是否启用笔记,第二个参数选填默认page.txt,仅支持单线程爬虫
     page=[True,"now_url.txt"],
     # clean 参数为是否进行数据清洗,防止大量爬虫收集无用信息
: r" |# ]9 p% C; S, L     #clean=True,
* k- W. s- h6 B7 d     # texting 参数为是否选择连续爬虫,避免爬虫过程中出现非代码问题报错结束爬虫程序
     texting=True,
     # Thread_num 为多线程数,默认为1单线程,支持多线程状态和异步状态
+ n% |3 {) D. E; q6 O: \     Thread_num=3,
     # cpu_count 为多进程数,默认为1单进程,支持多进程状态和联合状态
     cpu_count=1,
     # sem 为异步控制数,默认为5同时启动,支持异步状态和联合状态
1 }: u+ O( S9 k: {( G0 H% |     sem=5,
7 f( d+ [# o) g6 E- w0 e     # write_SQL 为是否写入数据库,默认否
     # host 参数默认localhost
2 b4 J4 A3 V) P9 i) r3 P7 t  `     # post 参数默认3306
1 E) x) L8 l; v% E# |" ^" s     # user 参数默认root
     # password 参数必填,必须正确
     # db 参数为即将存入的数据库名,若不存在自动创建
) v' ]: \! `5 J& ~* q     # table 参数为即将存入的数据表名,若不存在自动创建
0 a$ t$ n' @% t- ?7 v     write_SQL={
" O7 R3 b+ F! p+ p2 H$ L2 Y7 M         'host':'localhost',
         'post':'3306',
         'user':'root',
3 W% R; h6 I6 }- t- t  _         'password':'123456',
         'db':'example',
         'table':'example'
( K" |9 Z$ M5 V      }
).run()
; S1 f  Z7 Z& S) ?0 {
+ |2 F6 G6 T9 _* u8 \介绍一下crawl参数设置：
0 Y$ M* r, Q% O$ @8 ?1 v
'''
" q# e" E+ R, {9 @单行代码爬虫程序执行
0 m/ r5 O. k. J2 Z9 ?' L+ y5 X:param status:启用爬虫类型,支持普通爬虫、多进程爬虫、多线程爬虫、异步爬虫、异步多进程爬虫,参数请参考文档
:param url:即将请求的url地址,仅支持get请求
:param type_url:请求url后返回格式,支持text和json格式返回
:param Thread_num:即将启动多线程个数,默认为1单线程
1 C8 G; W4 b; [7 h% B:param sem:协程信号量,控制协程数,防止爬的过快,默认为5
:param cpu_count:运行爬虫使用多进程cpu核数,默认为系统核数一半
8 K" _6 t- q- w1 y% w% O:param login:模拟网站登陆,保存登陆信息
) m* i, ^2 ^" U0 Z8 c2 d& H:param Parsing:爬虫方式,支持re、xpath以及bs4方法
:param texting:是否启用连续爬虫,爬虫程序异常报错后重新启动爬虫,
                       多次报错结束程序,默认否
:param label:选择器内容,字典格式保存,
                     字典值为列表格式,第一个参数为选择器,第二个参数为转换类型
3 T  Q' O' D/ j# j" Q$ ]                     第一个参数必填,第二个参数默认str类型
; N/ o, b( g; o8 a5 E# k:param write:是否写入文件,支持txt格式、csv格式、json格式以及pkl格式,默认否
:param next_url:是否跨页爬虫,选择器内容使爬虫继续翻页爬虫
:param page:是否选择断续笔记接手下次爬虫处理,默认否
:param clean:是否进行简单类型数据清洗,默认否
' _& y$ \" j. B; W2 e; W* [. N5 I8 \:param write_sql:是否写入数据库,默认否
                         'host'默认为'localhost','post'默认'3306','user'默认'root',
                         'password':'密码','db':'数据库','table':'数据表',
; O: V. P2 {3 z2 C. a                         检测库是否存在,若不存在则创建,若存在则直接插入,
                         检测表是否存在,若不存在则创建,若存在则直接插入
( n3 `% n2 j$ w6 d8 i4 ?7 A- G- a:return True
'''
5 c# @7 V4 h' p9 M& n" r% P- F# ]介绍玩法
0 @3 H1 n) d( d# u$ x6 o  ^. x接下来介绍的均为调用第三方库的情况下运行：
1 N" |7 k, i! U, q) ~  J
from simple_crawl import request
+ C6 i4 P( m: ]' ~0 s第一种玩法：输出源代码
调用requests库进行源代码请求。
) S& ?1 |1 c" S% o  [
特点：
/ r, K$ T2 Y0 i6 w$ I% P& E请求失败则调用ip池处理重新请求访问，
8 M0 I: D# M7 ^! S出现五次失败默认网址输入错误。
支持text以及json字符串返回。默认text。

缺点：
暂时只能进行get请求，不支持post访问
  t, `3 o9 u9 \% `- [) ^
) O$ _4 N7 w9 B. s1 [0 v  n：return text or json
4 a' j0 u$ a, x9 r5 ]
9 c2 }; @, q+ S+ S% C& Drequest.parse(
        url = "https://www.douban.com/group/explore",
        type_url = "text"
).run()
# return text

; }3 C, s- H% G/ S) D# a2 }7 [第二种玩法：模拟网站登陆并保存信息
- _- J# J) N6 k调用DecryptLogin库请求登陆访问。

& r( @9 Q/ H8 ^& p( Dps：DecryptLogin库为大佬皮卡丘写的一个很不错的模拟网站登陆库，在此引用一下，因为单行爬虫原因不支持账号密码登陆，我将大佬写的二维码登陆使用过来了。再次感谢大佬开源
在此放出文档地址
DecryptLogin库中文文档：https://httpsgithubcomcharlespikachudecryptlogin.readthedocs.io/zh/latest/

特点：
* J$ q6 i2 ~& D将DecryptLogin库中二维码继承到此库（非二次开发）
8 H6 ^' B$ B$ W" u2 M支持QQ群、QQ空间、QQ安全中心、淘宝、京东和斗鱼登陆（大佬登陆库中所有的二维码登陆）
4 u& B4 B5 W  T$ e" x; ?$ N保存session.pkl信息到本地方便下次登陆运行

缺点：
session.pkl登陆信息过时无法自动删除。
6 {6 e8 \# Q- D导致下次登陆疑似cookie无法正常登陆。

2 X6 }: u) W" w5 B3 \5 @" M:return session
+ @! V$ `8 Y  C6 A8 i) z
request.parse(
        # 臭不要脸的推广一下我的店铺
        url="https://shop574805287.taobao.com/",
" D+ p% x8 N0 O7 z  R        login="taobao"
" {( @. ?6 U2 R; Z* a- g7 w).run()
/ N- {$ e7 ?: e2 l3 L+ _- k# return text

) Z2 B( ~( P" Y9 u8 D9 u. E第三种玩法：爬取网站信息
爬虫库自然少不了爬虫的过程

特点：
支持re库，xpath解析以及bs4选择器。
爬取方法为字典格式。单方面输出。
- z- q' c& k) _/ w$ S/ p' B! T字典键为保存的字段名称。
" M! p4 ^+ [5 `, e/ I( h, T# ?. m8 B字典值为列表格式：第一个参数为选择器，第二个参数为转换类型。第一个参数必填，第二个参数默认str类型。
: ]% S% n. S3 K2 I
( V9 N; Z$ c7 t# d0 b% f4 Q缺点：暂无（等待小伙伴们发现）

：return reptile_results

request.parse(
        url='https://www.douban.com/group/explore',
& O- q" p4 s0 ]3 N& w" n        # 字符串格式,选择器方法。
  A7 U7 p6 j' T2 t    Parsing = 'xpath',
  z" W) S# x# U9 W5 g# I4 e3 Z+ b( P/ P    # 字典格式,参数如上。
    label = {
( C  z% e4 f( \! Z" |        'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
$ X1 f- U5 B; \+ V: [; F# c) C) U5 O        'name':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/text()',str],
5 V$ X  L, O; z% I& C- W9 r        'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
        }
).run()
# return reptile_results（list）
! w; P. v* i8 ^# L) F; b; Q
. f: b, y$ K) X& ^- g第四种玩法：自由保存信息
6 S- H) u+ N6 o目前版本支持保存txt、csv、json以及pkl四大主流文件。日后版本更新将发布更为全面的保存方法。

/ A$ u1 D5 D( n2 z- C2 B特点：
写入文件均为数据格式传入文件。
  k; Y$ D) J6 S且输入格式规范方便阅读and省事。

缺点：
保存格式仅四种，
不方便用户之后读写操作。
1 `6 {& |0 @6 j. T, K
：return file

& Q% s) G& ?$ qrequest.parse(
        url='https://www.douban.com/group/explore',
$ a; \; a" \! z+ [/ G    Parsing = 'xpath',
    label = {
' A/ k& h0 [! C  I- }5 I        'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
( w( |) c+ S9 r        '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]
  u# F) U+ E  M, b7 F" Y! p7 T        },
8 i% _3 e* E4 E9 a    # 字符串格式,具体保存位置填写
$ |7 E. Y3 v3 T  K# X3 d    write='result.pkl'
).run()
" Z$ y0 o4 `3 y1 n% O" [- [# return file
: |  J' x) D/ s
第五种玩法：读取下一页 url 地址继续爬虫
这也是每个人都担心的问题，仅仅一行代码怎么可能翻页爬虫。这还真能做到哦~

  p* I7 x- f/ \特点：
$ [8 k5 G: _9 O6 H, g1 p' b$ O继承之前的Parsing参数选择器选择方法。
在这里可读取到解析后的下一页 url 网址。
, o) p% G' T- e方可继续进行爬虫处理。方便用户使用。
. f1 O2 y! {4 b: U' Q/ D% |4 t3 o
缺点：
若爬虫时下一页 url 地址改变，便结束爬虫。
只能爬取所给 url 地址中的信息。
8 c! F  o' s) j8 |无法进行某一界面的多个网页爬取返回。
/ D, x+ R& m% z1 N$ Z& A造成访问页面单一流失。

：return None

request.parse(
4 n+ a* w5 k: |$ R, H        url='https://www.douban.com/group/explore',
    Parsing = 'xpath',
    label = {
( r5 x7 k# G, [- K, 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],
! Z. q( Z9 s# w) F9 W5 e# L        'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
        },
% d$ Y6 V( T# |. N    write='result.pkl',
    # 字符串格式,根据Parsing方法继续请求下一页a中href
    next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
).run()
# return None
0 [+ x8 ]  @9 P2 j6 z7 o
第六种玩法：爬虫网页保存
) t7 j# N# M- Z% P听说过爬虫断续重连的朋友应该懂得这是个什么神仙操作。每次爬虫运行期间好好的，睡一觉醒来发现代码报错了。。。这就是个很难受的事，还不知道之前爬取到哪一页了，只能重新爬虫了啊！

8 y& P- U0 _( q( R6 J特点：
持续输出断续笔记。
4 [% e2 i) k1 Q# Y4 m- y  N) U# W" z8 I将此次爬虫的 url 地址保存到一个文本文档内部。
# A6 |+ l( m4 Z  w- t下次读取文本文档即可快速进行直接断掉的爬虫 url 地址继续爬取所需。
7 C# a& c5 t3 `# ~; s; h
* @. ~2 r; K1 g0 b- F& {+ w缺点：
/ e0 z0 ~) r1 `7 Y7 i* U) u读取内容不单一。
导致下次爬虫无法正确读取上次爬虫留下的痕迹。

：return url_file

9 \6 H# y6 ~% Z/ m0 j$ E" yrequest.parse(
: M1 [0 V: t5 H; [0 Z    url='https://www.douban.com/group/explore',
    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],
2 s. |+ m9 S  G" P. P, L  |, `/ ]        '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',
$ \9 ?' n$ m3 B. b    # 第一个参数为是否需要断续笔记。
! r& J7 O; X3 e) s5 N% }0 X" s0 l    # 第二个参数为断续笔记保存位置。
    page=[True,'url_page.txt']
! e7 L$ K' G9 R' C; c).run()
5 H, u. Y! I7 N; |# return url_file

第七种玩法：简单数据清洗
5 C) V9 _! t0 J7 r0 q( k2 y数据拿下后，直接保存到本地有些大佬可能觉得很辣鸡，连清洗都不清洗就存入本地了？那得拿到多少废数据脏数据。那么接下来介绍一下清洗参数。

特点：
, t- _8 F" [7 `; v" t4 G本人曾写过一个底层数据清洗。
能将列表格式数据进行归分清洗。
主要内容请参考另一篇文章
如下连接：数据清洗

) @# t+ I" L& z+ Q; f2 y缺点：
数据清洗格式简单。
数据清洗内容单一。
无法完全做到绝对清洗。
有待改善。
  j1 L/ T9 v1 H' P1 g% N+ g# `
：return keyword_list, value_list

0 i/ S; X; o" s& Orequest.parse(
    url='https://www.douban.com/group/explore',
& _# k4 i: F9 Y; z. @$ ]    Parsing = 'xpath',
: a: B2 v* n- V: Y3 r    label = {
4 J3 g, G2 O1 E& R        'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
' A8 D# Q8 r& h6 L+ c        '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 i' f6 q" y1 x0 g4 i        },
( l6 d; ~1 d: Z0 a1 z9 `3 K    write='result.pkl',
    next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
5 c: |& B7 T# h) b    page=[True,'url_page.txt'],
+ J- V' g2 x6 ?3 ^8 H; s) L    # bool类型,默认不清洗
+ D, q9 r( G3 C& V    clean=True
).run()
5 K7 J2 M. ~) L' t- X+ N
7 N( n( _3 u% x4 U5 b* r第八种玩法：爬虫存入数据库
1 m0 k3 t! t7 _/ e* M4 t存到txt、存到csv、存到json、存到pkl，那也太low了吧。现在流行的数据库用不了么？那是不可能的。。

9 f" e! C9 {0 K; {: t* i+ v  _特点：
; ^6 j, i5 A. ?( y0 _4 t信息存入MySQL数据库。
" [& K; |0 |3 W* @可连接docker远程数据库。
( q0 t$ y' x3 t* h9 Q! X数据库的库名可以不存在。
数据库的表名可以不存在。
' F  v" I! E* T0 K) z9 g根据之前传入字典键与值参数判断表类型。
自由建立数据表传入信息。

缺点：
+ h4 u8 H: Q- R+ p2 b4 f仅支持MySQL数据库。
, U6 `/ {; S4 p6 w, ]
$ v& J8 Y+ x1 @7 z: D; x- [; s：return SQL
# }$ t8 t1 u; \) k- {% X$ |
request.parse(
    url='https://www.douban.com/group/explore',
    Parsing = 'xpath',
    label = {
9 ~, I* [; S: p, V( m( n        'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
# c0 @2 e9 T4 c! M        '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]
        },
. ?$ s5 W# [& I  q  Y    write='result.pkl',
    next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
    page=[True,'url_page.txt'],
    clean=True,
    # 字典格式,
3 u/ K" C5 E% D6 q4 x/ Y    # host可有可无,默认localhost
    # post可有可无,默认3306
    # user可有可无,默认root
$ ]8 Z1 [4 T  t( I    # password必要参数,数据库连接密码
: G9 v6 m# q7 j; Z    # db必要参数,数据库即将存入的库名
    # table必要参数,数据库即将存入的表名
    write_SQL={
" N# i- _4 V4 K. n9 ~! S  M        'host':'localhost',
- I/ {* C) u. @! l* D& D; Y; [4 M        'post':'3306',
% T# F% ]. K, Y4 }5 r" `        'user':'root',
        'password':'123456',
: E- g0 W: p3 ^% @5 @6 Z# C        'db':'example',
$ q+ `, l5 Q1 H+ N5 B7 y        'table':'example'
        }
    ).run()
- \4 ?. X# A" E0 i* v
第九种玩法：重新启动爬虫
' J0 w) s! `7 f爬虫最让人厌烦的就是被一个不痛不痒的错误信息给终止爬虫了，比如意外的远程断开链接等低级非代码错误，报错之后还得重新启动断续爬虫，就显得很麻烦。我做了一期爬虫程序异常报错后重新启动爬虫，多次报错结束程序。

' Q8 `9 v+ E; R; v特点：
2 f! r+ F$ i! e! {+ B2 p/ x检测报错重新启动爬虫
无需手动处理错误信息
* u8 t. n: F# u6 E: Q  Q
# B: Y, p! |- p缺点：
无法收集子线程错误。

：return None
5 a; D' ?+ q+ P- A) y( u" A- V
request.parse(
, M( M* J2 a+ L        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
        #login="taobao",
/ m  I! b9 Z7 R* [' Y        type_url = "text",
1 Y  V& Z5 h3 t5 _6 v        Parsing = 'xpath',
# r0 K0 {. G, ]# U! p        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],
( Q, F' }" N7 N5 o/ E+ r3 y. }            '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"],
$ _( v& {4 P9 q) t  Z        # texting 参数为是否启用连续爬虫
6 [- \3 G4 b; w        # 爬虫程序异常报错后重新启动爬虫
+ A' ?" q: |* @' m! g; ^        texting=True,
  ]5 q% k2 |, n, o4 w/ {        ###
        write_SQL={
            'host':'localhost',
            'post':'3306',
9 g& F( A5 V9 ]' |            'user':'root',
            'password':'123456',
' X+ p; f4 ^7 h. J9 F8 N            'db':'example',
            'table':'example'
& l. I2 f; p, c3 T9 Y            }
).run()

' ]- P) Z" O5 m9 T- N, F+ m第十种玩法：多线程爬虫
& E/ O( W. S2 q! {特点：
爬虫速度加快，
更好的利用了线程。
$ r- _* }4 E& F# @- O. L; [# D
缺点：暂无

6 \/ i; C% W2 A+ g% v* }& M( ~9 y：return None

request.parse(
/ ~" P9 y' e/ Y" J        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
7 l5 E. a& y$ _4 {, Q5 a        #login="taobao",
* c& S9 p# j, Q) T: k        type_url = "text",
        Parsing = 'xpath',
7 R1 @2 i) w+ i* Z! _        label = {
% Q* ~# r8 ~9 B! I' ~* P" u6 K            '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 M* ~) w+ B& O3 y% q3 \" x            },
% t7 w( n; o  z" U7 s  G4 X3 [* X        write='result.txt',
        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
        page=[True,"now_url.txt"],
        #clean=True,
5 |8 ]/ ?# ^3 X) c; B        texting=True,
, k# Z" V" O9 ]7 T3 c' f$ [        # status="threads" 启用多线程爬虫
        # Thread_num 为线程数目,默认为1 单线程
        status="threads",
- o8 q. {3 I0 @7 R$ Y4 \        Thread_num=3,
1 o3 D$ R) g& r. i- @/ Y1 T        ###
2 g% @$ G) \$ D8 ^$ @        write_SQL={
3 C/ {  y: T8 |% c. R            'host':'localhost',
            'post':'3306',
            'user':'root',
& M+ I' Z2 j1 U8 M. o. W( g            'password':'123456',
            'db':'example',
            'table':'example'
            }
).run()
( @& l! ]: T( d+ K1 l
第十一种玩法：多进程爬虫
: h  c+ W6 [: B1 g9 d特点：
爬虫速度加快，
. W% X- @3 w( O1 N4 s更好的利用了进程。
( P+ z! t0 C) f6 g! f
" q* q8 m, r2 ~4 m9 U& {缺点：暂无
4 E* a. c3 H( y/ T6 i' L" P4 Y; q
5 i' T* V# S* ^% v：return None

from simple_crawl import request
request.parse(
9 N& ~0 g" ]2 b        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
        #login="taobao",
! i( m$ D' ^% [+ v' l+ h8 u2 I        type_url = "text",
- P# w* y9 u$ M3 _- {        Parsing = 'xpath',
        label = {
            'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
# J2 x% u8 P& B# s7 D1 I            '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',
8 o5 ]# f, y3 |        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
/ H9 X# P& S& `( ~0 y        page=[True,"now_url.txt"],
* ~( x+ s; |; _) w        #clean=True,
2 V8 B) I0 W. h7 S$ H4 T) `! W5 p        texting=True,
- F# r+ H, D0 j9 |! [        # status="multiprocessing" 启用多进程爬虫
' J# H' J/ i( }' D" r7 ~, ~9 A        # cpu_count 为启动代码核心数,默认为系统核数一半
# O1 ?  P* G0 I+ j8 W        status="multiprocessing",
        cpu_count=2,
$ `. ~. s! T* T9 s        ###
& |3 H( P* {; S! }        write_SQL={
& s  J) r0 Z/ v) \            'host':'localhost',
( e6 I! k& o' _% t3 P            'post':'3306',
            'user':'root',
            'password':'123456',
            'db':'example',
            'table':'example'
            }
).run()
" W& a5 M. m& s6 K
第十二种玩法：异步多线程爬虫
特点：
爬虫速度加快，
异步使得爬虫无等待时间，
同时使用多线程速度明显加快。

8 s/ e- Y4 k7 |6 Y缺点：暂无
4 t# E. G! u" k' y9 B+ k
：return None

from simple_crawl import request
1 w: f% G/ R+ t5 i' Y) Xrequest.parse(
  j" l  M1 q9 ?: h        url=['https://www.douban.com/group/explore?start={}'.format(i) for i in range(0,180,30)],
$ y" G$ V, O4 C9 u% B4 |        #login="taobao",
        type_url = "text",
        Parsing = 'xpath',
+ k& q/ j# e8 o5 s$ ^  w        label = {
            'url':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/@href',str],
+ X3 e+ i' y$ F. ]            'name':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/h3/a/text()',str],
4 [, ], o* ~! n0 C8 d# M' Z            'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
            },
        write='result.txt',
/ E. |1 J( d4 }/ A8 |( Z* R9 n        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
        page=[True,"now_url.txt"],
* m  |# P# ^- ?4 c0 g        #clean=True,
3 V# J  c1 B& K+ I4 s        texting=True,
        # sem 参数为异步引擎数目,默认为5
! v4 A+ F4 H; p% R: g* p6 [        # 其他参数同上
$ w, o$ j& ^) y: k" i+ N        status="aiohttp",
        Thread_num=3,
        sem=5,
3 U" g7 g- V& H1 t7 L        ###
        write_SQL={
4 o# b! B6 ^( [/ ^  n% d            'host':'localhost',
2 P8 ^1 m3 G* c) M! V+ E" J& B            'post':'3306',
            'user':'root',
6 l3 M5 h) S9 g/ p7 g4 Z6 ~4 ^            'password':'123456',
, D# R2 z+ P. [: D5 c            'db':'example',
            'table':'example'
% H# e' x% d( k( ~1 u' @/ I$ M            }
0 x# Y+ M; A: H  g! t5 \- K; ^$ J).run()

第十三种玩法：异步多进程爬虫
5 q, Z: q, U1 k! i# R1 w特点：
- p: ^( x+ B' X2 |) @爬虫速度加快，
9 k, s) C% u' |6 \- ^4 k异步使得爬虫无等待时间，
! L: x+ d: G+ t' _/ X8 E' x同时使用多进程速度明显加快。

+ ]: U/ F$ ^2 X. v* v7 U' y缺点：暂无
+ _. u$ O  h/ r8 Y6 q# {
. O6 h  k0 M% F4 s4 p. t# I：return None

1 E# G- ]* K8 _/ ~* I; |% \from simple_crawl import request
1 z& c' B- y3 `5 nrequest.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',
. a% ^+ y8 H3 F, J* P/ z: R! O        label = {
4 U, ], |2 ^$ J. 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],
            'Author':['//*[@id="content"]/div/div[1]/div[1]/div[1]/div[2]/div[2]/span[1]/a/text()',str]
* D& J& }7 ?# l: R            },
        write='result.txt',
        next_url='//*[@id="content"]/div/div[1]/div[2]/span[4]/a/@href',
* n3 C3 b7 Z5 E! l        page=[True,"now_url.txt"],
( g/ a5 b5 d( Z# u; ?# p        #clean=True,
        texting=True,
        # 参数如上
        status="between",
' x/ Q! c9 G% Z# _5 Q        cpu_count=1,
        sem=5,
) b8 D+ P# W8 V2 b8 J, D$ o        ###
0 V, z# ^, }( P* v        write_SQL={
            'host':'localhost',
            'post':'3306',
            'user':'root',
0 ]( N4 H- G# U7 v" _0 x( m            'password':'123456',
            'db':'example',
( \# K1 C" i% _* H6 i' ?  p            'table':'example'
            }
8 f% G/ d3 t6 i- \( N( z; x: v).run()

) t* J3 F5 F$ p/ ]. a" |: L6 W
功能介绍完毕🤞
/ C2 G3 Q& T, P7 R4 e& f; M最后还是希望你们能给我点一波小小的关注。
奉上自己诚挚的爱心💖
————————————————
. i; g4 Q2 O- ~( p/ I版权声明：本文为CSDN博主「꧁༺北海以北的等待༻꧂」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
  K3 A- x5 X# x* G原文链接：https://blog.csdn.net/qq_45414559/article/details/106005684


  U  g# i7 o% B* N8 t/ w4 C# M

738391227

66666666666666666666666666666