精通Python网络爬虫

<<精通python网络爬虫>>精简了书籍内容，必要的代码都放到备注上面了。代码经过我的测试，都可以运行，达到相同的效果。如果有不明白或者有错误要指出

• 理论基础篇
  • 什么是网络爬虫
    • 初识网络爬虫
      • 自动化浏览网页中信息的程序
    • 为什么要学网络爬虫
      • 私人订制搜索引擎,深入了解搜索引擎
      • 大数据时代的数据分析
      • 对seo从业者来说,可以了解原理,更好优化
      • 解决就业
    • 网络爬虫的组成
      • 控制节点
        • 爬虫的中央控制器
      • 爬虫节点
        • 根据一定的算法浏览网页内容
      • 资源库
        • 爬取到的结果存储到资源库
    • 网络爬虫的类型
      • 通用网络爬虫
        • 全网爬取,爬取的数据是海量
      • 聚焦网络爬虫
        • 主题爬取,有选择的爬取
      • 增量式爬虫
        • 更新的时候只改变更新的地方
      • 深层网络爬虫
        • 网页分为表层和深层,不需要提交表单的静态页面就是表层,而需要提交表单的就是深层
    • 爬虫扩展——聚焦爬虫
      • 组成
        • 初始url集合
        • url队列
        • 页面爬行模块
        • 页面分析模块
        • 页面数据库
        • 连接过滤模块
        • 内容评价模块
        • 链接评价模块
      • 图解
  • 网络爬虫技能总览
    • 网络爬虫技能总览图
    • 搜索引擎核心工作流程
      • 图解
      • 过程
        • 爬虫
          • 通过控制器存储到原始数据库
        • 索引器
          • 建立索引,将原始数据库的内容存储到索引数据库
        • 用户
          • 通过用户交互接口查询信息,检索器从索引数据库取得想要结果
          • 同时用户的行为,信息会存储到用户日志数据库中
        • 日志分析器
          • 分析用户日志数据库,通过得到的结果,调整原始数据库以及索引数据库的排名结果,以及其他
    • 用户爬虫的那些事儿
      • 用户爬虫爬取的是用户的信息
      • 知乎注册用户,qq使用用户,淘宝信息爬取等等
• 核心技术篇
  • 网络爬虫实现原理与实现技术
    • 网络爬虫实现原理详解
      • 通用爬虫
      • 聚焦爬虫
    • 爬行策略
      • 深度与广度
        • 网站层次示意图
        • 深度优先爬取策略
          • ade-&gt;b-&gt;fg
        • 广度优先爬取策略
          • abc-&gt;de-&gt;fg
      • 大站优先爬取策略
        • 对网页归类,网站多的归类到大站,先爬取这种站点
      • 反链爬取策略
        • 反向链接多的网站优先爬取,但是这种有可能出现作弊,所以要反向链接数可靠,才采取这种策略
      • 其他策略
        • opic策略
        • PartialPageRank策略
    • 了解
      • 网页更新策略
        • 用户体验策略
        • 历史数据策略
        • 聚焦分析策略
      • 网页分析算法
        • 基于用户行为的
        • 基于网络拓扑的
        • 基于页面内容的
    • 身份识别
      • 告诉站长自己的身份,user-agent
    • 网络爬虫实现技术
      • python,java,php,go,c++等等
    • 实例——metaseeker
      • metaseeker是一款网页采集程序,了解即可
  • Urllib库与URLError异常处理
    • 什么是Urllib库
      • 操作网页的模块
        • python2.x里有urllib,也有urlib2,python3.x版本将两者合并了
    • 快速使用Urllib爬取网页
      • urlopen访问百度并保存为html页面
        • ``` import urllib.request #导入相应的模块 file=urllib.request.urlopen("http://www.baidu.com") #访问百度页面 data=file.read() #读取返回的全部 dataline=file.readline()#读取返回的一行 print(dataline) #打印这一行 fhandle=open("urllib_urlopen.html","wb") #打开一个文件 fhandle.write(data) #将百度的源码传递进去 fhandle.close()#关闭文件 ```
      • urlretrieve直接访问网页并保存
        • ``` import urllib.request #urlretrieve方法可以直接将源码保存到文件中 urllib.request.urlretrieve("http://edu.51cto.com",filename="urllib_urlretrieve.html") #urlretrieve方法使用的时候会产生一些缓存,用urlcleanup即可清除缓存 urllib.request.urlcleanup() ```
      • 其他(取环境,状态码,取网址,编码网址)
        • ``` import urllib.request file=urllib.request.urlopen("http://www.baidu.com") #获取当前网页返回的状态码,用getcode statucode=str(file.getcode()) print("当前状态码是:"+statucode) #获取当前网页的网址,用geturl url=file.geturl() print("当前网址是:"+url) #对url进行url编码,用quote urlbefore="http://www.test.com" urlafter=urllib.request.quote(urlbefore) print("之前的网址是:"+urlbefore+"经过编码之后的网址是:"+urlafter) #获取当前网页的环境信息,用info() info=str(file.info()) print("当前的环境是:\n"+info) #解码成utf8 data=file.read().decode("UTF-8") ```
    • 浏览器的模拟——Headers属性
      • 使用build_opener修改报头
        • ``` import urllib.request url="https://blog.csdn.net/blogdevteam/article/details/80819627" headers=("User-Agent","Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.87 Safari/537.36") #创建一个打开对象 opener=urllib.request.build_opener() #增加报头 opener.addheaders=[headers] #用打开对象打开网址,并获取内容 data=opener.open(url).read() #以二进制写的模式打开文件 fhandle=open("urllib_opener.html","wb") #将数据写入文件 fhandle.write(data) #关闭文件 fhandle.close() ```
      • 创建Request对象,用add_header方法
        • ``` import urllib.request url="https://blog.csdn.net/blogdevteam/article/details/80819627" headers=("User-Agent","Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.87 Safari/537.36") #创建已给Request对象,对这个对象进行数据设置,然后将其传递进urlopen方法中 req=urllib.request.Request(url) req.add_header("User-Agent","Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.87 Safari/537.36") #访问网页,并获取数据 data=urllib.request.urlopen(req).read() #以二进制写的模式打开文件 fhandle=open("urllib_Request.html","wb") #将数据写入文件 fhandle.write(data) #关闭文件 fhandle.close() ```
    • 超时设置
      • 有时候访问网页,如果超过一定时间,那么我们可以判定这个网页超时了
        • ``` import urllib.request url="http://www.baidu.com" #将timeout设置成0.1秒,这个对一个网也来说是会很快的,所以会看到结果是网页异常,这个时间可以设置大一点 try: urllib.request.urlopen(url,timeout=0.1) except Exception as e: print("网页异常") ```
    • HTTP协议请求实战
      • get-实现百度查询
        • ``` import urllib.request #这个是关键词,可以随意输入 keywd="百度百科" #如果关键词是中文的,要进行编码转换 url_keywd=urllib.request.quote(keywd) url="http://www.baidu.com/s?wd="+url_keywd req=urllib.request.Request(url) data=urllib.request.urlopen(req).read() #将内容写入html fhandle=open("urllib_get.html","wb") fhandle.write(data) fhandle.close() ```
      • post-表单提交
        • ``` import urllib.request import urllib.parse url="http://www.iqianyue.com/mypost" #要用字典构造表单,这个是原始表单 postdata_a={ "name":"[e-mail]", "pass":"aA123456" } #要传递表单,还需要对数据进行转码,转码成utf8的url编码 postdata_b=urllib.parse.urlencode(postdata_a).encode("utf-8") #创建一个Request对象 req=urllib.request.Request(url,postdata_b) #增加浏览器报文 req.add_header("User-Agent","Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.87 Safari/537.36") #提交表单 data=urllib.request.urlopen(req).read() #将内容写入html fhandle=open("urllib_post.html","wb") fhandle.write(data) fhandle.close() ```
    • 代理服务器的设置
      • 代理ip访问百度
        • ``` import urllib.request def use_proxy(proxy_addr,url): #设置代理地址信息 proxy=urllib.request.ProxyHandler({'http':proxy_addr}) #创建一个opener对象,第一个参数是代理信息,第二个是http处理器,Handler,这个是用来处理http请求的 #还有httpshandler,处理https请求的 opener=urllib.request.build_opener(proxy,urllib.request.HTTPHandler) #安装全局默认的opener对象,这个全局安装之后,之后的urlopen,都会调用这个对象,不用opener.open这种格式 urllib.request.install_opener(opener) data=urllib.request.urlopen(url).read().decode("utf-8") return data #代理的地址,ip:端口号,如果代理ip不可用,会报错 proxy_addr="139.208.194.45:8118" data=use_proxy(proxy_addr,"http://www.baidu.com") #打印data内容长度 print(len(data)) ```
      • 代理地址
        • <a href="http://www.xicidaili.com/" target="blank">西刺代理</a>
    • DebugLog实战
      • 边运行边打印调试日志(51cto首页)
        • 为什么要这么做,书里只描述了一个步骤 ``` import urllib.request httphd=urllib.request.HTTPHandler(debuglevel=1) httpshd=urllib.request.HTTPSHandler(debuglevel=1) opener=urllib.request.build_opener(httphd,httpshd) urllib.request.install_opener(opener) data=urllib.request.urlopen("http://edu.51cto.com") ```
    • 异常处理神器——URLError实战
      • URlError
        • 因为书中说csdn是禁止爬取的,实际上是可以爬取的并不会报错,所以这里找了一篇文章,网址后面加了一个数字,这样就会看到错误 ``` import urllib.request import urllib.error try: urllib.request.urlopen("https://blog.csdn.net/wys7250578/article/details/450221610") except urllib.error.URLError as e: print(e.reason) ```
        • 产生错误的可能
          • 连接不上服务器
          • 连接不到特定的服务器
          • 无网络
          • 触发了HTTPError
      • HTTPError
        • 这是URLError的子类,它有一个code属性,这个就是请求返回的状态码
        • 如果出现的不是HTTPError的情况,URLError就会没有code属性,会报错,可以断网看效果
        • 两个异常都处理
          • ``` import urllib.request import urllib.error try: urllib.request.urlopen("https://blog.csdn.net/wys7250578/article/details/450221610") except urllib.error.HTTPError as e: print(e.code) print(e.reason) except urllib.error.URLError as e: print(e.reason) ```
  • 正则表达式与Cookie的使用
    • 正则基础(看书)
      • 什么是正则表达式
      • 正则表达式基础知识
    • 正则表达式常见函数
      • python使用re模块来操作正则
      • 只返回一个结果
        • match
          • match必须从起始位置就匹配,不然会返回None ``` import re string="dpythonasdfsdf" pattern=".python." result=re.match(pattern,string) #打印匹配信息 print(result) #打印匹配位置 print(result.span()) #打印匹配结果 print(result.group()) ```
        • search
          • search与match不同,它全文检索,而不是从起始位置 ``` import re string="asdfsadfsadpythonasdfsdf" pattern=".python." result=re.match(pattern,string) result2=re.search(pattern,string) print("使用match的结果:"+str(result)) print("使用search的结果:"+str(result2)) print("匹配到的结果是"+str(result2.group())) ```
      • 多个结果
        • findall
          • match和search.只会返回一个结果,有时候我们需要的不只是一个结果,因此,需要用findall,它会返回一个列表 ``` import re string="aasfsa1python1safdsadf2python2asdfsadf3python3" pattern=".python." #先生成一个预编译对象 reg=re.compile(pattern) result=reg.findall(string) print(result) ```
      • 替换
        • sub
          • 有时候需要替换文本中的字符,要用到sub ``` import re string="你好吗,,asdf,,你好吗,,asdfsaf,你好吗,," pattern="你好吗." #全部替换 result=re.sub(pattern,"呵呵",string) #只替换两次 result2=re.sub(pattern,"呵呵",string,2) print(result) print(result2) ```
    • 常见实例解析
      • 匹配.com,.cn后缀的网址
        • ``` import re pattern="[a-zA-Z]+://[^\s]*[.com|.cn]" string="<a href='http://www.baidu.com'>百度一下</a>" result=re.search(pattern,string) print(result) ```
      • 匹配电话
        • ``` import re pattern="\d{4}-\d{7}" string="0731-8112121" result=re.search(pattern,string) print(result) ```
    • 什么是Cookie
      • cookie是客户端保存的会话信息,与之对应的session是服务端保存的会话信息
    • Cookiejar实战精析
      • ``` import urllib.request import urllib.parse import http.cookiejar url="http://dx31.wzdr.cn/member.php?mod=logging&action=login&loginsubmit=yes&infloat=yes&lssubmit=yes&inajax=1" #转换后表单数据 postdata_a="fastloginfield=username&username=wzdr1&password=wzdrwzdr&quickforward=yes&handlekey=ls" #把字符串转成字典 list1=postdata_a.split("&") list2={} for x in list1: name,value=x.split("=",2) print(name,value) list2[name]=value #转码字符串 postdata_b=urllib.parse.urlencode(list2).encode("gbk") #构建一个Request对象 req=urllib.request.Request(url,postdata_b) req.add_header("user-agent","Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.87 Safari/537.36") #创建一个cookiejar对象 cjar=http.cookiejar.CookieJar() #创建一个cookie处理器 chandler=urllib.request.HTTPCookieProcessor(cjar) #将处理器传进opener opener=urllib.request.build_opener(chandler) #安装全局opener urllib.request.install_opener(opener) #打开网页 file=opener.open(req) data=file.read() # #写到文件 file=open("urllib_cookejar1.html","wb") file.write(data) file.close() #登录后访问页面,看是否有个人信息 response=urllib.request.urlopen("http://dx31.wzdr.cn/forum.php") data=response.read() file=open("urllib_cookiejar2.html","wb") file.write(data) file.close() ```
  • 手写Python爬虫
    • 图片爬虫实战
      • 使用时,在文件目录下建立一个文件夹image ``` import re import urllib.request def craw(url,page): html1=urllib.request.urlopen(url).read() html1=html1.decode("utf-8") #过滤掉侧边栏的信息,只取主要信息 pat1='<div id="plist" class="[\s\S]*?<div class="page clearfix">' result1=re.compile(pat1).findall(html1) request1=result1[0] #取图片网址,因为主要信息中,有六十张图片,前面十张和后面十张是不同的格式,所以用两个正则取 pat2='<img width="220" height="220" data-img="1" src="(.*?)">' pat3='<img width="220" height="220" data-img="1" data-lazy-img="(.*?)">' imagelist1=re.compile(pat2).findall(request1) imagelist2=re.compile(pat3).findall(request1) #拼接两个图片列表 imagelist3=imagelist1+imagelist2 x=1 for imageurl in imagelist3: imagename="image/"+str(page)+str(x)+".jpg" imageurl="http:"+imageurl print("正在爬取第"+str(i)+"张图片") try: urllib.request.urlretrieve(imageurl,filename=imagename) except urllib.error.URLError as e: if hasattr(e,"code"): x+=1 if hasattr(e,"reason"): x+=1 x+=1 #这里可以通过访问第一页获取range范围,为了不产生过多图片,范围定为1-2 for i in range (1,2): url="https://list.jd.com/list.html?cat=9987,653,655&page="+str(i) print(url) craw(url,i) ```
    • 链接爬虫实战
      • csdn是动态刷新的,而且每次打开都是不一样的,向下翻页会产生新的数据包,这里不翻页,只采集最开始的 ``` import re import urllib.request def getlink(url): #创建一个opener headers=("user-agent","Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.87 Safari/537.36") opener=urllib.request.build_opener() opener.addheaders=[headers] urllib.request.install_opener(opener) #安装全局opener file=urllib.request.urlopen(url) data=file.read().decode("utf-8") #取网址列表 pat='data-track-click=\'{"mod":".*?","con":",(.*?),.*?"}\'>\s*?([^\s]*?)\s*?</a>\s*?</h2>' link=re.compile(pat).findall(str(data)) #set可以去重复 link=list(set(link)) return link url="https://blog.csdn.net/" linklist=getlink(url) for link in linklist: url=link[0] title=link[1] #标题中有&mdash的进行替换 if(title.find("&mdash;")!=-1): title=title.replace("&mdash;","—") print("链接是%s\n标题是:%s"%(url,title)) print("\n") ```
    • 糗事百科爬虫实战
      • 因为糗事百科不仅仅是文字,还有图片,就连纯文字板块都有很多图片,因此换了一个网站.笑话集的原创笑话``http://www.jokeji.cn/yuanchuangxiaohua/list/default.htm`` ``` import re import os import urllib.request def getjoke(url): #创建一个opener headers=("user-agent","Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.87 Safari/537.36") opener=urllib.request.build_opener() opener.addheaders=[headers] #安装全局opener urllib.request.install_opener(opener) #取得笑话 response=urllib.request.urlopen(url) data=response.read().decode("gb18030") pat='<h2><a href=".*?" target="_blank">(.*?)</a></h2>[\s\S]*?<li>([\s\S]*?)<i>.*?</i></li>' jokes=re.compile(pat).findall(data) return jokes #创建一个笑话目录 if os.path.exists("jokes")!=True: os.mkdir("jokes") #一共有七千多页,这里只拿两页进行测试 for i in range(1,3): url="http://www.jokeji.cn/yuanchuangxiaohua/list/default"+str(i)+".htm" jokes=getjoke(url) txtname="jokes\\jokepage_"+str(i)+".txt" #打开文件,用追加模式 file=open(txtname,"a") jokenumber=1 for joke in jokes: joketitle=joke[0] jokecontent=joke[1] #替换换行,以及一些特殊字符 jokecontent=jokecontent.replace("<BR>","\n") jokecontent=jokecontent.replace("<br>","\n") jokecontent=jokecontent.replace("&nbsp;"," ") #每一页有十五个笑话,用一个txt保存一页的笑话,保存的格式是序号+题目+换行+内容+两个换行 file.write(str(jokenumber)+":"+joketitle+"\n"+jokecontent+"\n\n") #打印正在采集的数字 print("正在采集第"+str(i)+"页"+"第"+str(jokenumber)+"个笑话") jokenumber+=1 file.close() ```
    • 微信爬虫实战
      • 代码与书上有很大的不同,书上的是所有的文章和内容都存储到一个html里,而这段代码是每一个标题做一个文件名,文章写进html中 ``` import re import urllib.request import time import urllib.error import os def use_proxy(url,proxy_addr=""): try: if(proxy_addr!=""): proxy-urllib.request.ProxyHandler({'http':proxy_addr}) opener=urllib.request.build_opener(porxy,urllib.request.HTTPHandler) urllib.request.install_opener(opener) data=urllib.request.urlopen(url).read() return data except urllib.error.URLError as e: if hasattr(e,"code"): print(e.code) if hasattr(e,"reason"): print(e.reason) #发生了URLErro就延迟10秒 time.sleep(10) except Exception as e: print("exception:"+str(e)) #没有发生URLError就延迟1秒 time.sleep(1) def getlisturl(key,pagestart,pageend,proxy): page=pagestart keycode=urllib.request.quote(key) for page in range(pagestart,pageend+1): #进入搜狗微信搜索的具体页面 url="http://weixin.sogou.com/weixin?query="+keycode+"&type=2&page="+str(page) print("当前网址"+url) data1=use_proxy(url,proxy) #取出文章网址列表 listurlpat='<div class="txt-box">\s<h3>[\s\S]*?<a target="_blank" href="(.*?)"' #预编译的re.S代表的是把字符串看成一个整体,由此可以跨行匹配 #这个语句追加的是一个列表数据 listurl.append(re.compile(listurlpat,re.S).findall(data1.decode("utf-8"))) print("获取第"+str(page)+"页") return listurl def getcontent(listurl,proxy): for i in range(0,len(listurl)): for j in range(0,len(listurl[i])): #取的文章的网址 url=listurl[i][j] #把网址中的特殊字符替换 url=url.replace("amp;","") data=use_proxy(url,proxy) #取出标题 titlepat='var msg_title = "(.*?)";' title=re.compile(titlepat).findall(data.decode("utf-8")) #这里设置一个初始的标题值 thistitle="没有取到标题" if(title!=[]): #标题不为空,则写文章到html中 thistitle=title[0] htmlname="weixinarticle\\"+thistitle+".html" file=open(htmlname,"wb") file.write(data) file.close() print("正在处理第"+str(i+1)+"页--第"+str(j+1)+"篇--"+thistitle) #模拟浏览器 headers=("user-agent","Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.87 Safari/537.36") opener=urllib.request.build_opener() opener.addheaders=[headers] #安装全局opener urllib.request.install_opener(opener) #设置空网址列表 listurl=[] key="物联网" #代理地址,这里没设置,有需要的就设置,调用的子程序判断不为空才会启用代理 proxy="" pagestart=1 pageend=1 listurl=getlisturl(key,pagestart,pageend,proxy) #创建一个文章目录 if os.path.exists("weixinarticle")==False: os.mkdir("weixinarticle") getcontent(listurl,proxy) ```
    • 多线程爬虫
      • 什么是多线程
        • 程序的某一部分任务可以用多个线程来并行执行
      • 多线程爬虫实战
        • 简单例子
          • 与书上代码不一样的是,加了一个sleep,这样可以很直观的看出来,不是A执行完了才执行B,而是两个交替执行 ``` import threading import time class A(threading.Thread): def __init__(self): threading.Thread.__init__(self) #初始化该线程 def run(self): for i in range(10): print("我是线程A") time.sleep(1) class B(threading.Thread): def __init__(self): threading.Thread.__init__(self) def run(self): for i in range(10): print("我是线程B") time.sleep(1) #实例化线程A为t1,B2为t2 t1=A() t2=B() #启动线程t1 t1.start() t2.start() ```
        • 队列
          • 队列是一种数据结构,在多线程中可以起很好的作用 ``` import queue #创建一个队列 a=queue.Queue() #传递数据队列,这个过程非常像排队,排在前面的就先出来 a.put("网址1") a.put("网址2") a.put("网址3") a.put("网址4") #表示入队列任务完毕 a.task_done() #队列先进先出,所以永远是取第一个,像超市结账,结账一个就走一个,人就不在了.结账完了,整个队列就空了 #上面排了四个,循环四次,取出队列中第一个用get for i in range(4): print(a.get()) print("出队列完毕") ```
        • 微信爬虫多线程版
          • 这里的多线程是把执行的线程分为三个,一个是获取网址的线程,不停往队列里放网址,一个是获取标题和内容的线程,不停从队列里取网址,一个是判断线程执行情况的线程,不停判断队列是否为空.这样就由一个线程变成了三个线程 ``` import re import urllib.request import time import urllib.error import os import threading import queue def use_proxy(url,proxy_addr=""): try: if(proxy_addr!=""): proxy-urllib.request.ProxyHandler({'http':proxy_addr}) opener=urllib.request.build_opener(porxy,urllib.request.HTTPHandler) urllib.request.install_opener(opener) data=urllib.request.urlopen(url).read() return data except urllib.error.URLError as e: if hasattr(e,"code"): print(e.code) if hasattr(e,"reason"): print(e.reason) #发生了URLErro就延迟10秒 time.sleep(10) except Exception as e: print("exception:"+str(e)) #没有发生URLError就延迟1秒 time.sleep(1) #这个线程用来获取每一页的网址放到队列中 class geturl(threading.Thread): def __init__(self,key,pagestart,pageend,proxy,urlqueue): threading.Thread.__init__(self) self.pagestart=pagestart self.pageend=pageend self.proxy=proxy self.urlqueue=urlqueue self.key=key def run(self): listurl=[] keycode=urllib.request.quote(key) #进入搜狗微信搜索的具体页面 for page in range(pagestart,pageend+1): url="http://weixin.sogou.com/weixin?query="+keycode+"&type=2&page="+str(page) print("当前网址"+url) data1=use_proxy(url,proxy) #取出文章网址列表 listurlpat='<div class="txt-box">\s<h3>[\s\S]*?<a target="_blank" href="(.*?)"' #预编译的re.S代表的是把字符串看成一个整体,由此可以跨行匹配 listurl=re.compile(listurlpat,re.S).findall(data1.decode("utf-8")) print("成功获取到了"+str(len(listurl))+"页") for link in listurl: #把网址中的特殊字符替换 link=link.replace("amp;","") self.urlqueue.put(link) self.urlqueue.task_done() #这个线程用来取出队列里的每一条网址,并访问获取标题内容 class getcontent(threading.Thread): def __init__(self,urlqueue,proxy): threading.Thread.__init__(self) self.urlqueue=urlqueue self.proxy=proxy def run(self): while(True): #取得网址 url=urlqueue.get() data=use_proxy(url,proxy) #取出标题 titlepat='var msg_title = "(.*?)";' title=re.compile(titlepat).findall(data.decode("utf-8")) #这里设置一个初始的标题值 thistitle="没有取到标题" if(title!=[]): #标题不为空,则写文章到html中 thistitle=title[0] htmlname="weixinarticle\\"+thistitle+".html" file=open(htmlname,"wb") file.write(data) file.close() print("正在爬取的文章是"+"--"+thistitle) #这个线程用来检查队列的执行情况,每隔一段时间检测一次,如果为空,说明任务执行完毕 class control(threading.Thread): def __init__(self,urlqueue): threading.Thread.__init__(self) self.urlqueue=urlqueue def run(self): while(True): print("程序执行中") #设定间隔为30秒 time.sleep(30) if(self.urlqueue.empty()): print("程序执行完毕") exit() #模拟浏览器 headers=("user-agent","Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.87 Safari/537.36") opener=urllib.request.build_opener() opener.addheaders=[headers] #安装全局opener urllib.request.install_opener(opener) #设置空网址列表 listurl=[] #创建一个队列 urlqueue=queue.Queue() key="物联网" #代理地址,这里没设置,有需要的就设置,调用的子程序判断不为空才会启用代理 proxy="" pagestart=1 pageend=2 #如果不存在,创建一个目录文章目录 if os.path.exists("weixinarticle")==False: os.mkdir("weixinarticle") t1=geturl(key,pagestart,pageend,proxy,urlqueue) t2=getcontent(urlqueue,proxy) t3=control(urlqueue) t1.start() t2.start() t3.start() ```
  • 学会使用Fiddler
    • 什么是Fiddler
      • 一款抓包软件,用来截获浏览器客户端与外界之间通信的数据
      • 其他
        • 浏览器自带调试f12
          • 不支持复杂抓包
        • wireshark
          • 功能比较齐全
    • 爬虫与Fiddler的关系
      • fiddler可以更好的分析网页,使得我们能够编写更好的爬虫
    • 自行了解
      • Fiddler的基本原理与基本界面
      • Fiddler捕获会话功能
      • 使用QuickExec命令行
      • Fiddler断点功能
      • Fiddler会话查找功能
      • Fiddler的其他功能
  • 爬虫的浏览器伪装技术
    • 什么是浏览器伪装技术
      • 网站识别出是非浏览器访问的,可能会禁止访问,这时候就需要伪装
      • 常见的反爬虫机制
        • 分析headers
          • user-agent
            • 浏览器
          • referer
            • 引用来源页
        • 检测用户行为,比如同一ip频繁访问
          • 这个可以通过代理ip
        • 增加动态页面增加爬虫难度
          • 可以通过第三方工具软件破解
      • 本书主要针对第一种机制
    • 浏览器伪装技术准备工作
      • 了解headers,了解协议中常见字段代表什么意思
    • 爬虫的浏览器伪装技术实战
      • 无伪装程序
        • 随便找的一篇网易的文章,这个程序抓包运行后,可以看到fiddler里的user-agent是python-urllib/3.6,并非浏览器 ``` import urllib.request import http.cookiejar url="http://news.163.com/18/0703/13/DLPV78UP00018AOQ.html" #fiddler的代理地址是127.0.0.1:8888 proxy=urllib.request.ProxyHandler({'http':"127.0.0.1:8888"}) cjar=http.cookiejar.CookieJar() opener=urllib.request.build_opener(proxy,urllib.request.HTTPHandler,urllib.request.HTTPCookieProcessor(cjar)) urllib.request.install_opener(opener) response=urllib.request.urlopen(url) #写到文件 data=response.read() fhandle=open("fiddle_test1.html","wb") fhandle.write(data) fhandle.close() ```
      • 有伪装程序
        • 通过headers添加,再抓包,就可以看到不再是python,而是设定的值 ``` import urllib.request import http.cookiejar #随便找的一篇网易的文章 url="http://news.163.com/18/0703/13/DLPV78UP00018AOQ.html" #fiddler的代理地址是127.0.0.1:8888 #以字典的形式设置headers headers={"accept":"text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8", "Accept-Language":"zh-CN,zh;q=0.8", "User-Agent":"Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.87 Safari/537.36", "Connection":"keep-alive" } proxy=urllib.request.ProxyHandler({'http':"127.0.0.1:8888"}) cjar=http.cookiejar.CookieJar() opener=urllib.request.build_opener(proxy,urllib.request.HTTPHandler,urllib.request.HTTPCookieProcessor(cjar)) #因为addheaders是列表中包裹着元组,所以要把上面的字典headers做处理 headerall=[] for name,value in headers.items(): headerall.append((name,value)) opener.addheaders=headerall urllib.request.install_opener(opener) response=urllib.request.urlopen(url) data=response.read() fhandle=open("fiddle_test1.html","wb") fhandle.write(data) fhandle.close() ```
  • 爬虫的定向爬取技术
    • 什么是爬虫的定向爬取技术
      • 根据设定的主题,对网页和内容进行筛选
      • 需要解决三个问题
        • 定义好目标,和主题
        • 建立好网站的筛选和内容过滤
        • 建立好url排序算法
    • 定向爬取的相关步骤与策略
      • 步骤
        • 理清目标
        • 设置网址过滤机制
        • 设置内容过滤机制
        • 规划采集任务
        • 结果修正
        • 结果后续处理
      • 图解
      • 信息筛选策略
        • 正则表达式
        • Xpath
          • Xpath是Xml的路径语言,在Scapy框架中经常用到
        • xlst
          • XSLT 指 XSL 转换,可以把xml转换成其他文档
    • 定向爬取实战
      • 腾讯视频评论批量采集并加载评论
        • ``` import urllib.request import http.cookiejar import urllib.error import re def craw(vid,comid): try: url="http://coral.qq.com/article/"+vid+"/comment?commentid="+comid+"&reqnum=20" data=urllib.request.urlopen(url).read() except urllib.error.URLError as e: if hasattr(e,"code"): print(e.code) if hasattr(e,"reason"): print(e.reason) except Exception as e: print(e.message) return data #以字典的形式设置headers headers={"accept":"text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8", "Accept-Language":"zh-CN,zh;q=0.8", "User-Agent":"Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.87 Safari/537.36", "Connection":"keep-alive" } cjar=http.cookiejar.CookieJar() opener=urllib.request.build_opener(urllib.request.HTTPCookieProcessor(cjar)) #因为addheaders是列表中包裹着元组,所以要把上面的字典headers做处理 headerall=[] for name,value in headers.items(): headerall.append((name,value)) opener.addheaders=headerall urllib.request.install_opener(opener) #视频id vid="1301388867" #评论的id,初始为零就是从最开始,后续还想要加载更多,就需要把最后一个id传递给加载的网址 comid="0" #加载的条数,这里设置为20 idpat='"id":"(.*?)"' userpat='"nick":"(.*?)"' compat='"content":"(.*?)"' for i in range(1,4): print("第"+str(i)+"页评论内容") print("---------------------") datacontent=craw(vid,comid) #书上下面的代码是放到循环里的,这样不能说错,但是每次循环都会取一次列表,这样增加了程序的开销,所以放到外面来 idlist=re.compile(idpat,re.S).findall(datacontent.decode("utf-8")) userlist=re.compile(userpat,re.S).findall(datacontent.decode("utf-8")) comlist=re.compile(compat,re.S).findall(datacontent.decode("utf-8")) for j in range(0,20): try: print("用户名是:"+eval('u"'+userlist[j]+'"')) except: print("用户名有特殊字符,无法解码:"+userlist[j]) print("评论内容:"+eval('u"'+comlist[j]+'"')) print("\n") #把当前页的最后一个id赋值给comid comid=idlist[19] ```
• 框架实现篇
  • 了解Python爬虫框架
    • 什么是Python爬虫框架
      • 一些爬虫项目的半成品,留下了一些接口
      • 框架中已经实现了一些常用的功能
    • 常见的Python爬虫框架
      • Scrapy框架
      • Crawley框架
      • Portia框架
      • newspaper框架
      • Python—goose框架
  • 爬虫利器——Scrapy安装与配置
    • 在Windows7下安装及配置Scrapy实战详解
      • 命令行下:pip instal scrapy
    • 在Linux（Centos）下安装及配置Scrapy实战详解
    • 在MAC下安装及配置Scrapy实战详解
  • 开启Scrapy爬虫项目之旅
    • 认识Scrapy项目的目录结构
      • 项目文件夹
        • 同名项目文件夹
          • spiders文件夹
            • __init__.py
              • 项目中,爬虫部分的初始化,主要是对spiders的初始化
            • 还有其他的爬虫文件
          • __init__.py
            • 项目的初始化信息
          • items.py
            • 爬虫项目的数据容器文件,主要用来定义获取的数据
          • pipelines.py
            • 项目的管道文件,主要用来对item是里的数据进行进一步的加工
          • settings.py
            • 爬虫项目的一些设置信息
          • middleware.py
            • 下载中间件
        • Scrapy.cfg
          • 放置爬虫的配置文件
    • 用Scrapy进行爬虫项目管理
      • 命令行进入文件夹
      • scrapy startproject 项目名
        • 常用参数
          • --logfile=FILE
            • 用来指定日志文件 ``scrapy startproject --file="../log.txt" 项目名`` 就是在当前上一个目录下建立一个日志文件,打开的时候是有信息的
          • --loglevel=LEVEL, -L LEVEL
            • 设置日志的等级,这个有五个等级 1. DEBUG 输出调试信息,用于开发阶段默认是这个阶段 2. INFO 输出提示信息 3. WARNING 出现一些警告信息,存在前在错误 4. ERROR 发生了必须处理的错误 5. CRITICAL发生最严重的错误 命令: ``scrapy startproject -L INFO 项目名`` ``scrapy startproject --loglevel=INFO 项目名``
          • --nolog
            • 控制不输出日志 ``scrapy startproject --nolog 项目名``
    • 常用工具命令
      • 全局命令
        • 不需要进入项目文件下就可以运行的命令
        • 常用
          • fetch
            • fetch用来显示爬取对应网址的过程 如果在项目之外就会调用默认的爬虫,如果是在项目之内就会调用项目内的爬虫 访问百度显示协议头,不显示日志 ``scrapy fetch --headers --nolog http://www.baidu.com``
          • runspider
            • runspider可以不依托scrapy项目,来运行一个爬虫文件 下面的测试源码,可以放在其他的任何地方,这里假设是text.py ``` from scrapy.spiders import Spider class FirstSpider(Spider): name="first" allowed_doman=["baidu.com"] start_urls=[ "http://www.baidu.com" ] def parse(self,response): pass ``` 处理好爬虫文件之后,输入命令 ``scrapy runspider --loglevel=INFO test.py``
          • settings
            • 项目内使用settings命令,看到的settings.py里面的内容,项目外使用则是查看默认的scrapy设置 `` scrapy settings --get BOT_NAME `` 如果按照右图的项目设置,返回的回事test1,如果在项目外就是scrapybot
            • 查询的时候需要带上要查询的字段信息,这些信息都可以打开项目的settings就可以看到
          • shell
            • shell经常在开发和调试的时候用到,此命令可以启动scrapy的交互命令终端 命令:调试百度,不打印日志 ``scrapy shell --nolog http://www.baidu.com `` 进入命令行之后,可以打印标题信息 ``ti=sel.xpath("/html/head/title") `` `` print(ti) `` 退出是``exit()``
          • startproject
            • 前面已经介绍过,这个是用来创建项目,并生成一系列文件的
          • version
            • 用于查看scrapy的版本 ``scrapy version`` 查看更多的版本信息 ``scraoy version -v``
          • view
            • 此命令可以自动下载指定的网页并用浏览器打开,打开的时候是本地文件 ``scrapy view http://www.baidu.com``
      • 项目命令
        • 必须要在项目中运行才可以,必须要进入项目目录
        • 常用
          • bench
            • 此命令用于测试本地硬件,运行的时候会创建一个本地服务器,并以最大的速度爬行,可以从日志中看出爬取的速度 ``scrapy bench``
          • genspider
            • 此命令可以用来生成一个基于scrapy模板的爬虫文件 查看有什么模板,可以任选一个创建 ``scrapy genspider -l`` 创建模板爬虫,-t后面跟模板名 爬虫名 域名 ``scrapy genspider -t basic test www.baidu.com`` 这样就创建了一个以basic为模板的名为test的爬取百度的爬虫如果想要查看模板的内容,用下面的命令 ``scrapy genspider -d basic``
          • check
            • 此命令用来测试爬虫,爬虫名不带后缀的,采用合同(contract)的方式,这个不是很明白 ``scrapy check 爬虫名``
          • crawl
            • 此命令用来启动爬虫,爬虫名不带后缀的 ``scrapy crawl 爬虫名``
          • list
            • 在项目目录下输入,可以查看当前的所用的爬虫名称 ``scraoy list``
          • edit
            • 用来编辑文件,windows下用的比较少,linux下用的比较多 ``scrapy edit 爬虫名``
          • parse
            • 此命令可以实现获取指定的url,并指定相应的爬虫 这个参数很多,看书
    • 实战：Items的编写
      • 定义结构化数据
        • 这是直接在items.py上改的,后面用得上 ``` import scrapy class MyfirstpjtItem(scrapy.Item): # define the fields for your item here like: # name = scrapy.Field() urlname=scrapy.Field() urlkey=scrapy.Field() urlcr=scrapy.Field()#版权 urladdr=scrapy.Field() ```
      • 小练习
        • ``` import scrapy #item是要定义一系列结构化的数据 class person(scrapy.Item): name=scrapy.Field() job=scrapy.Field() email=scrapy.Field() #创建一个实例 person1=person(name="weiwei",job="teacher",email="[e-mail]") #可以看到,对应的数据以字典的形式储存 print(person1) #单独输出某字段的值 print("person1的name是"+person1["name"]) #需要改变某项的值 person1["name"]="leilei" print("person1的name修改后的值:"+person1["name"]) #查看所有的字段名 print("person1的所有字段名:"+str(person1.keys())) #查看对象的项目视图 print("person1的项目视图:"+str(person1.items())) ```
    • 实战：Spider的编写
      • 所有的爬虫必须继承spider这个类
        • 这是利用genspider生成的爬虫文件first.py,可以看到,firstspider继承了Spider这个类 三个字段 name就是爬虫的名字 allowed_domains是允许爬行的域名 start_urls代表起始网址,里面可以定义多个url ``` import scrapy class FirstSpider(scrapy.Spider): name = 'first' allowed_domains = ['www.baidu.com'] start_urls = ['http://www.baidu.com/'] def parse(self, response): pass ``` parse方法没有特别指定,会采用默认方法处理response
      • 修改生成的爬虫
        • ```# -*- coding: utf-8 -*- import scrapy #调用目录文件下的itmes.py的MyfirstpjtItem类,这个在items实战里设置了 from Myfirstpjt.items import MyfirstpjtItem class FirstSpider(scrapy.Spider): name = 'first' allowed_domains = ['sina.com.cn'] #设置了三个网址,一个首页,两篇新闻 start_urls = [ 'http://news.sina.com.cn/', 'http://news.sina.com.cn/c/2018-07-04/doc-ihevauxk4488022.shtml', 'http://finance.sina.com.cn/china/gncj/2018-06-27/doc-iheqpwqx7497616.shtml' ] def parse(self, response): item=MyfirstpjtItem() item["urlname"]=response.xpath("/html/head/title/text()") print(item["urlname"]) ```
      • 如果不使用start_urls
        • ``` # -*- coding: utf-8 -*- import scrapy #调用目录文件下的itmes.py的MyfirstpjtItem类,这个在items实战里设置了 from Myfirstpjt.items import MyfirstpjtItem class FirstSpider(scrapy.Spider): name = 'first' allowed_domains = ['sina.com.cn'] #设置了三个网址,一个首页,两篇新闻 start_urls = [ 'http://news.sina.com.cn/', 'http://news.sina.com.cn/c/2018-07-04/doc-ihevauxk4488022.shtml', 'http://finance.sina.com.cn/china/gncj/2018-06-27/doc-iheqpwqx7497616.shtml' ] urls2={ "http://www.jd.com", "http://sina.com.cn", "http://www.baidu.com" } #这个是重新写了start_requests方法 def start_requests(self): for url in self.urls2: #调用默认的方法生成请求,这个yield会产生一个迭代器,是比较高级的用法 yield self.make_requests_from_url(url) def parse(self, response): item=MyfirstpjtItem() item["urlname"]=response.xpath("/html/head/title/text()") print(item["urlname"]) ```
    • XPath基础
      • /
        • 选择标签
      • //
        • 选择所有某一类标签
      • /text()
        • 获取文本信息
      • //Z[@X="Y"]
        • 获取所有属性为x的值为y的z标签
        • //img[class="f1"]
    • Spider类参数传递
      • 修改Spider的爬虫文件
        • 单个传递
          • 命令:``scrapy crawl first -a myurl=http://www.sina.com.cn --nolog``就可以把网址传给爬虫文件 ``` # -*- coding: utf-8 -*- import scrapy #调用目录文件下的itmes.py的MyfirstpjtItem类,这个在items实战里设置了 from Myfirstpjt.items import MyfirstpjtItem class FirstSpider(scrapy.Spider): name = 'first' def __init__(self,myurl=None,*args,**kwargs): super(FirstSpider,self).__init__(*args,**kwargs) #输入要爬取的网址,对应之为接受到的参数 print("要爬取的网址为:%s"%myurl) #重新定义start_urls属性,属性值为传进来的参数值 self.start_urls=["%s"%myurl] def parse(self, response): item=MyfirstpjtItem() item["urlname"]=response.xpath("/html/head/title/text()") print("以下将显示爬取网址的标题") print(item["urlname"]) ```
        • 多个传递
          • 就是把单个传递的字符串用|分割,转化成列表传递给start_urls 命令: `` scrapy crawl first -a myurl="http://www.sina.com.cn|http://www.csdn.net --nolog"`` ``` # -*- coding: utf-8 -*- import scrapy #调用目录文件下的itmes.py的MyfirstpjtItem类,这个在items实战里设置了 from Myfirstpjt.items import MyfirstpjtItem class FirstSpider(scrapy.Spider): name = 'first' def __init__(self,myurl=None,*args,**kwargs): super(FirstSpider,self).__init__(*args,**kwargs) #用|号分割网址 myurllist=myurl.split("|") #遍历网址列表,分别输出 for i in myurllist: print("要爬取的网址为:%s"%i) self.start_urls=myurllist def parse(self, response): item=MyfirstpjtItem() item["urlname"]=response.xpath("/html/head/title/text()") print("以下将显示爬取网址的标题") print(item["urlname"]) ```
    • 用XMLFeedSpider来分析XML源
      • 复制xml网址(作者博客)
        • http://blog.sina.com.cn/rss/1615888477.xml
      • 创建myxml爬虫项目
        • ``scrapy startproject myxml``
        • 编辑items.py
          • ``` import scrapy class MyxmlItem(scrapy.Item): # define the fields for your item here like: # name = scrapy.Field() #存储文章标题 title=scrapy.Field() #存储对应链接 link=scrapy.Field() #存储对应文章作者 author=scrapy.Field() ```
        • 创建一个爬虫文件
          • 查看模板 ``scrapy genspider -l`` 使用xmlfeed模板 ``scrapy genspider -t xmlfeed myxmlspider sina.com.cn`` 修改myxmlspider.py ``` # -*- coding: utf-8 -*- from scrapy.spiders import XMLFeedSpider from myxml.items import MyxmlItem class MyxmlspiderSpider(XMLFeedSpider): name = 'myxmlspider' allowed_domains = ['sina.com.cn'] start_urls = ['http://blog.sina.com.cn/rss/1615888477.xml'] iterator = 'iternodes' # you can change this; see the docs #迭代开始节点rss itertag = 'rss' # change it accordingly def parse_node(self, response, node): i = MyxmlItem() #利用xpath表达式将对饮信息提取出来,并存储到对应的item中 #extract:返回选择器（列表）对应的节点的字符串（列表） i['title'] = node.xpath("/rss/channel/item/title/text()").extract() i['link'] = node.xpath("/rss/channel/item/link/text()").extract() i['author'] = node.xpath("/rss/channel/item/author/text()").extract() for j in range(len(i['title'])): print("第"+str(j+1)+"篇文章") print("标题是: "+i['title'][j]) print("对应链接是: "+i['link'][j]) print("对应的作者是: "+i['author'][j]) print("----------------") return i ```
      • 运行爬虫
        • ``scrapy crawl myxmlspider --nolog``
    • 学会使用CSVFeedSpider
      • 新建一个csv(作者有提供一个云文件)
        • http://yum.iqianyue.com/weisuenbook/pyspd/part12/mydata.csv
      • 创建mycsv爬虫项目
        • ``scrapy startproject mycsv``
        • 编辑items.py
          • 这个csv,我们要取姓名,性别,地址,email ``` import scrapy class MycsvItem(scrapy.Item): # define the fields for your item here like: # name = scrapy.Field() name=scrapy.Field() sex=scrapy.Field() addr=scrapy.Field() email=scrapy.Field() ```
        • 创建一个爬虫文件
          • 查看模板 ``scrapy genspider -l`` 使用csvfeed模板 ``scrapy genspider -t csvfeed mycsvspider iqianyue.com` 修改mycsvspider.py ``` # -*- coding: utf-8 -*- from scrapy.spiders import CSVFeedSpider from mycsv.items import MycsvItem class MycsvspiderSpider(CSVFeedSpider): name = 'mycsvspider' allowed_domains = ['iqianyue.com'] #定义csv所在的网址 start_urls = ['http://yum.iqianyue.com/weisuenbook/pyspd/part12/mydata.csv'] #定义csv的头部 headers = ['name', 'sex', 'addr', 'email'] #定义数据分割符号,csv是以逗号玮分隔符 delimiter = ',' # Do any adaptations you need here #def adapt_response(self, response): # return response def parse_row(self, response, row): i = MycsvItem() #提取信息,书里用到了encode,实际上不用,提示需要的是一个字符串,而不是字节 i['name'] = row['name'] i['sex'] = row['sex'] i['addr'] = row['addr'] i['email'] = row['email'] #打印信息,为了好看,打印信息放成一行 print("名字是:"+i['name']+" 性别是:"+i['sex']+" 地址是:"+i['addr']+" 邮箱是:"+i['email']) print('-----------------') return i ```
      • 运行爬虫
        • ``scrapy crawl mycsvspider --nolog``
    • Scrapy爬虫多开技能
      • CrawProcess
        • <a href="https://doc.scrapy.org/en/latest/topics/practices.html" target="_blank">官方文档</a>
      • 修改craw源码+自定义命令
        • 创建mymultispd项目
          • ``scrapy startproject mymultispd``
          • 创建三个爬虫文件
            • 先进入项目 ``cd mymultispd`` 再创建三个基本模板的爬虫文件 ``scrapy genspider -t basic myspd1 sina.com.cn`` ``scrapy genspider -t basic myspd2 sina.com.cn`` ``scrapy genspider -t basic myspd3 sina.com.cn``
          • 复制scrapy项目的crawl源码,并修改
            • scrapy项目地址
              • ``https://github.com/scrapy/scrapy``
            • crawl源码
              • crawl的地址是: ``https://github.com/scrapy/scrapy/blob/master/scrapy/commands/crawl.py`` ``` import os from scrapy.commands import ScrapyCommand from scrapy.utils.conf import arglist_to_dict from scrapy.utils.python import without_none_values from scrapy.exceptions import UsageError class Command(ScrapyCommand): requires_project = True def syntax(self): return "[options] <spider>" def short_desc(self): return "Run a spider" def add_options(self, parser): ScrapyCommand.add_options(self, parser) parser.add_option("-a", dest="spargs", action="append", default=[], metavar="NAME=VALUE", help="set spider argument (may be repeated)") parser.add_option("-o", "--output", metavar="FILE", help="dump scraped items into FILE (use - for stdout)") parser.add_option("-t", "--output-format", metavar="FORMAT", help="format to use for dumping items with -o") def process_options(self, args, opts): ScrapyCommand.process_options(self, args, opts) try: opts.spargs = arglist_to_dict(opts.spargs) except ValueError: raise UsageError("Invalid -a value, use -a NAME=VALUE", print_help=False) if opts.output: if opts.output == '-': self.settings.set('FEED_URI', 'stdout:', priority='cmdline') else: self.settings.set('FEED_URI', opts.output, priority='cmdline') feed_exporters = without_none_values( self.settings.getwithbase('FEED_EXPORTERS')) valid_output_formats = feed_exporters.keys() if not opts.output_format: opts.output_format = os.path.splitext(opts.output)[1].replace(".", "") if opts.output_format not in valid_output_formats: raise UsageError("Unrecognized output format '%s', set one" " using the '-t' switch or as a file extension" " from the supported list %s" % (opts.output_format, tuple(valid_output_formats))) self.settings.set('FEED_FORMAT', opts.output_format, priority='cmdline') def run(self, args, opts): if len(args) < 1: raise UsageError() elif len(args) > 1: raise UsageError("running 'scrapy crawl' with more than one spider is no longer supported") spname = args[0] self.crawler_process.crawl(spname, **opts.spargs) self.crawler_process.start() if self.crawler_process.bootstrap_failed: self.exitcode = 1 ```
          • 创建一个文件夹,放改造的源码(spider同级目录)
            • 文件夹名称随意,这里命名为mycmd,这里都是通过cmd命令创建,也可以直接手动建立 ``mkdir mycmd`` 进入文件夹 ``cd mycmd`` 创建文件 ``echo # >mycrawl.py``
            • 改造crawl源码
              • 打开mycrawl.py复制crawl的源码,并修改 主要修改的部分为,run方法,其他的地方都没有变 ``` #这里是修改的主要部分,可以对比查看源码改了哪些地方 def run(self, args, opts): #获取爬虫列表,这里牵涉到一个问题,从哪里获取列表 spd_loader_list=self.crawler_process.spider_loader.list() #遍历爬虫 for spname in spd_loader_list: #下面的代码运行爬虫 self.crawler_process.crawl(spname, **opts.spargs) print("此时启动的爬虫为: "+spname) self.crawler_process.start() if self.crawler_process.bootstrap_failed: self.exitcode = 1 ```
            • 增加__init__文件
              • 只是确保有这个文件 ``echo #>__init__.py``
          • 修改settings.py
            • 原来的是 ``` BOT_NAME = 'mymultispd' SPIDER_MODULES = ['mymultispd.spiders'] NEWSPIDER_MODULE = 'mymultispd.spiders' ROBOTSTXT_OBEY = True ``` 增加一条 ``COMMANDS_MODULE='mymultispd.mycmd'`` ``` BOT_NAME = 'mymultispd' SPIDER_MODULES = ['mymultispd.spiders'] NEWSPIDER_MODULE = 'mymultispd.spiders' COMMANDS_MODULE='mymultispd.mycmd' ROBOTSTXT_OBEY = True ```
          • 查看命令
            • 在前面的步骤都完成之后,可输入命令行``scrapy -h``查看,如果配置没有问题的话,命令中应该会出现``mycrawl``
          • 运行爬虫
            • 不需要输入文件名直接运行 ``scrapy mycrawl --nolog``
    • 避免被禁止
      • 碰到反爬虫机制,会被禁止
      • 策略
        • 禁止cookie
          • 通过禁用本地cookie,让对方无法识别我们的会话信息 在settings.py中,有一段代码是被注视的 ``` #COOKIES_ENABLED = False ``` 只需要把注释取消就可以禁用本地cookie
        • 设置下载延时
          • 对于会检查访问频率的网站,可以设置下载延时 将settings.py中的注释取消,并设置具体的值,单位是秒 ``` #DOWNLOAD_DELAY = 3 ```
        • 设置代理ip池
          • 创建一个下载中间件middlewares
            • 事实上,项目创建会自动生成一个 middlewares.py,可以直接在上面修改
          • settings.py设置ip池
            • ``` #设置ip池 IPPOOL=[ {"ipaddr":"121.16.204.179:8118"}, {"ipaddr":"14.118.254.113:6666"}, {"ipaddr":"118.190.95.43:9001"}, ] ```
          • 修改middlewares.py
            • ``` from scrapy import signals import random from myippoolspider.settings import IPPOOL #导入与代理服务器相关的中间件类 from scrapy.contrib.downloadermiddleware.httpproxy import HttpProxyMiddleware #可以自己定义一个类,也可以直接在下面修改类(xxspiderDownloaderMiddleware),这里自己创建一个 class IpPools(HttpProxyMiddleware): def __init__(self,ip=""): self.ip=ip def process_request(self,request,spider): #先随机选择一个ip thisip=random.choice(IPPOOL) print("当前使用的ip是"+thisip['ipaddr']) #将对应的ip实际添加为具体的代理,用该ip进行爬取 request.meta["proxy"]="http://"+thisip["ipaddr"] ```
          • settings.py绑定中间件
            • 找到settings文件中的DOWNLOADER_MIDDLEWARES这个字段,把注释取消 ``` # DOWNLOADER_MIDDLEWARES = { # 'myippoolspider.middlewares.MyippoolspiderSpiderMiddleware': 543, # } ``` 增加一段代码,字典里的值是中间件的顺序,这个中间件顺序需要深入了解一下 ``` DOWNLOADER_MIDDLEWARES = { # 'myippoolspider.middlewares.MyippoolspiderDownloaderMiddleware': 543, 'scrapy.contrib.downloadermiddleware.httpproxy.HttpProxyMiddleware':123, 'myippoolspider.middlewares.IpPools':125 } ```
          • 设置好items和爬虫文件,就可以运行了
        • 设置用户代理池
          • 同样创建一个中间件
          • settings.py设置ua池
            • ``` #设置ua池 user_agent_pools=[ 'Mozilla/5.0 (Windows NT 6.2) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1062.0 Safari/536.3', 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1063.0 Safari/536.3', 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.75 Safari/537.36', ] ```
          • 修改middlewares.py
            • ``` from scrapy import signals import random from myippoolspider.settings import user_agent_pools #导入与代理浏览器相关的中间件类 from scrapy.contrib.downloadermiddleware.useragent import UserAgentMiddleware #可以自己定义一个类,也可以直接在下面修改类(xxspiderDownloaderMiddleware),这里自己创建一个 class UserAgent(UserAgentMiddleware): def __init__(self,ua=""): self.user_agent=ua def process_request(self,request,spider): #先随机选择一个ua thisua=random.choice(user_agent_pools) print("当前使用的user-agent是"+thisua) #设置ua request.headers.setdefault('User-Agent',thisua) ```
          • settings.py绑定中间件
            • ``` DOWNLOADER_MIDDLEWARES = { # 'myippoolspider.middlewares.MyippoolspiderDownloaderMiddleware': 543, 'scrapy.contrib.downloadermiddleware.useragent.UserAgentMiddleware':2, 'myippoolspider.middlewares.UserAgent':1 } ```
          • 设置好items和爬虫文件,就可以运行了
        • 其他方法
          • 谷歌cache
          • 分布式爬行
  • Scrapy核心架构
    • Scrapy架构
      • scrapy引擎
        • 是整个scrapy架构的核心,负责控制整个数据处理
      • 调度器
        • 实现存储待爬取的网址,并确定这些网址的优先级,决定下一次爬取哪一个地址
      • 下载器
        • 实现对网络上要爬取的网页资源进行高速下载
      • 下载中间件
        • 处于下载器和scrapy引擎之间的一个特定的组件,用于下载器和scrapy引擎之间的通信进行处理
      • 蜘蛛(也叫爬虫))
        • 主要负责接收scrapy引擎中个response响应
      • 爬虫中间件
        • 用于对爬虫组件和scrapy引擎之间的通信处理
      • 实体管道
        • 接受从蜘蛛组件中提取出来的项目(item)
    • Scrapy工作流
  • Scrapy中文输出与存储
    • Scrapy的中文输出
      • scrapy的中文输出已经比较完善,在python2.x中需要用encode编码,而3.x可以直接输出
    • Scrapy的中文存储
      • settings配置pipelines
        • 取消注释 ``` ITEM_PIPELINES = { 'Myfirstpjt.pipelines.MyfirstpjtPipeline': 300, } ```
      • 编写pipelinse.py
        • 需要注意的是,爬虫文件里的item必须要返回,管道文件才能接受得到 ``` import codecs class MyfirstpjtPipeline(object): def __init__(self): self.file=codecs.open("test.txt","wb",encoding="utf-8") def process_item(self, item, spider): #设置每行要写的内容 l=str(item)+"\n" #打印输出信息 self.file.write(l) return item def close_spider(self,spider): #关闭文件 self.file.close() ```
      • 运行爬虫就可以看到结果
    • 输出中文到JSON文件
      • 与上面一样,只是管道文件需要做些许修改 ``` import codecs import json class MyfirstpjtPipeline(object): def __init__(self): self.file=codecs.open("test.json","wb",encoding="utf-8") def process_item(self, item, spider): #设置每行要写的内容 #通过dic(item)将item转化成字典 #通过json模块下的dumps()序列化数据 #ensure_ascii=False让写到json的数据不使用编码ascii,从而显示成中文 i=json.dumps(dict(item),ensure_ascii=False) #得到的数据后加上"\n"换行符形成要写入的数据 line=i+'\n' print(line) #打印输出信息 self.file.write(line) return item def close_spider(self,spider): #关闭文件 self.file.close() ```
  • 编写自动爬取网页的爬虫(当当网某频道)
    • 创建autopjt项目
      • ``scrapy startproject autopjt``
    • 实战：items的编写
      • 这里准备爬取当当网图书频道,定义四个字段,name,price,link,comnum ``` import scrapy class AutopjtItem(scrapy.Item): # define the fields for your item here like: # name = scrapy.Field() #定义图书名称 name=scrapy.Field() #定义图书价格 price=scrapy.Field() #定义图书链接 link=scrapy.Field() #定义图书评论数量 comnum=scrapy.Field() ```
    • 实战：pipelines的编写
      • ``` import codecs import json class AutopjtPipeline(object): def __init__(self): self.file=codecs.open("book.json","wb",encoding="utf-8") def process_item(self, item, spider): #设置每行要写的内容 print(len(item["comnum"])) for i in range(len(item['name'])): name=item['name'][i] price=item['price'][i] link=item['link'][i] comnum=item['comnum'][i] #把字段信息放到一个新的字典里面,这样打开文件的时候就会好看很多 goods={"name":name,"price":price,"link":link,"commum":comnum} #序列化字典,ensure_ascii=False让写到json的数据不使用编码ascii,从而显示成中文,indent=1代表1个缩进 i=json.dumps(goods,ensure_ascii=False,indent=1) #打印输出信息 self.file.write(i+"\n") return item def close_spider(self,spider): #关闭文件 self.file.close() ```
    • 实战：settings的编写
      • 将注释取消 ``` ITEM_PIPELINES = { 'autopjt.pipelines.AutopjtPipeline': 300, } ```
    • 自动爬虫编写实战
      • 创建一个basic模板的爬虫文件 ``scrapy genspider -t basic autospd dangdang.com`` 改写autospd.py ``` import scrapy from autopjt.items import AutopjtItem from scrapy.http import Request class AutospdSpider(scrapy.Spider): name = 'autospd' allowed_domains = ['dangdang.com'] start_urls = ['http://search.dangdang.com/?key=python&act=input&show=big&page_index=1'] def parse(self, response): item=AutopjtItem() item['name']=response.xpath("//a[@class='pic']/@title").extract() item['price']=response.xpath("//span[@class='price_n']/text()").extract() item['link']=response.xpath("//a[@class='pic']/@href").extract() item['comnum']=response.xpath("//a[@name='itemlist-review']/text()").extract() #提取完后返回item yield item #通过循环自动爬取,这里只设置了一页,可以自己设置 for i in range(2,3): #通过上面的网址构建要爬取的格式 url="http://search.dangdang.com/?key=python&act=input&show=big&page_index="+str(i) yield Request(url,callback=self.parse) ```
    • 调试与运行
      • 调试的时候如果出现了forbidden for robot.txt,这个是因为遵循机器人协议,打开settings.py找到 ``` # Obey robots.txt rules ROBOTSTXT_OBEY = True ``` 可以看到这个是true,这个就代表我们这个爬虫是遵循机器人协议的,只需要改成False就可以无视机器人协议
  • CrawlSpider
    • 初识CrawlSpider
      • scrapy框架的自带的自动爬取网页的爬虫
        • 这个是生成的craw模板文件 ``` import scrapy from scrapy.linkextractors import LinkExtractor from scrapy.spiders import CrawlSpider, Rule class CwspdSpider(CrawlSpider): name = 'cwspd' allowed_domains = ['sohu.com'] start_urls = ['http://sohu.com/'] rules = ( Rule(LinkExtractor(allow=r'Items/'), callback='parse_item', follow=True), ) def parse_item(self, response): i = {} #i['domain_id'] = response.xpath('//input[@id="sid"]/@value').extract() #i['name'] = response.xpath('//div[@id="name"]').extract() #i['description'] = response.xpath('//div[@id="description"]').extract() return i ``` ```
    • 链接提取器(linkExtractor)
      • 负责将response中的网址提取出来,这个在下面的实战中可以看得出来
      • 参数
        • allow
          • 提取符合正则表达式的链接
        • deny
          • 不提取符合正则表达式的链接
        • restrict_xpaths
          • 使用xpath表达式,和allow共同作用过滤链接
        • allow_domain
          • 允许提取的域名
        • deny_domain
          • 不想提取的域名
    • 实战：CrawlSpider实例(新浪新闻)
      • 创建项目
        • 因为搜狐新闻的网址发生了很大的变化,不再如书中所说,换成新浪的 ``scrapy startproject mycwpjt``
        • 编辑items.py
          • 只取新闻标题和链接 ``` import scrapy class MycwpjtItem(scrapy.Item): # define the fields for your item here like: # name = scrapy.Field() title=scrapy.Field() link=scrapy.Field() ```
        • 编辑pipelines.py
          • 为了显示效果,只做简单的打印 ``` class MycwpjtPipeline(object): def process_item(self, item, spider): #判断列表成员数,如果大于零才打印 if(len(item['title']))>0: print(item["title"]) if(len(item['link']))>0: print(item["link"]) print("----------------------") return item ```
        • 编辑settings.py
          • 将注释取消 ``` ITEM_PIPELINES = { 'autopjt.pipelines.AutopjtPipeline': 300, } ```
        • 编辑爬虫文件
          • ``` import scrapy from scrapy.linkextractors import LinkExtractor from scrapy.spiders import CrawlSpider, Rule from mycwpjt.items import MycwpjtItem class CwspdSpider(CrawlSpider): name = 'cwspd' allowed_domains = ['sina.com.cn'] start_urls = ['http://news.sina.com.cn/'] rules = ( #新浪新闻网的网页是这种格式 #http://news.sina.com.cn/c/2018-07-05/doc-ihexfcvk0808111.shtml Rule(LinkExtractor(allow=('.*?/doc.*?.shtml'),allow_domains="sina.com.cn"),callback='parse_item', follow=True), ) def parse_item(self, response): i = MycwpjtItem() i['title'] = response.xpath('/html/head/title/text()').extract() i['link'] = response.xpath("/html/head/meta[@property='og:url']/@content").extract() return i ```
        • 运行爬虫
          • ``scrapy crawl cwspd --nolog``
  • Scrapy高级应用
    • 如何在Python3中操作数据库
      • 准备
        • phpstud集成环境
        • pymysql模块
      • pymysql
        • 连接,执行语句
          • 连接名叫mypydb的本地mysql数据库 ``` import pymysql con1=pymysql.connect(host="127.0.0.1",user="root",passwd="root",db="mypydb") ``` 如果没有mypydb数据库,可以创建一个 ``con1.query("CREATE DATABASE mypydb")`` 再使用这个数据库 ``con1.query("USE mypydb")`` 创建一个数据表 `` con1.query("CREATE TABLE mytb(title VARCHAR(20)) NOT NULL,keyword VARCHAR(30) ") `` 插入一些数据,用query语句 ``con1.query()``
        • select查询
          • 创建游标 ``cursor=conn.cursor()`` 执行语句 ``cursor.excute("select * from mytb")`` 取游标值 ``` for i in cursor: print("当前查询的是"+str(cursor.rownumber)+"行") print(i[0]) print(i[1]) 等等 ```
    • 爬取内容写进MySQL
      • 创建项目mysqlpjt
        • 生成crawlspider文件
          • ``scrapy genspider -t crawl mysql sina.com.cn``
        • 编辑items.py
          • ``` import scrapy class MysqlpjtItem(scrapy.Item): # define the fields for your item here like: # name = scrapy.Field() #网页标题 name=scrapy.Field() #keywd存储网页 keywd=scrapy.Field() ```
        • 编辑pipelines.py
          • 为了显示效果,只做简单的打印 ``` import pymysql class MysqlpjtPipeline(object): def __init__(self): self.conn=pymysql.connect(host="127.0.0.1",user="root",passwd="root",db="mypydb") def process_item(self, item, spider): name=item["name"][0] key=item["keywd"][0] sql="insert into mytb(title,keyword) VALUES ('"+name+"','"+key+"')" print(sql) self.conn.query(sql) return item def close_spider(self,spider): self.conn.close() ```
        • 编辑settings.py
          • 将注释取消 ``` ITEM_PIPELINES = { 'mysqlpjt.pipelines.MysqlpjtPipeline': 300, } ```
        • 编辑爬虫文件
          • ``` import scrapy from scrapy.linkextractors import LinkExtractor from scrapy.spiders import CrawlSpider, Rule from mysqlpjt.items import MysqlpjtItem class MysqlSpider(CrawlSpider): name = 'mysql' allowed_domains = ['sina.com.cn'] start_urls = ['http://news.sina.com'] rules = ( Rule(LinkExtractor(allow=('.*?/doc.*?.shtml'),allow_domains="sina.com.cn"),callback='parse_item', follow=True), ) def parse_item(self, response): i = MysqlpjtItem() i['name'] = response.xpath('/html/head/title/text()').extract() print(i["name"]) i['keywd'] = response.xpath('/html/head/meta[@name="keywords"]/@content').extract() return i ```
• 项目实战篇
  • 博客类爬虫项目(和讯博客)
    • 数据库的设计
      • 创建一个数据库名为hexun ``create table hexun`` 使用数据库 ``use hexun`` 创建一个数据表名为myhexun ``` create table myhexun(id int(10) auto_increment primary key not null,name varchar(30),url varchar(100),hits int(15),comment int (15)); ```
    • 创建一个项目hexunpjt
      • 生成一个basic模板的爬虫文件
      • 编辑items.py
        • ``` import scrapy class HexunpjtItem(scrapy.Item): # define the fields for your item here like: # name = scrapy.Field() name=scrapy.Field() url=scrapy.Field() hits=scrapy.Field() comment=scrapy.Field() ```
      • 编辑pipelines.py
        • ``` import pymysql class HexunpjtPipeline(object): def __init__(self): self.conn=pymysql.connect(host="127.0.0.1",user="root",password="root",db="hexun") def process_item(self, item, spider): for j in range(0,len(item['name'])): name=item['name'][j] url=item['url'][j] hits=item['hits'][j] comment=item['comment'][j] hits=item['hits'][j] sql="insert into myhexun(name,url,hits,comment) VALUES ('"+name+"','"+url+"','"+hits+"','"+comment+"')" self.conn.query(sql) return item def close_spider(self,spider): self.conn.close() ```
      • 编辑settings.py
        • 修改值为false ``` ROBOTSTXT_OBEY = False ``` 取消注释 ``` COOKIES_ENABLED = False ``` ``` 取消注释 ITEM_PIPELINES = { 'hexunpjt.pipelines.HexunpjtPipeline': 300, } ```
      • 编辑爬虫文件
        • ``` # -*- coding: utf-8 -*- import scrapy import re import urllib.request from hexunpjt.items import HexunpjtItem; from scrapy.http import Request class HexunspdSpider(scrapy.Spider): name = 'hexunspd' allowed_domains = ['hexun.com'] uid="14755952" def start_requests(self): #博客格式 #http://14755952.blog.hexun.com/p2/default.html yield Request("http://"+str(self.uid)+".blog.hexun.com/p1/default.html",headers={"User-Agent":"Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.87 Safari/537.36"}) def parse(self, response): item=HexunpjtItem() item['name']=response.xpath('//span[@class="ArticleTitleText"]/a/text()').extract() item['url']=response.xpath('//span[@class="ArticleTitleText"]/a/@href').extract() #接下来使用urllib和re模块获取博文的评论数和阅读数 #首先提取存储评论数和点击数网址的正则 pat1='<script type="text/javascript" src="(http://click.tool.hexun.com/.*?)">' #提取网址 hcurl=re.compile(pat1).findall(str(response.body))[0] header2=("User-Agent","Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.87 Safari/537.36") opener=urllib.request.build_opener() opener.addheaders=[header2] urllib.request.install_opener(opener) #提取评论和点击 data2=urllib.request.urlopen(hcurl).read() pat2="'click\d*?','(\d*?)'" pat3="'comment\d*?','(\d*?)'" item['hits']=re.compile(pat2).findall(str(data2)) item['comment']=re.compile(pat3).findall(str(data2)) yield item #提取博文列表页的总页数 pat4="blog.hexun.com/p(.*?)/" #获取的列表中,倒数第二个是总页数 data2=re.compile(pat4).findall(str(response.body)) if(len(data2)>=2): totalurl=data2[-2] else: totalurl="1" for i in range(2,int(totalurl)+1): nexturl="http://"+str(self.uid)+".blog.hexun.com/p"+str(i)+"/default.html" yield Request(nexturl,headers={"User-Agent":"Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.87 Safari/537.36"}) ```
  • 图片类爬虫项目(千图网)
    • 创建项目qtpjt
      • 生成一个basic模板的爬虫文件
      • 编辑items.py
        • ``` import scrapy class QtpjtItem(scrapy.Item): # define the fields for your item here like: # name = scrapy.Field() #建立图片存储的网址 picurl=scrapy.Field() #简历春初图片网址中的图片名,方便构造本地文件名 picid=scrapy.Field() ```
      • 编辑pipelines.py
        • ``` import os import urllib.request class QtpjtPipeline(object): def process_item(self, item, spider): for i in range(0,len(item['picurl'])): if os.path.exists("pic")==False: os.mkdir("pic") localpath="pic\\"+item['picid'][i]+".jpg" print(localpath) urllib.request.urlretrieve(item['picurl'][i],filename=localpath) return item ```
      • 编辑settings.py
        • 修改值为false ``` ROBOTSTXT_OBEY = False ``` 取消注释 ``` COOKIES_ENABLED = False ``` 取消注释 ``` ITEM_PIPELINES = { 'qtpjt.pipelines.QtpjtPipeline': 300, } ```
      • 编辑爬虫文件
        • ``` # -*- coding: utf-8 -*- # -*- coding: utf-8 -*- import scrapy import re from qtpjt.items import QtpjtItem from scrapy.http import Request class QtpicspdSpider(scrapy.Spider): name = 'qtpicspd' allowed_domains = ['58pic.com'] #网址是淘宝素材的热门下载第一页 start_urls = ['http://www.58pic.com/tupian/taobao-0-0-id-0-0-%E6%B7%98%E5%AE%9D-0_2_0_0_0_0_0-01.html'] def parse(self, response): item=QtpjtItem() paturl='(http://pic.qiantucdn.com/58pic/.*?.jpg)' item['picurl']=re.compile(paturl).findall(str(response.body)) print(item['picurl']) patlocal='http://pic.qiantucdn.com/58pic/.*?/.*?/.*?/(.*?).jpg' item['picid']=re.compile(patlocal).findall(str(response.body)) yield item for i in range (2,3): nexturl="http://www.58pic.com/tupian/taobao-0-0-id-0-0-%E6%B7%98%E5%AE%9D-0_2_0_0_0_0_0-0"+str(i)+".html" yield Request(nexturl,callback=self.parse) ```
  • 模拟登录爬虫项目
    • 验证码识别三种方式
      • 手动打码
      • 平台打码
      • 自己编写自动识别程序
    • 模拟登录爬虫项目(豆瓣)
      • 创建项目loginpjt
        • 这个例子只编辑了一个爬虫文件,没有用到items,和pipeline这些
          • ``` # -*- coding: utf-8 -*- import scrapy import urllib.request from scrapy.http import Request,FormRequest class LoginspdSpider(scrapy.Spider): name = 'loginspd' allowed_domains = ['douban.com'] header={"User-Agent":"Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.87 Safari/537.36"} def start_requests(self): return [FormRequest("https://accounts.douban.com/login",headers=self.header,meta={"cookiejar":1},callback=self.parse)] def parse(self,response): captcha=response.xpath('//img[@id="captcha_image"]/@src').extract() if len(captcha)>0: print("此时有验证码") urllib.request.urlretrieve(captcha[0],filename="captcha.png") print("请输入验证码") captcha_value=input() data={ "form_email":"[e-mail]", "form_password":"qq19930813", "captcha-solution":captcha_value, "redir":"https://www.douban.com/people/103071823/" } else: data={ "form_email":"[e-mail]", "form_password":"*******", "redir":"https://www.douban.com/people/103071823/" } return (FormRequest.from_response(response, #设置cookie信息 headers=self.header, formdata=data, callback=self.next, )) def next(self,response): with open("test.txt","wb") as file: file.write(response.body) print("此时已完成登录,并爬取个人数据") #网页标题xpath xtitle="/html/head/title/text()" #日记标题xpath xnotetitle="//div[@class='note-header pl2']/a/@title" #日记发表时间 xnotetime="//div[@class='note-header pl2']//span[@class='pl']/text()" #日记发表内容 xnotecontent="//div[@class='mbtr2']/div[@class='note']/text()" #日记连接 xnoteurl="//div[@class='note-header pl2']/a/@href" title=response.xpath(xtitle).extract() notetitle=response.xpath(xnotetitle).extract() notetime=response.xpath(xnotetime).extract() notecontent=response.xpath(xnotecontent).extract() noteurl=response.xpath(xnoteurl).extract() print("网页标题是"+title[0]) for i in range(0,len(notetitle)): print("第"+str(i)+"篇文章的信息如下:") print("文章标题为:"+notetitle[i]) print("文章发表时间为:"+notetime[i]) print("文章内容为:"+notecontent[i]) print("文章连接为:"+noteurl[i]) ```
      • 调试运行
        • 豆瓣出现403错误,就在settings.py里面把USER-AGENT注释取消,并添加相应的浏览器信息