2019/10/28更新

使用Python3，而不再是Python2


转载请注明出处：https://blog.csdn.net/aaronjny/article/details/77945329
爬虫入门系列教程：


python爬虫入门教程(一)：开始爬虫前的准备工作


python爬虫入门教程(二)：开始一个简单的爬虫


python爬虫入门教程(三)：淘女郎爬虫 ( 接口解析 | 图片下载 )


等待更新…



上一篇讲了开始爬虫前的准备工作。当我们完成开发环境的安装、IDE的配置之后，就可以开始开发爬虫了。  这一篇，我们开始写一个超级简单的爬虫。
1.爬虫的过程分析
当人类去访问一个网页时，是如何进行的？

　　①打开浏览器，输入要访问的网址，发起请求。

　　②等待服务器返回数据，通过浏览器加载网页。

　　③从网页中找到自己需要的数据（文本、图片、文件等等）。

　　④保存自己需要的数据。
对于爬虫，也是类似的。它模仿人类请求网页的过程，但是又稍有不同。

　　首先，对应于上面的①和②步骤，我们要利用python实现请求一个网页的功能。

　　其次，对应于上面的③步骤，我们要利用python实现解析请求到的网页的功能。

　　最后，对于上面的④步骤，我们要利用python实现保存数据的功能。

　　因为是讲一个简单的爬虫嘛，所以一些其他的复杂操作这里就不说了。下面，针对上面几个功能，逐一进行分析。
2.如何用python请求一个网页
作为一门拥有丰富类库的编程语言，利用python请求网页完全不在话下。这里推荐一个非常好用的第三方类库requests。
2.1 requests
2.1.1 安装方式
打开终端或者cmd，在里面输入以下指令并回车
pip3 install requests



　　一般不会出什么问题，如果下载太慢，是因为pip使用的源服务器在国外，可以设置pip使用国内镜像源，设置方法可以参考PyPI使用国内源。
2.1.2 测试是否安装成功
在命令行中输入python，敲击回车，进入python交互环境。在里面输入以下代码并回车：
import requests

如果不报错，就安装成功了，如下图：

　　
2.2 使用requests请求网页
打开pycharm，创建一个项目，嗯，随便取个名字吧。

　　

　　创建成功后，再创建一个py文件，用来写代码。嗯，再随便取个名字= =教程（二）的2.2，那就spider_2_2_2吧。

　　

　　在里面输入以下代码：
#coding=utf-8
import requests

resp=requests.get('https://www.baidu.com') #请求百度首页
print(resp) #打印请求结果的状态码
print(resp.content) #打印请求到的网页源码

对上面的代码进行以下简单的分析：

　　我是用的是python2.7，第1行到第4行，都是为了将字符编码设置为utf8。

　　第2行：引入requests包。

　　第4行：使用requests类库，以get的方式请求网址https://www.baidu.com，并将服务器返回的结果封装成一个对象，用变量resp来接收它。

　　第5行：一般可以根据状态码来判断是否请求成功，正常的状态码是200，异常状态码就很多了，比如404（找不到网页）、301（重定向）等。

　　第6行：打印网页的源码。注意，只是源码。不像是浏览器，在获取到源码之后，还会进一步地取请求源码中引用的图片等信息，如果有JS，浏览器还会执行JS，对页面显示的内容进行修改。使用requests进行请求，我们能够直接获取到的，只有最初始的网页源码。也正是因为这样，不加载图片、不执行JS等等，爬虫请求的速度会非常快。

　　代码很短吧？一行就完成了请求，可以，这很python。

　　现在，运行一下代码看看吧。

　　

　　箭头指向的是状态码，可以看到，200，请求正常。

　　被圈起来是网页的源码。
3.如何用python解析网页源码
网页源码我们拿到了，接下来就是要解析了。python解析网页源码有很多种方法，比如BeautifulSoup、正则、pyquery、xpath等。这里我简单介绍一下。
3.1 网页源码解析器
3.1.1 BeautifulSoup
这是我比较推荐的一款解析器，简单易用，容易理解。

　　但是使用bs4还需要安装另一个类库lxml，用来代替bs4默认的解析器。之所以这样做，是因为默认的那个实在太慢了，换用了lxml后，可以大幅度提升解析速度。
3.1.1.1 安装
命令行中输入以下指令并回车，安装bs4：
pip3 install beautifulsoup4



　　使用pip直接安装lxml会出错，所以要用些特别的方法。Windows用户的话，去百度搜一下lxml在Windows环境下的安装方法，网上有很多，我就不多说了（主要是嫌麻烦= =）。Ubuntu用户就很方便了，在终端里面输入以下指令并回车就行了：
apt-get install python-lxml


3.1.1.2 测试是否安装成功
进入python交互环境，引用bs4和lxml类库，不报错即安装成功。
import bs4
import lxml


3.1.2 正则
这个不用安装，标准库里带的就有。

　　正则的优点：①速度快 ②能够提取有些解析器提取不到的数据

　　正则的缺点：①不够直观，很难从面向对象的角度来考虑数据的提取 ②你得会写正则表达式

　　教程就不放了，善用百度嘛。正则一般用来满足特殊需求、以及提取其他解析器提取不到的数据，正常情况下我会用bs4，bs4无法满足就用正则。

　　当然了，如果你喜欢，全部用正则解析也是没问题的，你喜欢就好= =。
3.1.3 pyquery
这个解析器的语法和jQuery很相似，所以写过jQuery的同学用起来可能比较容易上手。国内有个dalao写的爬虫框架pyspider用的就是这个解析器。

　　如果没用过jQuery，那就在bs4和pyquery两个里面选一个学吧，一般情况下会一个就够了。
3.1.3.1 安装
pip3 install pyquery

3.1.3.2 测试
import pyquery

3.2 使用BeautifulSoup+lxml解析网页源码
接着上面的代码来，我们使用BeautifulSoup+lxml解析请求到的网页源码。

　　从百度的首页，可以通过点击跳转到很多其他页面，比如说下面圈起来的，点击都会跳转到新的页面：

　　

　　现在，我们想要用python获得从百度能够跳转到的页面的链接，该怎么做？

　　代码很简单，接着上面的写：
#coding=utf-8
import requests
from bs4 import BeautifulSoup

resp=requests.get('https://www.baidu.com') #请求百度首页
print(resp) #打印请求结果的状态码
print(resp.content) #打印请求到的网页源码

bsobj=BeautifulSoup(resp.content,'lxml') #将网页源码构造成BeautifulSoup对象，方便操作
a_list=bsobj.find_all('a') #获取网页中的所有a标签对象
for a in a_list:
    print(a.get('href')) #打印a标签对象的href属性，即这个对象指向的链接地址

首先，第3行，引入我们解析时要使用的类库，beautifulsoup4。

　　第9行，将网页的源码转化成了BeautifulSoup的对象，这样我们可以向操作DOM模型类似地去操作它。

　　第10行，从这个BeautifulSoup对象中，获取所有的a标签对象（大家应该知道a标签对象是什么吧，网页中的链接绝大多数都是a对象实现的），将他们组成一个列表，也就是a_list。

　　第11、12行，遍历这个列表，对于列表中的每一个a标签对象，获取它的属性href的值（href属性记录一个a标签指向的链接地址）。获取一个标签对象的属性，可以使用get（‘xx’）方法，比如a_tag是一个a标签对象，获取它的href的值，就是a_tag.get('href')，获取它的class信息可以用a_tag.get('class')，这将返回一个修饰该标签的class列表。

　　运行一下，可以看到，打印出了很多链接。

　　

　　这是个简单的例子，介绍如何开始一个简单爬虫，不涉及复杂操作（复杂的后面会上小项目，会介绍）。关于beautifulsoup的详细用法，请自行百度。
3.3 简单的保存数据的方法
保存数据的方法大概可以分为几类：保存文本、保存二进制文件（包括图片）、保存到数据库。保存二进制文件和保存到数据库后面会具体说，这里简单讲一下怎么保存到文本。

　　python里面操作文本相当的简单。现在，我将刚才提取出来的链接保存到一个名称为url.txt的文本里面去，将上面的代码稍作修改。
#coding=utf-8
import requests
from bs4 import BeautifulSoup

resp=requests.get('https://www.baidu.com') #请求百度首页
print(resp) #打印请求结果的状态码
print(resp.content) #打印请求到的网页源码

bsobj=BeautifulSoup(resp.content,'lxml') #将网页源码构造成BeautifulSoup对象，方便操作
a_list=bsobj.find_all('a') #获取网页中的所有a标签对象
text='' # 创建一个空字符串
for a in a_list:
    href=a.get('href') #获取a标签对象的href属性，即这个对象指向的链接地址
    text+=href+'\n' #加入到字符串中，并换行
with open('url.txt','w') as f: #在当前路径下，以写的方式打开一个名为'url.txt'，如果不存在则创建
    f.write(text) #将text里的数据写入到文本中

代码中注释写得很清楚了，就不多做解释了。值得一提的是，使用with…as…来打开文件，在操作完成后，会自动关闭文件，不用担心忘记关闭文件了，超级好用啊！

　　运行一下代码，可以发现，当前路径下多了个名为url.txt的文件。

　　

　　打开后，能够看到我们刚才提取出来的url。

　　
4.更多
虽然东西不多，但是写了挺长时间的。因为平时在一边上课，一边实习，时间真的不多，抽着时间一点点写的。后面我尽量加快速度写吧，当然了，尽量嘛，写得慢了的话……你顺着网线过来打我呀~

　　我也只是个菜鸟，文中错误的地方，欢迎拍砖~

Python是一款功能强大的脚本语言，具有丰富和强大的库，重要的是，它还具有很强的可读性，易用易学，非常适合编程初学者入门。以下是小编为你整理的python3.4爬虫入门教程
环境配置：下载Python并安装，安装完成后，配置windows的环境变量：打开高级系统设置，将Python的安装目录添加到系统变量path中。配置完成后，在cmd命令行，输入命令"Python"，出现Python版本号，即配置成功
教程学习：上网百度下载一份Python教程，进行学习。初学者入门的话，没必要整份教程看一遍，只需要将基础的语法及模块挑出学习，如：字符串、列表、字典、元组、文件及数据库的操作
上机实践：单纯地学习教程绝对是没法学好编程语言的，我们需要通过实践将理论知识转为实打实的技能。在学习的过程中，可以在Ulipad上尝试编写脚本，也可以将教程上的代码自己敲一遍。总之，一定要“多敲”
下载安装步骤
趁着在家有个干净的windows环境，我自己尝试从头配置Python+webdriver，公司的配置是前辈已经帮忙配好的。本文档在于帮助菜鸟扫盲。有些内容是引用虫师的
1.下载python，好吧官网有，直接exe安装吧少年，推荐下载py2.7，3.3不太稳定(说错别砍我，我很菜)
2.下载setuptools(python的基础包工具)，同样是exe 文件，默认会找到python 的安装路径，将安装到C:Python27Libsite-packages 目录下
3.下载pip，(python安装包管理工具)，我默认解压在了C:pip-1.3.1 目录下
4.打开命令提示符(开始---cmd 回车)进入C:pip-1.3.1目录下输入：
C:pip-1.3.1 > python setup.py install
(如果提示python 不是内部或外部命令!别急，去配置一下环境变量吧)
5.再切换到C:Python27Scripts 目录下输入：
C:Python27Scripts > easy_install pip
6、安装selenium，(下载地址： https://pypi.python.org/pypi/selenium )
如果是联网状态的话，可以直接在C:Python27Scripts 下输入命令安装：
C:Python27Scripts > pip install -U selenium
如果没联网(这个一般不太可能)，下载selenium 2.33.0 (目前的最新版本)
并解压把整个目录放到C:Python27Libsite-packages 目录下。
7、下载selenium 的服务端(https://code.google.com/p/selenium/)在页面的左侧
列表中找到
selenium-server-standalone-XXX.jar
对!就是这个东西，把它下载下来并解压;
在selenium-server-standalone-xxx.jar 目录下使用命令java -jar
selenium-server-standalone-xxx.jar 启动(如果打不开，查看是否端口被占用：
netstat -aon|findstr 4444)。
至此步骤完毕
接下来是一些注意事项，是我配置想启动的过程中遇到的问题，希望对你们有所帮助：
1.我写了个入门的python+webdriver脚本：
出现error：
Traceback (most recent call last): File "C:Python27Libaa.py", line 1, in from selenium import webdriverImportError: No module named selenium
解决方案：没有找到selenium，好吧他说selenium没装，但是我真的安装的啊。我勒个去。于是我把我之前selenium-2.35.0.tar删了，在线用pip命令操作安装selenium，发现用from selenium import webdriver还是报错，于是找啊找，参见该博客http://blog.sina.com.cn/s/blog_416544cb0101kzua.html
重启电脑，这里如果不重启，不生效，OK，这个重启电脑搞定这个问题
2.我相信很多人会去手写python脚本
请大家注意调用浏览器首字母要大写。。。(今天差点弄死我)，如:Firefox，Chrome,Ie
3.注意得把IEDriverServer跟chromedriver放到对应浏览器的安装目录下
配置浏览器的环境变量Path：如
Chrome:C:UserswyxAppDataLocalGoogleChromeApplication
4.在python的安装目录下也放IEDriverServer，chromedriver
Python入门
第一步：Python入门
这一阶段，你需要学习的知识点：
如果学习能力还不错的话，这一阶段，只需要一个多月的时间
教程如下：
Python入门教程完整版(懂中文就能学会)http://pan.baidu.com/s/1miwZ1WW
第二步：熟悉Scrapy各模块
教程简介：
(1)Scrapy的简介。
主要知识点：Scrapy的架构和运作流程。
(2)搭建开发环境：
主要知识点：Windows及Linux环境下Scrapy的安装。
(3)Scrapy Shell以及Scrapy Selectors的使用。
(4)使用Scrapy完成网站信息的爬取。
主要知识点：创建Scrapy项目(scrapy startproject)、定义提取的结构化数据(Item)、编写爬取网站的 Spider 并提取出结构化数据(Item)、编写 Item Pipelines 来存储提取到的Item(即结构化数据)。
教程下载地址：Scrapy教程 http://pan.baidu.com/s/1dF3qhFV
第三步：Django教程
教程简介：
(1)Django的简介。
主要知识点：MVC设计模式以及Django的MVT。
(2)搭建开发环境：
主要知识点：Linux的虚拟环境搭建和应用、Django的安装。
(3)利用Django框架完成简单的图书项目：
主要知识点：编写模型，使用API与数据库交互、使用Django的后台管理管理数据、通过视图接收请求，通过模型获
教程下载地址：Django教程 http://pan.baidu.com/s/1nvFlfU5
第四部：Python全栈教程
教程简介：
(1)HTTP协议的分析：
HTTP格式。
包含知识点：HTTP GET请求的格式、HTTP POST请求的格式、HTTP响应的格式。
(2)HTTP协议的使用(实现Web静态服务器)：
利用HTTP协议实现Web静态服务器。
包含知识点：浏览器首先向服务器发送HTTP请求、服务器向浏览器返回HTTP响应、使用类。
(3)服务器动态资源请求(实现Web动态服务器)：
利用WSGI实现Web动态服务器。
包含知识点：浏览器请求动态页面的过程介绍、WSGI的介绍、定义WSGI接口。
教程下载地址：
Python全栈教程 http://pan.baidu.com/s/1nvFlfU
逻辑思维能力强
众所周知，IT行业赚钱多，常加班，大部分为男生?为什么会是这种状态，就在于男生的逻辑思维能力强，学IT比较容易。假设一下：逻辑思维能力弱，这行代码写完了，不知道关联什么，下边代码不会写，那就傻眼啦!
数理专业
大学学习的数学、物理、化学、大数据分析等专业，来学习Python事半功倍，假以时日，你会在这个领域发光发亮!
本身从事编程行业
编程语言可以说是相通的，Java转Python容易转，C语言转Python也容易，Linux运维转Python更容易!喜爱编程，0基础不知道选择什么编程语言的人，Python是最适合的。
l自学能力强
没有基础，想要自学编程的可以选择Python，Python语言简单，但是要保证自己的自学能力强，自控力够，不要学习期间摸摸手机，看看电脑，静不下心来学一切也是白玩。网上有好多视频资源，自学还是可以的。

爬虫入门教程 -1

很想做一些爬虫的基础性的教程，来与大家共同分享我的一些小经验， 我将以我认为的方式为大家讲解网络爬虫，如果你没有编程基础，对网络爬虫有兴趣，开始可能稍微有一些小难度，不过我希望能给你带来一些帮助。对我来说同样也是相互学习。。

工具 ： 1 大家需要在电脑上安装Python3.x版本  我们以Python3 为例子讲解。安装方式百度一下按照步骤做就可以，安                            装时候遇到的问题也可以百度的到，你遇到的这些问题小白都遇到过，特别的正常

            2 关于IDE(集成开发环境)的选择 我建议大家使用pycham   至于什么是IDE。就是我们写代码的地方，它提供了  代码高                   亮，代码报错，代码的搜索等等非常方便的功能。

            3  我用的操作系统是liunx ,大家可以使用windows

            4  你可能用的是IE浏览器 ，看到这里我希望你能安装chrome 或者火狐浏览器

本套教程主要用的编程语言是Python  

第一节 认识网络爬虫

本节我主要是带领大家了解认识网络爬虫

什么是网络爬虫？

网络爬虫

除了百度百科所讲，通俗来讲，我平时浏览的页面大都是HTML页面，包括我们平时浏览的新闻，门户网站等都是将文字内容镶嵌在HTML代码中的，比如腾讯新闻的这篇文章：



 

爬虫要做的可以简单理解为利 用程序来获取我们需要的网络上的内容，包括文字，视频，图片等信息 称之为   数据。

你可能会说 真low 老子分分钟复制粘贴好几篇，辣鸡---##---。您说的有道理但是，你想如果是10w篇呢，甚至100w呢，你还分分钟复制粘贴吗，程序可以做到将这写数据下载下来或者是保存到数据库中这些--------- 

为什么要做网络爬虫？

数据  你感觉重要不重要？  "大数据时代"，获取数据方式有哪些？ 

企业产生的数据：百度搜索指数、腾讯公司业绩数据、阿里巴巴集团财务及运营数据、新浪微博微指数等...

数据平台购买数据：数据堂、国云数据市场、贵阳大数据交易所 等等

 

爬取网络数据：如果数据市场上没有需要的数据，或者价格太高不愿意购买，那么可以利用爬虫技术，抓取网站上的数据。

 

我们对于爬虫其实我们经常与它打交道，百度 谷歌，雅虎，等就是大爬虫， 他们有个响当当的名字------搜索引擎

搜索引擎可以说是爬虫的至高境界---  你修炼到这个境界今年是不可能了，当然明年也不肯可能。

你可能要问了，那百度为什么搜索的时候搜不到数据，都是官网，打开才可以进去，像搜索引擎不会像个人写的爬虫程序一样无脑，因为他们要遵循一个 协议： 如标注为nofollow的链接，或者是Robots协议。

这些协议注明了那些页面是爬虫可以访问的，哪些是不可以访问的。如：

 

淘宝网：https://www.taobao.com/robots.txt

腾讯网： http://www.qq.com/robots.txt

 

搜索引擎通过爬虫爬取到的网页，将数据存入原始页面数据库。其中的页面数据与用户浏览器得到的HTML是完全一样的。

搜索引擎蜘蛛在抓取页面时，也做一定的重复内容检测，一旦遇到访问权重很低的网站上有大量抄袭、采集或者复制的内容，很可能就不再爬行。

别激动 我们做的是小爬虫，也称聚焦爬虫，即你想爬哪些数据，找到网址，分析规则然后写程序取抓取数据，当然不同网站的难易程度是不一样的。

 

首先你要知道 当你点击一下百度，发生了什么，能把你想要的数据返回到你的电脑屏幕上

简单来说这段过程发生了以下四个步骤：


	
浏览器通过 DNS服务器 查找域名对应的 IP地址;
	
	

	
向 IP地址 对应的 Web服务器 发送请求;
	
	

	
Web服务器 响应请求，发回 HTML页面;
	
	

	
浏览器解析 HTML内容，并显示出来。
	
HTTP和HTTPS

HTTP协议（HyperText Transfer Protocol，超文本传输协议）：是一种发布和接收 HTML页面的方法。

HTTPS（Hypertext Transfer Protocol over Secure Socket Layer）简单讲是HTTP的安全版，在HTTP下加入SSL层。

SSL（Secure Sockets Layer 安全套接层）主要用于Web的安全传输协议，在传输层对网络连接进行加密，保障在Internet上数据传输的安全。

HTTP的端口号为80，
	
HTTPS的端口号为443
HTTP工作原理

网络爬虫抓取过程可以理解为模拟浏览器操作的过程。

浏览器的主要功能是向服务器发出请求，在浏览器窗口中展示您选择的网络资源，HTTP是一套计算机通过网络进行通信的规则

 

浏览器发送HTTP请求的过程：


	
当用户在浏览器的地址栏中输入一个URL地址并按回车键之后，浏览器会向HTTP服务器发送HTTP请求。  HTTP请求主要分为 Get 和 Post 两种方法。
	
	

	
当我们在浏览器输入URL http://www.baidu.com 的时候，浏览器发送一个Request请求去获取 http://www.baidu.com 的html文件，服务器把Response文件对象发送回给浏览器。
	
	

	
浏览器分析Response中的 HTML，发现其中引用了很多其他文件，比如Images文件，CSS文件，JS文件。 浏览器会自动再次发送Request去获取图片，CSS文件，或者JS文件等。
	
	

	
当所有的文件都下载成功后，网页会根据HTML语法结构，完整的显示出来了。
	
        URL（Uniform / Universal Resource Locator的缩写）：统一资源定位符，是用于完整地描述Internet上

HTTP请求主要分为Get和Post两类：


	
GET是从服务器上获取指定页面信息，POST是向服务器提交数据并获取页面信息。
	
	

	
GET请求参数都显示在URL上，服务器根据该请求所包含URL中的参数来产生响应内容。 "Get" 请求的参数 是URL的一部分。
	
	

	
POST请求参数在请求体当中，消息长度没有限制而且以隐式的方式进行发送，通常用来向HTTP服务器提交量比较大的数据（比如请求中包含许多参数或者文件上传操作等）。 "POST"请求的参数 不在URL中，而在请求体中。
	
get请求的参数都在网址里面包含，所以我们有时候看到一个网址特别长，后边带了一坨东西。post请求一般是用于表单提交，将账号密码以post的方式发送。

当你任意点开客户端与服务期的一次信息交互，你会看到它访问客户端携带的参数也就是头部信息：request headers （常用） 以及客户端的回应response headers

 

 



 

前边说过了，我们鼠标每点击一次，就是对服务器发送了一次请求，等待服务器给你响应

当我们打开一个网页，右键点击选择查看源代码是可以查看源代码的，点击审查元素 和检查元素，就可以对客户端与服务器之间的信息交流进行查看如图：

第一个箭头指向的位置  —点击一下，然后点击文章相应位置，它会指向代码中内容的位置，可以帮助我们查看数据在网页中的结构和位置

第二给箭头是网络  — 点击network ,重新刷新页面，你会看到客户端和服务器之间的数据来往，也是我们今后用的最多的

第三个箭头 是   —all是所有的数据来往，xhr一般ajax加载的数据会在这里面找到，js是js的一些请求，里面也有我们要的数据，少数

下边方框里面  分别是 name  status(状态码)  type  size  等     了解一下即可，状态  200是正常，其他异常状态码可以百度，size点击可以按大小排列 这个后边还是挺方便的

其他的我们后边在做详细的讲解，大家可以先找个网页尝试一下。（其中有不明白的 可以自行百度）

第一节课程到这里也就结束了 ，今天先带大家认识爬虫，做一个简单的了解，明天开始我们开始下一章了，对于Python基础不了解的同学，可以看廖雪峰老师的讲解   百度 廖雪峰Python

 



 

在这套教程中我们将逐步共同学习：

 

1. Python基础语法学习（基础知识）    #  这个我们暂时不讲

2. 对HTML页面的内容抓取（Crawl）

3. 对HTML页面的数据解析（Parse）

4. 动态HTML的处理/验证码的处理 

5. Scrapy框架

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Scrapy爬虫入门教程一 安装和基本使用 

Scrapy爬虫入门教程二 官方提供Demo 

Scrapy爬虫入门教程三 命令行工具介绍和示例 

Scrapy爬虫入门教程四 Spider（爬虫） 

Scrapy爬虫入门教程五 Selectors（选择器） 

Scrapy爬虫入门教程六 Items（项目） 

Scrapy爬虫入门教程七 Item Loaders（项目加载器） 

Scrapy爬虫入门教程八 交互式 shell 方便调试 

Scrapy爬虫入门教程九 Item Pipeline（项目管道） 

Scrapy爬虫入门教程十 Feed exports（导出文件） 

Scrapy爬虫入门教程十一 Request和Response（请求和响应） 

Scrapy爬虫入门教程十二 Link Extractors（链接提取器）

Scrapy爬虫入门教程十三 Settings（设置）

 

 

目录

Spider

class scrapy.spiders.Spider

Spider arguments

通用爬虫

CrawlSpider

XMLFeedSpider

CSVFeedSpider

SitemapSpider

 

Spider

爬虫是定义如何抓取某个网站（或一组网站）的类，包括如何执行抓取（即关注链接）以及如何从其网页中提取结构化数据（即抓取项目）。换句话说，Spider是您定义用于为特定网站（或在某些情况下，一组网站）抓取和解析网页的自定义行为的位置。

对于爬虫，循环经历这样的事情：


	
您首先生成用于抓取第一个URL的初始请求，然后指定要使用从这些请求下载的响应调用的回调函数。

	
第一个执行的请求通过调用 start_requests()（默认情况下）Request为在start_urls和中指定的URL生成的parse方法获取， 并且该方法作为请求的回调函数。
	
	

	
在回调函数中，您将解析响应（网页），并返回带有提取的数据，Item对象， Request对象或这些对象的可迭代的对象。这些请求还将包含回调（可能是相同的），然后由Scrapy下载，然后由指定的回调处理它们的响应。
	
	

	
在回调函数中，您通常使用选择器来解析页面内容 （但您也可以使用BeautifulSoup，lxml或您喜欢的任何机制），并使用解析的数据生成项目。
	
	
最后，从爬虫返回的项目通常将持久存储到数据库（在某些项目管道中）或使用Feed导出写入文件。
即使这个循环（或多或少）适用于任何种类的爬虫，有不同种类的默认爬虫捆绑到Scrapy中用于不同的目的。我们将在这里谈论这些类型。

class scrapy.spiders.Spider

这是最简单的爬虫，每个其他爬虫必须继承的爬虫（包括与Scrapy捆绑在一起的爬虫，以及你自己写的爬虫）。它不提供任何特殊功能。它只是提供了一个默认start_requests()实现，它从start_urlsspider属性发送请求，并parse 为每个结果响应调用spider的方法。

name 

定义此爬虫名称的字符串。爬虫名称是爬虫如何由Scrapy定位（和实例化），因此它必须是唯一的。但是，没有什么能阻止你实例化同一个爬虫的多个实例。这是最重要的爬虫属性，它是必需的。

如果爬虫抓取单个域名，通常的做法是在域后面命名爬虫。因此，例如，抓取的爬虫mywebsite.com通常会被调用 mywebsite。

注意 

在Python 2中，这必须是ASCII。

allowed_domains 

允许此爬虫抓取的域的字符串的可选列表，指定一个列表可以抓取，其它就不会抓取了。

start_urls 

当没有指定特定网址时，爬虫将开始抓取的网址列表。

custom_settings 

运行此爬虫时将从项目宽配置覆盖的设置字典。它必须定义为类属性，因为设置在实例化之前更新。

有关可用内置设置的列表，请参阅： 内置设置参考。

crawler 

此属性from_crawler()在初始化类后由类方法设置，并链接Crawler到此爬虫实例绑定到的对象。

Crawlers在项目中封装了很多组件，用于单个条目访问（例如扩展，中间件，信号管理器等）。有关详情，请参阅抓取工具API。

settings 

运行此爬虫的配置。这是一个 Settings实例，有关此主题的详细介绍，请参阅设置主题。

logger 

用Spider创建的Python记录器name。您可以使用它通过它发送日志消息，如记录爬虫程序中所述。

from_crawler（crawler，* args，** kwargs ） 

是Scrapy用来创建爬虫的类方法。

您可能不需要直接覆盖这一点，因为默认实现充当方法的代理，__init__()使用给定的参数args和命名参数kwargs调用它。

尽管如此，此方法 在新实例中设置crawler和settings属性，以便以后可以在爬虫程序中访问它们。

参数： 
	
crawler（Crawlerinstance） - 爬虫将绑定到的爬虫
		
args（list） - 传递给init()方法的参数
		
kwargs（dict） - 传递给init()方法的关键字参数
	
start_requests（） 

此方法必须返回一个可迭代的第一个请求来抓取这个爬虫。

有了start_requests()，就不写了start_urls，写了也没有用。

默认实现是：start_urls，但是可以复写的方法start_requests。 

例如，如果您需要通过使用POST请求登录来启动，您可以：

class MySpider(scrapy.Spider):
    name = 'myspider'

    def start_requests(self):
        return [scrapy.FormRequest("http://www.example.com/login",
                                   formdata={'user': 'john', 'pass': 'secret'},
                                   callback=self.logged_in)]

    def logged_in(self, response):
        # here you would extract links to follow and return Requests for
        # each of them, with another callback
        pass


make_requests_from_url(url) 

一种接收URL并返回Request 对象（或Request对象列表）进行抓取的方法。此方法用于在方法中构造初始请求 start_requests()，并且通常用于将URL转换为请求。

除非重写，此方法返回具有方法的Requests parse() 作为它们的回调函数，并启用dont_filter参数（Request有关更多信息，请参阅类）。

parse(response) 

这是Scrapy用于处理下载的响应的默认回调，当它们的请求没有指定回调时。

该parse方法负责处理响应并返回所抓取的数据或更多的URL。其他请求回调具有与Spider类相同的要求。

此方法以及任何其他请求回调必须返回一个可迭代的Request和dicts或Item对象。

参数： 
	
response（Response） - 解析的响应
	
log(message[, level, component]) 

包装器通过爬虫发送日志消息logger，保持向后兼容性。有关详细信息，请参阅 从Spider记录。

closed(reason) 

当爬虫关闭时召唤。此方法为spider_closed信号的signals.connect()提供了一个快捷方式。

让我们看一个例子：

import scrapy


class MySpider(scrapy.Spider):
    name = 'example.com'
    allowed_domains = ['jianshu.com']
    start_urls = [
        'http://www.jianshu.com/p/cc8d69ed5601',
        'http://www.jianshu.com/p/41322417e0be',
        'http://www.jianshu.com/p/6e8b207cf833',
    ]

    def parse(self, response):
        self.logger.info('A response from %s just arrived!', response.url)

从单个回调中返回多个请求和项：

import scrapy

class MySpider(scrapy.Spider):
    name = 'example.com'
    allowed_domains = ['example.com']
    start_urls = [
        'http://www.example.com/1.html',
        'http://www.example.com/2.html',
        'http://www.example.com/3.html',
    ]

    def parse(self, response):
        for h3 in response.xpath('//h3').extract():
            yield {"title": h3}

        for url in response.xpath('//a/@href').extract():
            yield scrapy.Request(url, callback=self.parse)

你可以直接使用start_requests()，而不是start_urls; 项目可以更加方便获取数据：

import scrapy
from myproject.items import MyItem

class MySpider(scrapy.Spider):
    name = 'example.com'
    allowed_domains = ['example.com']

    def start_requests(self):
        yield scrapy.Request('http://www.example.com/1.html', self.parse)
        yield scrapy.Request('http://www.example.com/2.html', self.parse)
        yield scrapy.Request('http://www.example.com/3.html', self.parse)

    def parse(self, response):
        for h3 in response.xpath('//h3').extract():
            yield MyItem(title=h3)

        for url in response.xpath('//a/@href').extract():
            yield scrapy.Request(url, callback=self.parse)

Spider arguments

爬虫可以接收修改其行为的参数。爬虫参数的一些常见用法是定义起始URL或将爬网限制到网站的某些部分，但它们可用于配置爬虫的任何功能。

Spider crawl参数使用该-a选项通过命令 传递。例如：

scrapy crawl myspider -a category=electronics

爬虫可以在他们的init方法中访问参数：

import scrapy

class MySpider(scrapy.Spider):
    name = 'myspider'

    def __init__(self, category=None, *args, **kwargs):
        super(MySpider, self).__init__(*args, **kwargs)
        self.start_urls = ['http://www.example.com/categories/%s' % category]
        # ...


默认的init方法将获取任何爬虫参数，并将它们作为属性复制到爬虫。上面的例子也可以写成如下：

import scrapy

class MySpider(scrapy.Spider):
    name = 'myspider'

    def start_requests(self):
        yield scrapy.Request('http://www.example.com/categories/%s' % self.category)

请记住，spider参数只是字符串。爬虫不会自己做任何解析。如果要从命令行设置start_urls属性，则必须将它自己解析为列表，使用像 ast.literal_eval 或json.loads之类的属性 ，然后将其设置为属性。否则，你会导致迭代一个start_urls字符串（一个非常常见的python陷阱），导致每个字符被看作一个单独的url。

有效的用例是设置使用的http验证凭据HttpAuthMiddleware 或用户代理使用的用户代理UserAgentMiddleware： 
scrapy crawl myspider -a http_user=myuser -a http_pass=mypassword -a user_agent=mybot

Spider参数也可以通过Scrapyd schedule.jsonAPI 传递。请参阅Scrapyd文档。

 

通用爬虫

Scrapy附带一些有用的通用爬虫，你可以使用它来子类化你的爬虫。他们的目的是为一些常见的抓取案例提供方便的功能，例如根据某些规则查看网站上的所有链接，从站点地图抓取或解析XML / CSV Feed。

对于在以下爬虫中使用的示例，我们假设您有一个TestItem在myproject.items模块中声明的项目：

import scrapy

class TestItem(scrapy.Item):
    id = scrapy.Field()
    name = scrapy.Field()
    description = scrapy.Field()


 

CrawlSpider

类 scrapy.spiders.CrawlSpider 

这是最常用的爬行常规网站的爬虫，因为它通过定义一组规则为下列链接提供了一种方便的机制。它可能不是最适合您的特定网站或项目，但它是足够通用的几种情况，所以你可以从它开始，根据需要覆盖更多的自定义功能，或只是实现自己的爬虫。

 

CrawlSpider这个爬虫还暴露了可覆盖的方法：

parse_start_url(response) 

对于start_urls响应调用此方法。它允许解析初始响应，并且必须返回Item对象，Request对象或包含任何对象的迭代器。

 

通过命令创建CrawlSpider

scrapy genspider -t crawl tencent tencent.com

 

LinkExtractors：

class scrapy.linkextractors.LinkExtractor

Link Extractors 的目的很简单: 提取链接｡

每个LinkExtractor有唯一的公共方法是 extract_links()，它接收一个 Response 对象，并返回一个 scrapy.link.Link 对象。

Link Extractors要实例化一次，并且 extract_links 方法会根据不同的 response 调用多次提取链接｡

class scrapy.linkextractors.LinkExtractor(
    allow = (),
    deny = (),
    allow_domains = (),
    deny_domains = (),
    deny_extensions = None,
    restrict_xpaths = (),
    tags = ('a','area'),
    attrs = ('href'),
    canonicalize = True,
    unique = True,
    process_value = None
)

主要参数：

allow：满足括号中“正则表达式”的值会被提取，如果为空，则全部匹配。
	
deny：与这个正则表达式(或正则表达式列表)不匹配的URL一定不提取。
	
allow_domains：会被提取的链接的domains。
	
deny_domains：一定不会被提取链接的domains。
	
restrict_xpaths：使用xpath表达式，和allow共同作用过滤链接。
 

除了从Spider继承的属性（你必须指定），这个类支持一个新的属性：

Rules：

在rules中包含一个或多个Rule对象，每个Rule对爬取网站的动作定义了特定操作。如果多个rule匹配了相同的链接，则根据规则在本集合中被定义的顺序，第一个会被使用。

 

Rule：抓取规则

class scrapy.spiders.Rule（link_extractor，callback = None，cb_kwargs = None，follow = None，process_links = None，process_request = None ） 

link_extractor是一个链接提取程序对象，它定义如何从每个爬网页面提取链接。

class scrapy.spiders.Rule(
        link_extractor, 
        callback = None, 
        cb_kwargs = None, 
        follow = None, 
        process_links = None, 
        process_request = None
)

link_extractor：是一个Link Extractor对象，用于定义需要提取的链接。
	
callback： 从link_extractor中每获取到链接时，参数所指定的值作为回调函数，该回调函数接受一个response作为其第一个参数。注意：当编写爬虫规则时，避免使用parse作为回调函数。由于CrawlSpider使用parse方法来实现其逻辑，如果覆盖了 parse方法，crawl spider将会运行失败。
	
cb_kwargs 是包含要传递给回调函数的关键字参数的dict。
	
follow：是一个布尔(boolean)值，指定了根据该规则从response提取的链接是否需要跟进。 如果callback为None，follow 默认设置为True ，否则默认为False。
	
process_links：指定该spider中哪个的函数将会被调用，从link_extractor中获取到链接列表时将会调用该函数。该方法主要用来过滤。
	
process_request：指定该spider中哪个的函数将会被调用， 该规则提取到每个request时都会调用该函数。 (用来过滤request)
 

CrawlSpider抓取爬虫示例

现在让我们来看一个CrawlSpider的例子：

import scrapy
from scrapy.spiders import CrawlSpider, Rule
from scrapy.linkextractors import LinkExtractor

class MySpider(CrawlSpider):
    name = 'example.com'
    allowed_domains = ['example.com']
    start_urls = ['http://www.example.com']

    rules = (
        # Extract links matching 'category.php' (but not matching 'subsection.php')
        # and follow links from them (since no callback means follow=True by default).
        Rule(LinkExtractor(allow=('category\.php', ), deny=('subsection\.php', ))),

        # Extract links matching 'item.php' and parse them with the spider's method parse_item
        Rule(LinkExtractor(allow=('item\.php', )), callback='parse_item'),
    )

    def parse_item(self, response):
        self.logger.info('Hi, this is an item page! %s', response.url)
        item = scrapy.Item()
        item['id'] = response.xpath('//td[@id="item_id"]/text()').re(r'ID: (\d+)')
        item['name'] = response.xpath('//td[@id="item_name"]/text()').extract()
        item['description'] = response.xpath('//td[@id="item_description"]/text()').extract()
        return item

这个爬虫会开始抓取example.com的主页，收集类别链接和项链接，用parse_item方法解析后者。对于每个项目响应，将使用XPath从HTML中提取一些数据，并将Item使用它填充。

 

XMLFeedSpider

class scrapy.spiders.XMLFeedSpider 

XMLFeedSpider设计用于通过以特定节点名称迭代XML订阅源来解析XML订阅源。迭代器可以选自：iternodes，xml和html。iternodes为了性能原因，建议使用迭代器，因为xml和迭代器html一次生成整个DOM为了解析它。但是，html当使用坏标记解析XML时，使用作为迭代器可能很有用。

要设置迭代器和标记名称，必须定义以下类属性：


	
iterator 

	定义要使用的迭代器的字符串。它可以是：

	
'iternodes' - 基于正则表达式的快速迭代器
		
'html'- 使用的迭代器Selector。请记住，这使用DOM解析，并且必须加载所有DOM在内存中，这可能是一个大饲料的问题
		
'xml'- 使用的迭代器Selector。请记住，这使用DOM解析，并且必须加载所有DOM在内存中，这可能是一个大饲料的问题 

		它默认为：'iternodes'。
	
itertag 

一个具有要迭代的节点（或元素）的名称的字符串。示​​例： 
itertag = 'product'

namespaces 

定义该文档中将使用此爬虫处理的命名空间的元组列表。在 与将用于自动注册使用的命名空间 的方法。(prefix, uri)prefixuriregister_namespace()

然后，您可以在属性中指定具有命名空间的itertag 节点。

例：

class YourSpider(XMLFeedSpider):

    namespaces = [('n', 'http://www.sitemaps.org/schemas/sitemap/0.9')]
    itertag = 'n:url'
    # ...

除了这些新的属性，这个爬虫也有以下可重写的方法：

adapt_response(response) 

一种在爬虫开始解析响应之前，在响应从爬虫中间件到达时立即接收的方法。它可以用于在解析之前修改响应主体。此方法接收响应并返回响应（它可以是相同的或另一个）。

parse_node(response, selector) 

对于与提供的标记名称（itertag）匹配的节点，将调用此方法。接收Selector每个节点的响应和 。覆盖此方法是必需的。否则，你的爬虫将不工作。此方法必须返回一个Item对象，一个 Request对象或包含任何对象的迭代器。

process_results(response, results) 

对于由爬虫返回的每个结果（Items or Requests），将调用此方法，并且它将在将结果返回到框架核心之前执行所需的任何最后处理，例如设置项目ID。它接收结果列表和产生那些结果的响应。它必须返回结果列表（Items or Requests）。

XMLFeedSpider示例

这些爬虫很容易使用，让我们看一个例子：

from scrapy.spiders import XMLFeedSpider
from myproject.items import TestItem

class MySpider(XMLFeedSpider):
    name = 'example.com'
    allowed_domains = ['example.com']
    start_urls = ['http://www.example.com/feed.xml']
    iterator = 'iternodes'  # This is actually unnecessary, since it's the default value
    itertag = 'item'

    def parse_node(self, response, node):
        self.logger.info('Hi, this is a <%s> node!: %s', self.itertag, ''.join(node.extract()))

        item = TestItem()
        item['id'] = node.xpath('@id').extract()
        item['name'] = node.xpath('name').extract()
        item['description'] = node.xpath('description').extract()
        return item

基本上我们做的是创建一个爬虫，从给定的下载一个start_urls，然后遍历每个item标签，打印出来，并存储一些随机数据Item。

 

CSVFeedSpider

class scrapy.spiders.CSVF 

这个爬虫非常类似于XMLFeedSpider，除了它迭代行，而不是节点。在每次迭代中调用的方法是parse_row()。

delimiter 

CSV文件中每个字段的带分隔符的字符串默认为’,’（逗号）。

quotechar 

CSV文件中每个字段的包含字符的字符串默认为’”’（引号）。

headers 

文件CSV Feed中包含的行的列表，用于从中提取字段。

parse_row(response, row) 

使用CSV文件的每个提供（或检测到）标头的键接收响应和dict（表示每行）。这个爬虫还给予机会重写adapt_response和process_results方法的前和后处理的目的。

CSVFeedSpider示例

让我们看一个类似于前一个例子，但使用 CSVFeedSpider：

from scrapy.spiders import CSVFeedSpider
from myproject.items import TestItem

class MySpider(CSVFeedSpider):
    name = 'example.com'
    allowed_domains = ['example.com']
    start_urls = ['http://www.example.com/feed.csv']
    delimiter = ';'
    quotechar = "'"
    headers = ['id', 'name', 'description']

    def parse_row(self, response, row):
        self.logger.info('Hi, this is a row!: %r', row)

        item = TestItem()
        item['id'] = row['id']
        item['name'] = row['name']
        item['description'] = row['description']
        return item

SitemapSpider

class scrapy.spiders.SitemapSpider 

SitemapSpider允许您通过使用Sitemaps发现网址来抓取网站。

它支持嵌套Sitemap和从robots.txt发现Sitemap网址 。

sitemap_urls 

指向您要抓取的网址的网站的网址列表。

您还可以指向robots.txt，它会解析为从中提取Sitemap网址。

sitemap_rules 

元组列表其中：(regex, callback)

regex是与从Sitemap中提取的网址相匹配的正则表达式。 regex可以是一个str或一个编译的正则表达式对象。
	
callback是用于处理与正则表达式匹配的url的回调。callback可以是字符串（指示蜘蛛方法的名称）或可调用的。
例如： 
sitemap_rules = [('/product/', 'parse_product')]

规则按顺序应用，只有匹配的第一个将被使用。 

如果省略此属性，则会在parse回调中处理在站点地图中找到的所有网址。

sitemap_follow 

应遵循的网站地图的正则表达式列表。这只适用于使用指向其他Sitemap文件的Sitemap索引文件的网站。

默认情况下，将跟踪所有网站地图。

sitemap_alternate_links 

指定是否url应遵循一个备用链接。这些是在同一个url块中传递的另一种语言的同一网站的链接。

例如：

<url>
    <loc>http://example.com/</loc>
    <xhtml:link rel="alternate" hreflang="de" href="http://example.com/de"/>
</url>

使用sitemap_alternate_linksset，这将检索两个URL。随着 sitemap_alternate_links禁用，只有http://example.com/将进行检索。

默认为sitemap_alternate_links禁用。

SitemapSpider示例

最简单的示例：使用parse回调处理通过站点地图发现的所有网址 ：

from scrapy.spiders import SitemapSpider

class MySpider(SitemapSpider):
    sitemap_urls = ['http://www.example.com/sitemap.xml']

    def parse(self, response):
        pass # ... scrape item here ...


使用某个回调处理一些网址，并使用不同的回调处理其他网址：

from scrapy.spiders import SitemapSpider

class MySpider(SitemapSpider):
    sitemap_urls = ['http://www.example.com/sitemap.xml']
    sitemap_rules = [
        ('/product/', 'parse_product'),
        ('/category/', 'parse_category'),
    ]

    def parse_product(self, response):
        pass # ... scrape product ...

    def parse_category(self, response):
        pass # ... scrape category ...


关注robots.txt文件中定义的sitemaps，并且只跟踪其网址包含/sitemap_shop以下内容的Sitemap ：

from scrapy.spiders import SitemapSpider

class MySpider(SitemapSpider):
    sitemap_urls = ['http://www.example.com/robots.txt']
    sitemap_rules = [
        ('/shop/', 'parse_shop'),
    ]
    sitemap_follow = ['/sitemap_shops']

    def parse_shop(self, response):
        pass # ... scrape shop here ...

将SitemapSpider与其他来源网址结合使用：

from scrapy.spiders import SitemapSpider

class MySpider(SitemapSpider):
    sitemap_urls = ['http://www.example.com/robots.txt']
    sitemap_rules = [
        ('/shop/', 'parse_shop'),
    ]

    other_urls = ['http://www.example.com/about']

    def start_requests(self):
        requests = list(super(MySpider, self).start_requests())
        requests += [scrapy.Request(x, self.parse_other) for x in self.other_urls]
        return requests

    def parse_shop(self, response):
        pass # ... scrape shop here ...

    def parse_other(self, response):
        pass # ... scrape other here ...

 

转载自：https://blog.csdn.net/Inke88/article/details/60573507