了编写一个Java爬虫,你需要了解以下几个步骤:
下面是一个基本的Java爬虫代码示例,它使用Jsoup解析器和URLConnection库连接到目标网站并提取标题和链接信息:
import java.io.IOException;
import java.net.URL;
import java.net.URLConnection;
import java.util.Scanner;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;
public class SimpleWebCrawler {
public static void main(String[] args) {
String url = "https://www.example.com/";
try {
URLConnection conn = new URL(url).openConnection();
conn.addRequestProperty("User-Agent", "Mozilla/5.0");
Scanner scanner = new Scanner(conn.getInputStream());
String html = scanner.useDelimiter("\\Z").next();
scanner.close();
Document doc = Jsoup.parse(html);
Elements links = doc.select("a[href]");
for (Element link : links) {
System.out.println(link.attr("href") + " - " + link.text());
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
Jsoup是一款用于解析HTML和XML文档的Java库。它提供了类似于jQuery的语法来操作文档,使得解析和处理文档变得非常简单。
以下是Jsoup解析器的一些常用功能:
总之,Jsoup是一款非常实用的HTML和XML解析器,可以帮助Java开发者快速、简单地解析和处理HTML文档,使得爬虫开发变得更加容易。
使用Jsoup解析器需要先将其添加到项目的依赖中。可以通过Maven或者Gradle来添加依赖。
例如,使用Maven添加Jsoup的依赖:
<dependency>
<groupId>org.jsoup</groupId>
<artifactId>jsoup</artifactId>
<version>1.14.3</version>
</dependency>
添加依赖之后,就可以在Java代码中使用Jsoup了。以下是使用Jsoup解析器获取HTML文档中所有链接的示例代码:
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;
public class JsoupExample {
public static void main(String[] args) {
String html = "<html><head><title>Jsoup Example</title></head>"
+ "<body><p>Jsoup is a Java library for working with real-world HTML.</p>"
+ "<a href=\"http://example.com\">Example</a></body></html>";
Document doc = Jsoup.parse(html); // 将HTML字符串解析为文档对象
Elements links = doc.select("a"); // 获取所有的链接元素
for (Element link : links) {
String href = link.attr("href"); // 获取链接的URL地址
String text = link.text(); // 获取链接的文本内容
System.out.println(href + ": " + text);
}
}
}
以上代码使用Jsoup将HTML字符串解析为文档对象,然后使用选择器语法获取所有的链接元素,并输出它们的URL地址和文本内容。
除此之外,Jsoup还有很多其他的功能,例如修改元素、过滤HTML文档等等,可以根据具体需求灵活运用。
1.获取网页的 Title:
Document doc = Jsoup.connect("http://example.com/").get();
String title = doc.title();
2.获取指定标签的文本内容:
Element element = doc.select("div.content").first();
String text = element.text();
3.获取指定属性的值:
Element element = doc.select("img").first();
String src = element.attr("src");
4.过滤 HTML 标签:
String html = "<p>这是一段 <b>加粗</b> 的文本。</p>";
String text = Jsoup.parse(html).text();
5.修改 HTML 内容:
Element element = doc.select("div.content").first();
element.append("<p>这是新增的文本内容。</p>");
6.提取网页中的链接:
Elements links = doc.select("a[href]");
for (Element link : links) {
String href = link.attr("href");
System.out.println(href);
}
7.提取网页中的图片:
Elements imgs = doc.select("img[src~=(?i)\\.(png|jpe?g|gif)]");
for (Element img : imgs) {
String src = img.attr("src");
System.out.println(src);
}
这些只是 Jsoup 解析器的常见用法之一。Jsoup 还有更多的功能,如解析 XML、处理表单、处理 Cookie 等,大家可以自己去了解!
有不足之处大家也可以在评论区指出!
言
在当前数据爆发的时代,数据分析行业势头强劲,越来越多的人涉足数据分析领域。进入领域最想要的就是获取大量的数据来为自己的分析提供支持,但是如何获取互联网中的有效信息?这就促进了“爬虫”技术的飞速发展。
网络爬虫(又被称为网页蜘蛛,网络机器人,在FOAF社区中间,更经常的称为网页追逐者),是一种按照一定的规则,自动地抓取万维网信息的程序或者脚本。
传统爬虫从一个或若干初始网页的URL开始,获得初始网页上的URL,在抓取网页的过程中,不断从当前页面上抽取新的URL放入队列,直到满足系统的一定停止条件。聚焦爬虫的工作流程较为复杂,需要根据一定的网页分析算法过滤与主题无关的链接,保留有用的链接并将其放入等待抓取的URL队列。然后,它将根据一定的搜索策略从队列中选择下一步要抓取的网页URL,并重复上述过程,直到达到系统的某一条件时停止。
另外,所有被爬虫抓取的网页将会被系统存贮,进行一定的分析、过滤,并建立索引,以便之后的查询和检索;对于聚焦爬虫来说,这一过程所得到的分析结果还可能对以后的抓取过程给出反馈和指导。
笔者是爬虫初学者,通过这篇综述来记录一下自己的心得体会。
以下为文章主要内容:
1. 初见爬虫
使用Python中的Requests第三方库。在Requests的7个主要方法中,最常使用的就是get()方法,通过该方法构造一个向服务器请求资源的Request对象,结果返回一个包含服务器资源的额Response对象。通过Response对象则可以获取请求的返回状态、HTTP响应的字符串即URL对应的页面内容、页面的编码方式以及页面内容的二进制形式。
在了解get()方法之前我们先了解一下HTTP协议,通过对HTTP协议来理解我们访问网页这个过程到底都进行了哪些工作。
1.1 浅析HTTP协议
超文本传输协议(HTTP,HyperText Transfer Protocol)是互联网上应用最为广泛的一种网络协议。所有的www文件都必须遵守这个标准。HTTP协议主要有几个特点:
支持客户/服务器模式
简单快捷:客服向服务器发出请求,只需要传送请求方法和路径。请求方法常用的有GET, HEAD, POST。每种方法规定了客户与服务器联系的类型不同。由于HTTP协议简单,使得HTTP服务器的程序规模小,因而通信速度快。
灵活:HTTP允许传输任意类型的数据对象。
无连接:无连接的含义是限制每次连接请求只处理一个请求。服务器处理完客户的请求,收到客户的应答后即断开连接,这种方式可以节省传输时间。
无状态:HTTP协议是无状态协议。无状态是指协议对于事物处理没有记忆能力。缺少状态意味着如果后续处理需要前面的信息,则它必须重传,这样可能导致每次连接传送的数据量增大,另一方面,在服务器不需要先前信息时它的应答就较快。
下面通过一张图我们来了解一下访问网页的过程都发生了什么:
1. 首先浏览器拿到网址之后先将主机名解析出来。如 http://www.baidu.com/index.html 则会将主机名www.baidu.com 解析出来。
2. 查找ip,根据主机名,会首先查找ip,首先查询hosts文件,成功则返回对应的ip地址,如果没有查询到,则去DNS服务器查询,成功就返回ip,否则会报告连接错误。
3. 发送http请求,浏览器会把自身相关信息与请求相关信息封装成HTTP请求 消息发送给服务器。
4. 服务器处理请求,服务器读取HTTP请求中的内容,在经过解析主机,解析站点名称,解析访问资源后,会查找相关资源,如果查找成功,则返回状态码200,失败就会返回大名鼎鼎的404了,在服务器监测到请求不在的资源后,可以按照程序员设置的跳转到别的页面。所以有各种有个性的404错误页面。
5. 服务器返回HTTP响应,浏览器得到返回数据后就可以提取数据,然后调用解析内核进行翻译,最后显示出页面。之后浏览器会对其引用的文件比如图片,css,js等文件不断进行上述过程,直到所有文件都被下载下来之后,网页就会显示出来。
HTTP请求,http请求由三部分组成,分别是:请求行、消息报头、请求正文。请求方法(所有方法全为大写)有多种,各个方法的解释如下:
GET 请求获取Request-URI所标识的资源
POST 在Request-URI所标识的资源后附加新的数据
HEAD 请求获取由Request-URI所标识的资源的响应消息报头
PUT 请求服务器存储一个资源,并用Request-URI作为其标识
DELETE 请求服务器删除Request-URI所标识的资源
TRACE 请求服务器回送收到的请求信息,主要用于测试或诊断
CONNECT 保留将来使用
OPTIONS 请求查询服务器的性能,或者查询与资源相关的选项和需求
GET方法应用举例:在浏览器的地址栏中输入网址的方式访问网页时,浏览器采用GET方法向服务器获取资源,eg:GET /form.html HTTP/1.1 (CRLF)
HTTP响应也是由三个部分组成,分别是:状态行、消息报头、响应正文。
状态行格式如下:HTTP-Version Status-Code Reason-Phrase CRLF,其中,HTTP-Version表示服务器HTTP协议的版本;Status-Code表示服务器发回的响应状态代码;Reason-Phrase表示状态代码的文本描述。
状态代码有三位数字组成,第一个数字定义了响应的类别,且有五种可能取值:
1xx:指示信息--表示请求已接收,继续处理
2xx:成功--表示请求已被成功接收、理解、接受
3xx:重定向--要完成请求必须进行更进一步的操作
4xx:客户端错误--请求有语法错误或请求无法实现
5xx:服务器端错误--服务器未能实现合法的请求
常见状态代码、状态描述、说明:
200 OK //客户端请求成功
400 Bad Request //客户端请求有语法错误,不能被服务器所理解
401 Unauthorized //请求未经授权,这个状态代码必须和WWW-Authenticate报头域一起使用
403 Forbidden //服务器收到请求,但是拒绝提供服务
404 Not Found //请求资源不存在,eg:输入了错误的URL
500 Internal Server Error //服务器发生不可预期的错误
503 Server Unavailable //服务器当前不能处理客户端的请求,一段时间后可能恢复正常。
eg:HTTP/1.1 200 OK (CRLF)
详细的HTTP协议可以参考这篇文章:
http://www.cnblogs.com/li0803/archive/2008/11/03/1324746.html
前面我们了解了HTTP协议,那么我们访问网页的过程,那么网页在是什么样子的。爬虫眼中的网页又是什么样子的。
网是静态的,但爬虫是动态的,所以爬虫的基本思想就是沿着网页(蜘蛛网的节点)上的链接的爬取有效信息。当然网页也有动态(一般用PHP或ASP等写成,例如用户登陆界面就是动态网页)的,但如果一张蛛网摇摇欲坠,蜘蛛会感到不那么安稳,所以动态网页的优先级一般会被搜索引擎排在静态网页的后面。
知道了爬虫的基本思想,那么具体如何操作呢?这得从网页的基本概念说起。一个网页有三大构成要素,分别是html文件、css文件和JavaScript文件。如果把一个网页看做一栋房子,那么html相当于房子外壳;css相当于地砖涂料,美化房子外观内饰;JavaScript则相当于家具电器浴池等,增加房子的功能。从上述比喻可以看出,html才是网页的根本,毕竟地砖颜料在市场上也有,家具电器都可以露天摆设,而房子外壳才是独一无二的。
下面就是一个简单网页的例子:
而在爬虫眼里,这个网页是这样的:
因此网页实质上就是超文本(hypertext),网页上的所有内容都是在形如“<>...</>”这样的标签之内的。如果我们要搜集网页上的所有超链接,只需寻找所有标签中前面是"href="的字符串,并查看提取出来的字符串是否以"http"(超文本转换协议,https表示安全的http协议)开头即可。如果超链接不以"http"开头,那么该链接很可能是网页所在的本地文件或者ftp或smtp(文件或邮件转换协议),应该过滤掉。
在Python中我们使用Requests库中的方法来帮助我们实现对网页的请求,从而达到实现爬虫的过程。
1.2 Requests库的7个主要方法:
最常用的方法get用来实现一个简单的小爬虫,通过示例代码展示:
2. Robots协议
Robots协议(也称为爬虫协议、机器人协议等)的全称是“网络爬虫排除标准”(Robots Exclusion Protocol),网站通过Robots协议告诉搜索引擎哪些页面可以抓取,哪些页面不能抓取。通过几个小例子来解读一下robots.txt中的内容,robots.txt默认放置于网站的根目录小,对于一个没有robots.txt文件的网站,默认是允许所有爬虫获取其网站内容的。
我们对于robots协议的理解,如果是商业利益我们是必须要遵守robots协议内容,否则会承担相应的法律责任。当只是个人玩转网页、练习则是建议遵守,提高自己编写爬虫的友好程度。
3. 网页解析
BeautifulSoup尝试化平淡为神奇,通过定位HTML标签来格式化和组织复杂的网络信息,用简单易用的Python对象为我们展示XML结构信息。
BeautifulSoup是解析、遍历、维护“标签树”的功能库。
3.1 BeautifulSoup的解析器
BeautifulSoup通过以上四种解析器来对我们获取的网页内容进行解析。使用官网的例子来看一下解析结果:
首先获取以上的一段HTML内容,我们通过BeautifulSoup解析之后,并且输出解析后的结果来对比一下:
通过解析的网页内容,我们就可以使用BeautifulSoup中的方法来轻而易举的获得网页中的主要信息:
3.2 BeautifulSoup类的基本元素
3.3 BeautifulSoup的遍历功能
遍历分为上行遍历、下行遍历、平行遍历三种。
下行遍历:
上行遍历:
平行遍历:
4. 正则表达式
正则表达式,又称规则表达式。(英语:Regular Expression,在代码中常简写为regex、regexp或RE),计算机科学的一个概念。正则表通常被用来检索、替换那些符合某个模式(规则)的文本。
笔者也是初学正则表达式,感觉自己不能简洁清晰的讲述正则表达式,建议参考网上的教程( http://deerchao.net/tutorials/regex/regex.htm#mission )图文并茂,详细讲解了正则表达式。
通过掌握正则表示也可以帮助我们获取网页中的主要信息。
5. 爬虫框架Scrapy
Scrapy是Python开发的一个快速,高层次的屏幕抓取和web抓取框架,用于抓取web站点并从页面中提取结构化的数据。Scrapy用途广泛,可以用于数据挖掘、监测和自动化测试。
Scrapy吸引人的地方在于它是一个框架,任何人都可以根据需求方便的修改。它也提供了多种类型爬虫的基类,如BaseSpider、sitemap爬虫等,最新版本又提供了web2.0爬虫的支持。
5.1 Scrapy爬虫框架结构
Engine: 控制所有模块之间的数据流、根据条件触发事件。
Downloader: 根据请求下载网页
Scheduler: 对所有爬去请求进行调度管理
Spider: 解析Downloader返回的响应、产生爬取项、产生额外的爬去请求。
Item Pipelines: 以流水线方式处理Spider产生的爬取项、可能包括清理、检验和查重爬取项中的HTML数据、将数据存储到数据库。
5.2 数据流
1. 引擎打开一个网站(open a domain),找到处理该网站的Spider并向该spider请求第一个要爬取的URL(s)。
2. 引擎从Spider中获取到第一个要爬取的URL并在调度器(Scheduler)以Request调度。
3. 引擎向调度器请求下一个要爬取的URL。
4. 调度器返回下一个要爬取的URL给引擎,引擎将URL通过下载中间件(请求(request)方向)转发给下载器(Downloader)。
5. 一旦页面下载完毕,下载器生成一个该页面的Response,并将其通过下载中间件(返回(response)方向)发送给引擎。
6. 引擎从下载器中接收到Response并通过Spider中间件(输入方向)发送给Spider处理。
7. Spider处理Response并返回爬取到的Item及(跟进的)新的Request给引擎。
8. 引擎将(Spider返回的)爬取到的Item给Item Pipeline,将(Spider返回的)Request给调度器。
9. (从第二步)重复直到调度器中没有更多地request,引擎关闭该网站。
6. 分布式爬虫
6.1 多线程爬虫
在爬取数据量小的情况下,我们使用的都是串行下载网页的,只有前一次下载完成之后才会启动新的下载。数据量小的情况下尚可应对。但面对大型网站就会显得性能不足,如果我们可以同时下载多个网页,那么下载时间将会得到显著改善。
我们将串行下载爬虫扩展成并行下载。需要注意的是如果滥用这一功能,多线程爬虫请求内容过快,可能会造成服务器过载,或是IP地址被封禁。为了避免这一问题,我们的爬虫就要设置一个delay标识,用于设定请求同一域名时的最小时间间隔。
在Python中实现多线程是比较简单的,Python中的thread模块是比较底层的模块,Python的threading模块是对thread做了一些封装,可以更加方便的被使用。
简要的看一下thread模块中含函数和常量:
Thread中常用的函数和对象:
一般来说,使用线程有两种模式, 一种是创建线程要执行的函数, 把这个函数传递进Thread对象里,让它来执行. 另一种是直接从Thread继承,创建一个新的class,把线程执行的代码放到这个新的class里。
实现多进程的代码和例子参考:
http://www.jianshu.com/p/86b8e78c418a
6.2 多进程爬虫
Python中的多线程其实并不是真正的多线程,并不能做到充分利用多核CPU资源。
如果想要充分利用,在python中大部分情况需要使用多进程,那么这个包就叫做 multiprocessing。
借助它,可以轻松完成从单进程到并发执行的转换。multiprocessing支持子进程、通信和共享数据、执行不同形式的同步,提供了Process、Queue、Pipe、Lock等组件。
Process基本使用:
在multiprocessing中,每一个进程都用一个Process类来表示。首先看下它的API:
target 表示调用对象,你可以传入方法的名字
args 表示被调用对象的位置参数元组,比如target是函数a,他有两个参数m,n,那么args就传入(m, n)即可
kwargs 表示调用对象的字典
name 是别名,相当于给这个进程取一个名字
group 分组,实际上不使用
我们先用一个实例来感受一下:
最简单的创建Process的过程如上所示,target传入函数名,args是函数的参数,是元组的形式,如果只有一个参数,那就是长度为1的元组。
然后调用start()方法即可启动多个进程了。
另外你还可以通过 cpu_count() 方法还有 active_children() 方法获取当前机器的 CPU 核心数量以及得到目前所有的运行的进程。
通过一个实例来感受一下:
运行结果:
通过开启多个进程实现爬虫,会大大缩减爬取信息的速度。详细介绍请参考:
http://cuiqingcai.com/3335.html
7. 异步网站数据采集
在收集网页信息时我们会遇到,网页的加载模型为瀑布流形式,页面URL没有改变,但依然可以加载出内容。这时候就需要我们分析网页中JavaScript中的一些代码,从中获取我们所需要的数据。
面对使用JS渲染的页面推荐使用PhantomJS,无界面,可脚本编程的WebKit浏览器。参考 : http://cuiqingcai.com/2577.html
Selenium一种自动化测试工具。可以方便实现Web界面测试。使用PhantomJS渲染解析JS,Selenium用来驱动以及写与Python的对接,然后Python进行后期处理。参考: http://cuiqingcai.com/2599.html
8. 爬虫的存储
在刚开始接触爬虫的时候,我们习惯将小的爬虫结果输出在命令行中,看着命令行中一行行的数据显得颇有成就感,但是随着数据的增多,并且需要进行数据分析时,将数据打印到命令行就不是办法了。为了可以远程使用大部分网络爬虫,我们还是需要将收集的数据存储起来。
8.1 媒体文件
媒体文件常见的有两种存储方式:只获取URL链接,或者直接把源文件下载下来。但是推荐使用第一种方式。优点如下:
爬虫运行的更快,耗费的流量更少,因为只存储链接,不需要下载文件。
节省存储空间,因为不需要存储媒体文件。
存储URL的代码更容易写,也不需要实现文件下载代码
不下载文件能够降低目标主机服务器的负载。
当然这样做也存在一些缺点:
内嵌在我们网页中的外站链接被称为盗链,使用这种链接会让我们麻烦不断,每个网站都会实施防盗链措施。
因为你的链接文件在别人的服务器,所以我们的应用就要跟着别人的节奏运行了。
盗链很容易改变,如果把盗链放在博客等地,被对方发现很可能被恶搞。或者是把URL存储备用,等到用的时候发现链接已经过期了。
在现实中网络浏览器不仅可以访问HTML页面并切换页面,它们也会下载访问页面上的所有资源。下载文件会让我们的爬虫看起来更像人在浏览页面。
8.2 把数据存储到CSV
CSV是存储表格数据的常用文件格式。每行都用一个换行符分隔,列与列之间用逗号分隔。Python中的CSV库可以非常简单的修改CSV文件,也可以从零开始创建一个CSV文件:
我们可以使用csv模块提供的功能将爬虫获取的信息存入csv文件中。
8.3 MySQL
对于大量的爬虫数据,并且在之后我们需要反复用来筛选分析的数据,我们选择存储在数据库中。
MySQL是目前最受欢迎的开源关系型数据库管理系统,它是一种非常灵活、稳定、功能齐全的DBMS,许多顶级网站都在用它,YouTube、Twitter、Facebook等。
Python中没有内置的MySQL支持工具,不过,有很多开源的库可以用来与MySQL做交互,最为出名的就是PyMySQL。
结合上述过程将爬虫获取到的数据存入数据库中。
9. 爬虫的常见技巧
9.1 模拟登录
目前的网站多是采用cookie跟踪用户是否已经登录的信息。一旦网站验证了你的登录权证,它就会保存在你浏览器的cookie中,里面通常包含一个服务器生成的命令牌、登录有效时限和状态跟踪信息。网站会把这个cookie当作信息验证的证据,在我们浏览网站的每个页面时出示给服务器。
通过Chrome等浏览器自带的开发者工具,我们从Network中获取请求网页的头部和表单,在Header中我们就可以查看cookie中存储的登录信息,我们可以通过Scrapy设置请求网页的头部信息,并将cookie存储在本地,来实现模拟登陆的效果。详细的操作可以查看博客:http://www.jianshu.com /p/b7f41df6202d
9.2 网页验证码
简单的说,验证码就是一张图片,图片上有字符串。网站是如何实现的呢?有WEB基础的人可能会知道,每个浏览器基本都有cookie,作为这次回话的唯一标示。每次访问网站,浏览器都会把这个cookie发送给服务器。验证码就是和这个cookie绑定到一起的。如何理解呢?举个例子,现在有网站W,有A和B两个人,同时访问W,W给A返回的验证码是X,给B返回的验证码是Y,这两个验证码都是正确的,但是如果A输入了B的验证码,肯定验证不通过。那服务器是怎么区分A和B呢,就是用到的cookie。再举个例子,有些网站你登录一次之后,下次继续访问可能就自动登陆了,也是用cookie来标示唯一身份的,如果清除了cookie也就无法自动登陆了。
对于一些简单的验证码我们可以通过机器识别,但是对于一些人眼都很难识别的验证码就只能寻找更加复杂的技术了。简单的验证码识别过程就是对验证码图片的一个处理过程。
灰度图转换,可以结合opencv中的imread方法。
图像去噪(均值滤波器、高斯滤波器等等)。
图像二值化(这个过程中验证码中的字符串已经成为黑色的,底色为白色)。
使用图像识别方式,识别图中的字符串达到识别验证码的目的。
推荐阅读:
http://www.jianshu.com/p/dd699561671b
http://www.cnblogs.com/hearzeus/p/5166299.html(上篇)
http://www.cnblogs.com/hearzeus/p/5226546.html(下篇)
9.3 爬虫代理池
由于笔者是个爬虫初学者也没有用到过这么复杂的技术,不过笔者在爬虫的过程中的确是体会了被封IP地址的痛苦。所以推荐大家有精力的可以来学习并完成一个。
推荐阅读:
https://www.zhihu.com/question/47464143
10. 防爬虫
由于暴力爬虫会对网站的服务器产生很大的压力,所以各个网站对爬虫都有限制,大多数网站会定义robots.txt.文件可以让爬虫了解该网站的限制。限制是作为建议给出。但是爬虫前检查该文件可以最小化我们的爬虫被封禁的可能。
一篇关于反爬虫的文章: https://segmentfault.com/a/ 1190000005840672 (来自携程技术中心)
11. 学习资料
推荐书籍:
《Python网络数据采集》 陶俊杰、陈小莉 译
《用Python写网络爬虫》 李斌 译
推荐博客:
崔庆才得个人博客,有大量关于爬虫的文章,而且讲解的比较细致。
http://cuiqingcai.com/
数据挖掘与入门实战微信公众号分享的一篇文章,《Python开源爬虫项目代码:抓取淘宝、京东、QQ、知网数据》,有十九个开源的爬虫项目,可以给大家提供参考。https://github.com/hlpassion/blog/issues/6
推荐视频:
网易云课堂,例子清晰,可以跟做。
http://study.163.com/course/introduction.htm?courseId=1002794001#/courseDetail
Python网络爬虫与信息提取
http://www.icourse163.org/course/BIT-1001870001
- 更多精彩请关注清华-青岛数据科学研究院微信官方公众平台“THU数据派”
强烈建议:请在电脑的陪同下,阅读本文。本文以实战为主,阅读过程如稍有不适,还望多加练习。
本文的实战内容有:
网络爬虫,也叫网络蜘蛛(Web Spider)。它根据网页地址(URL)爬取网页内容,而网页地址(URL)就是我们在浏览器中输入的网站链接。比如:https://www.baidu.com/,它就是一个URL。
在讲解爬虫内容之前,我们需要先学习一项写爬虫的必备技能:审查元素(如果已掌握,可跳过此部分内容)。
在浏览器的地址栏输入URL地址,在网页处右键单击,找到检查,如下图所示:(不同浏览器的叫法不同,Chrome浏览器叫做检查,Firefox浏览器叫做查看元素,但是功能都是相同的)
我们可以看到,右侧出现了一大推代码,这些代码就叫做HTML。什么是HTML?举个容易理解的例子:我们的基因决定了我们的原始容貌,服务器返回的HTML决定了网站的原始容貌。
为啥说是原始容貌呢?因为人可以整容啊!扎心了,有木有?那网站也可以"整容"吗?可以!请看下图:
我能有这么多钱吗?显然不可能。我是怎么给网站"整容"的呢?就是通过修改服务器返回的HTML信息。我们每个人都是"整容大师",可以修改页面信息。我们在页面的哪个位置点击审查元素,浏览器就会为我们定位到相应的HTML位置,进而就可以在本地更改HTML信息。
再举个小例子:我们都知道,使用浏览器"记住密码"的功能,密码会变成一堆小黑点,是不可见的。可以让密码显示出来吗?可以,只需给页面"动个小手术"!以淘宝为例,在输入密码框处右键,点击检查。
可以看到,浏览器为我们自动定位到了相应的HTML位置。将下图中的password属性值改为text属性值(直接在右侧代码处修改):
就这样,浏览器"记住的密码"显现出来了:
说这么多,什么意思呢?浏览器就是作为客户端从服务器端获取信息,然后将信息解析,并展示给我们的。我们可以在本地修改HTML信息,为网页"整容",但是我们修改的信息不会回传到服务器,服务器存储的HTML信息不会改变。刷新一下界面,页面还会回到原本的样子。这就跟人整容一样,我们能改变一些表面的东西,但是不能改变我们的基因。
网络爬虫的第一步就是根据URL,获取网页的HTML信息。在Python3中,可以使用urllib.request和requests进行网页爬取。
requests库强大好用,所以本文使用requests库获取网页的HTML信息。requests库的github地址:https://github.com/requests/requests
(1)requests安装
在学习使用requests库之前,我们需要在电脑中安装好requests库。在cmd中,使用如下指令安装requests库:
使用pip和easy_install都可以安装,二选一即可。
(2)简单实例
安装好requests库之后,我们先来大体浏览一下requests库的基础方法:
官方中文教程地址:
http://docs.python-requests.org/zh_CN/latest/user/quickstart.html
requests库的开发者为我们提供了详细的中文教程,查询起来很方便。本文不会对其所有内容进行讲解,摘取其部分使用到的内容,进行实战说明。
首先,让我们看下requests.get()方法,它用于向服务器发起GET请求,不了解GET请求没有关系。我们可以这样理解:get的中文意思是得到、抓住,那这个requests.get()方法就是从服务器得到、抓住数据,也就是获取数据。让我们看一个例子(以 www.gitbook.cn为例)来加深理解:
# -*- coding:UTF-8 -*-
import requests
if __name__ == '__main__':
target = 'http://gitbook.cn/'
req = requests.get(url=target)
print(req.text)
requests.get()方法必须设置的一个参数就是url,因为我们得告诉GET请求,我们的目标是谁,我们要获取谁的信息。我们将GET请求获得的响应内容存放到req变量中,然后使用req.text就可以获得HTML信息了。运行结果如下:
左侧是我们程序获得的结果,右侧是我们在www.gitbook.cn网站审查元素获得的信息。我们可以看到,我们已经顺利获得了该网页的HTML信息。这就是一个最简单的爬虫实例,可能你会问,我只是爬取了这个网页的HTML信息,有什么用呢?客官稍安勿躁,接下来进入我们的实战正文。
实战内容由简单到复杂,难度逐渐增加,但均属于入门级难度。下面开始我们的第一个实战内容:网络小说下载。
(1)实战背景
小说网站《笔趣看》URL:http://www.biqukan.com/
《笔趣看》是一个盗版小说网站,这里有很多起点中文网的小说,该网站小说的更新速度稍滞后于起点中文网正版小说的更新速度。并且该网站只支持在线浏览,不支持小说打包下载。因此,本次实战就是从该网站爬取并保存一本名为《一念永恒》的小说,该小说是耳根正在连载中的一部玄幻小说。PS:本实例仅为交流学习,支持耳根大大,请上起点中文网订阅。
(2)小试牛刀
我们先看下《一念永恒》小说的第一章内容,URL:http://www.biqukan.com/1_1094/5403177.html
用已经学到的知识获取HTML信息试一试,编写代码如下:
# -*- coding:UTF-8 -*-
import requests
if __name__ == '__main__':
target = 'http://www.biqukan.com/1_1094/5403177.html'
req = requests.get(url=target)
print(req.text)
运行代码,可以看到如下结果:
可以看到,我们很轻松地获取了HTML信息。但是,很显然,很多信息是我们不想看到的,我们只想获得如右侧所示的正文内容,我们不关心那些看着眼晕的英文字母。如何把正文内容从这些众多的HTML信息中提取出来呢?这就是本小节实战的主要内容。
(3)Beautiful Soup
爬虫的第一步,获取整个网页的HTML信息,我们已经完成。接下来就是爬虫的第二步,解析HTML信息,提取我们感兴趣的内容。对于本小节的实战,我们感兴趣的内容就是文章的正文。提取的方法有很多,例如使用正则表达式、Xpath、Beautiful Soup等。对于初学者而言,最容易理解,并且使用简单的方法就是使用Beautiful Soup提取感兴趣内容。
Beautiful Soup的安装方法和requests一样,使用如下指令安装(也是二选一):
一个强大的第三方库,都会有一个详细的官方文档。我们很幸运,Beautiful Soup也是有中文的官方文档。URL:
http://beautifulsoup.readthedocs.io/zh_CN/latest/
同理,我会根据实战需求,讲解Beautiful Soup库的部分使用方法,更详细的内容,请查看官方文档。
现在,我们使用已经掌握的审查元素方法,查看一下我们的目标页面,你会看到如下内容:
不难发现,文章的所有内容都放在了一个名为div的“东西下面”,这个"东西"就是html标签。HTML标签是HTML语言中最基本的单位,HTML标签是HTML最重要的组成部分。不理解,没关系,我们再举个简单的例子:
html标签就像一个个“口袋”,每个“口袋”都有自己的特定功能,负责存放不同的内容。显然,上述例子中的div标签下存放了我们关心的正文内容。这个div标签是这样的:
<div id="content", class="showtxt">
细心的朋友可能已经发现,除了div字样外,还有id和class。id和class就是div标签的属性,content和showtxt是属性值,一个属性对应一个属性值。这东西有什么用?它是用来区分不同的div标签的,因为div标签可以有很多,我们怎么加以区分不同的div标签呢?就是通过不同的属性值。
仔细观察目标网站一番,我们会发现这样一个事实:class属性为showtxt的div标签,独一份!这个标签里面存放的内容,是我们关心的正文部分。
知道这个信息,我们就可以使用Beautiful Soup提取我们想要的内容了,编写代码如下:
# -*- coding:UTF-8 -*-
from bs4 import BeautifulSoup
import requests
if __name__ == "__main__":
target = 'http://www.biqukan.com/1_1094/5403177.html'
req = requests.get(url = target)
html = req.text
bf = BeautifulSoup(html)
texts = bf.find_all('div', class_ = 'showtxt')
print(texts)
在解析html之前,我们需要创建一个Beautiful Soup对象。BeautifulSoup函数里的参数就是我们已经获得的html信息。然后我们使用find_all方法,获得html信息中所有class属性为showtxt的div标签。find_all方法的第一个参数是获取的标签名,第二个参数class_是标签的属性,为什么不是class,而带了一个下划线呢?因为python中class是关键字,为了防止冲突,这里使用class_表示标签的class属性,class_后面跟着的showtxt就是属性值了。看下我们要匹配的标签格式:
<div id="content", class="showtxt">
这样对应的看一下,是不是就懂了?可能有人会问了,为什么不是find_all('div', id = 'content', class_ = 'showtxt')?这样其实也是可以的,属性是作为查询时候的约束条件,添加一个class_='showtxt'条件,我们就已经能够准确匹配到我们想要的标签了,所以我们就不必再添加id这个属性了。运行代码查看我们匹配的结果:
我们可以看到,我们已经顺利匹配到我们关心的正文内容,但是还有一些我们不想要的东西。比如div标签名,br标签,以及各种空格。怎么去除这些东西呢?我们继续编写代码:
# -*- coding:UTF-8 -*-
from bs4 import BeautifulSoup
import requests
if __name__ == "__main__":
target = 'http://www.biqukan.com/1_1094/5403177.html'
req = requests.get(url = target)
html = req.text
bf = BeautifulSoup(html)
texts = bf.find_all('div', class_ = 'showtxt')
print(texts[0].text.replace('\xa0'*8,'\n\n'))
find_all匹配的返回的结果是一个列表。提取匹配结果后,使用text属性,提取文本内容,滤除br标签。随后使用replace方法,剔除空格,替换为回车进行分段。 在html中是用来表示空格的。replace('\xa0'*8,'\n\n')就是去掉下图的八个空格符号,并用回车代替:
程序运行结果如下:
可以看到,我们很自然的匹配到了所有正文内容,并进行了分段。我们已经顺利获得了一个章节的内容,要想下载正本小说,我们就要获取每个章节的链接。我们先分析下小说目录:
URL:http://www.biqukan.com/1_1094/
通过审查元素,我们发现可以发现,这些章节都存放在了class属性为listmain的div标签下,选取部分html代码如下:
<div class="listmain">
<dl>
<dt>《一念永恒》最新章节列表</dt>
<dd><a href="/1_1094/15932394.html">第1027章 第十道门</a></dd>
<dd><a href="/1_1094/15923072.html">第1026章 绝伦道法!</a></dd>
<dd><a href="/1_1094/15921862.html">第1025章 长生灯!</a></dd>
<dd><a href="/1_1094/15918591.html">第1024章 一目晶渊</a></dd>
<dd><a href="/1_1094/15906236.html">第1023章 通天道门</a></dd>
<dd><a href="/1_1094/15903775.html">第1022章 四大凶兽!</a></dd>
<dd><a href="/1_1094/15890427.html">第1021章 鳄首!</a></dd>
<dd><a href="/1_1094/15886627.html">第1020章 一触即发!</a></dd>
<dd><a href="/1_1094/15875306.html">第1019章 魁祖的气息!</a></dd>
<dd><a href="/1_1094/15871572.html">第1018章 绝望的魁皇城</a></dd>
<dd><a href="/1_1094/15859514.html">第1017章 我还是恨你!</a></dd>
<dd><a href="/1_1094/15856137.html">第1016章 从来没有世界之门!</a></dd>
<dt>《一念永恒》正文卷</dt>
<dd><a href="/1_1094/5386269.html">外传1 柯父。</a></dd>
<dd><a href="/1_1094/5386270.html">外传2 楚玉嫣。</a></dd>
<dd><a href="/1_1094/5386271.html">外传3 鹦鹉与皮冻。</a></dd>
<dd><a href="/1_1094/5403177.html">第一章 他叫白小纯</a></dd>
<dd><a href="/1_1094/5428081.html">第二章 火灶房</a></dd>
<dd><a href="/1_1094/5433843.html">第三章 六句真言</a></dd>
<dd><a href="/1_1094/5447905.html">第四章 炼灵</a></dd>
</dl>
</div>
在分析之前,让我们先介绍一个概念:父节点、子节点、孙节点。<div>和</div>限定了<div>标签的开始和结束的位置,他们是成对出现的,有开始位置,就有结束位置。我们可以看到,在<div>标签包含<dl>标签,那这个<dl>标签就是<div>标签的子节点,<dl>标签又包含<dt>标签和<dd>标签,那么<dt>标签和<dd>标签就是<div>标签的孙节点。有点绕?那你记住这句话:谁包含谁,谁就是谁儿子!
他们之间的关系都是相对的。比如对于<dd>标签,它的子节点是<a>标签,它的父节点是<dl>标签。这跟我们人是一样的,上有老下有小。
看到这里可能有人会问,这有好多<dd>标签和<a>标签啊!不同的<dd>标签,它们是什么关系啊?显然,兄弟姐妹喽!我们称它们为兄弟结点。
好了,概念明确清楚,接下来,让我们分析一下问题。我们看到每个章节的名字存放在了<a>标签里面。<a>标签还有一个href属性。这里就不得不提一下<a> 标签的定义了,<a> 标签定义了一个超链接,用于从一张页面链接到另一张页面。<a> 标签最重要的属性是 href 属性,它指示链接的目标。
我们将之前获得的第一章节的URL和<a> 标签对比看一下:
http://www.biqukan.com/1_1094/5403177.html
<a href="/1_1094/5403177.html">第一章 他叫白小纯</a>
不难发现,<a> 标签中href属性存放的属性值/1_1094/5403177.html是章节URLhttp://www.biqukan.com/1_1094/5403177.html的后半部分。其他章节也是如此!那这样,我们就可以根据<a> 标签的href属性值获得每个章节的链接和名称了。
总结一下:小说每章的链接放在了class属性为listmain的<div>标签下的<a>标签中。链接具体位置放在html->body->div->dl->dd->a的href属性中。先匹配class属性为listmain的<div>标签,再匹配<a>标签。编写代码如下:
# -*- coding:UTF-8 -*-
from bs4 import BeautifulSoup
import requests
if __name__ == "__main__":
target = 'http://www.biqukan.com/1_1094/'
req = requests.get(url = target)
html = req.text
div_bf = BeautifulSoup(html)
div = div_bf.find_all('div', class_ = 'listmain')
print(div[0])
还是使用find_all方法,运行结果如下:
很顺利,接下来再匹配每一个<a>标签,并提取章节名和章节文章。如果我们使用Beautiful Soup匹配到了下面这个<a>标签,如何提取它的href属性和<a>标签里存放的章节名呢?
<a href="/1_1094/5403177.html">第一章 他叫白小纯</a>
方法很简单,对Beautiful Soup返回的匹配结果a,使用a.get('href')方法就能获取href的属性值,使用a.string就能获取章节名,编写代码如下:
# -*- coding:UTF-8 -*-
from bs4 import BeautifulSoup
import requests
if __name__ == "__main__":
server = 'http://www.biqukan.com/'
target = 'http://www.biqukan.com/1_1094/'
req = requests.get(url = target)
html = req.text
div_bf = BeautifulSoup(html)
div = div_bf.find_all('div', class_ = 'listmain')
a_bf = BeautifulSoup(str(div[0]))
a = a_bf.find_all('a')
for each in a:
print(each.string, server + each.get('href'))
因为find_all返回的是一个列表,里边存放了很多的<a>标签,所以使用for循环遍历每个<a>标签并打印出来,运行结果如下。
最上面匹配的一千多章的内容是最新更新的12章节的链接。这12章内容会和下面的重复,所以我们要滤除,除此之外,还有那3个外传,我们也不想要。这些都简单地剔除就好。
(3)整合代码
每个章节的链接、章节名、章节内容都有了。接下来就是整合代码,将获得内容写入文本文件存储就好了。编写代码如下:
# -*- coding:UTF-8 -*-
from bs4 import BeautifulSoup
import requests, sys
"""
类说明:下载《笔趣看》网小说《一念永恒》
Parameters:
无
Returns:
无
Modify:
2017-09-13
"""
class downloader(object):
def __init__(self):
self.server = 'http://www.biqukan.com/'
self.target = 'http://www.biqukan.com/1_1094/'
self.names = [] #存放章节名
self.urls = [] #存放章节链接
self.nums = 0 #章节数
"""
函数说明:获取下载链接
Parameters:
无
Returns:
无
Modify:
2017-09-13
"""
def get_download_url(self):
req = requests.get(url = self.target)
html = req.text
div_bf = BeautifulSoup(html)
div = div_bf.find_all('div', class_ = 'listmain')
a_bf = BeautifulSoup(str(div[0]))
a = a_bf.find_all('a')
self.nums = len(a[15:]) #剔除不必要的章节,并统计章节数
for each in a[15:]:
self.names.append(each.string)
self.urls.append(self.server + each.get('href'))
"""
函数说明:获取章节内容
Parameters:
target - 下载连接(string)
Returns:
texts - 章节内容(string)
Modify:
2017-09-13
"""
def get_contents(self, target):
req = requests.get(url = target)
html = req.text
bf = BeautifulSoup(html)
texts = bf.find_all('div', class_ = 'showtxt')
texts = texts[0].text.replace('\xa0'*8,'\n\n')
return texts
"""
函数说明:将爬取的文章内容写入文件
Parameters:
name - 章节名称(string)
path - 当前路径下,小说保存名称(string)
text - 章节内容(string)
Returns:
无
Modify:
2017-09-13
"""
def writer(self, name, path, text):
write_flag = True
with open(path, 'a', encoding='utf-8') as f:
f.write(name + '\n')
f.writelines(text)
f.write('\n\n')
if __name__ == "__main__":
dl = downloader()
dl.get_download_url()
print('《一年永恒》开始下载:')
for i in range(dl.nums):
dl.writer(dl.names[i], '一念永恒.txt', dl.get_contents(dl.urls[i]))
sys.stdout.write(" 已下载:%.3f%%" % float(i/dl.nums) + '\r')
sys.stdout.flush()
print('《一年永恒》下载完成')
很简单的程序,单进程跑,没有开进程池。下载速度略慢,喝杯茶休息休息吧。代码运行效果如下图所示:
(1)实战背景
已经会爬取文字了,是不是感觉爬虫还是蛮好玩的呢?接下来,让我们进行一个进阶实战,了解一下反爬虫。
URL:https://unsplash.com/
看一看这些优美的壁纸,这个网站的名字叫做Unsplash,免费高清壁纸分享网是一个坚持每天分享高清的摄影图片的站点,每天更新一张高质量的图片素材,全是生活中的景象作品,清新的生活气息图片可以作为桌面壁纸也可以应用于各种需要的环境。
看到这么优美的图片,我的第一反应就是想收藏一些,作为知乎文章的题图再好不过了。每张图片我都很喜欢,批量下载吧,不多爬,就下载50张好了。
(2)实战进阶
我们已经知道了每个html标签都有各自的功能。<a>标签存放一下超链接,图片存放在哪个标签里呢?html规定,图片统统给我放到<img>标签中!既然这样,我们截取就Unsplash网站中的一个<img>标签,分析一下:
<img alt="Snow-capped mountain slopes under blue sky" src="https://images.unsplash.com/photo-1428509774491-cfac96e12253?dpr=1&auto=compress,format&fit=crop&w=360&h=240&q=80&cs=tinysrgb&crop=" class="cV68d" style="width: 220px; height: 147px;">
可以看到,<img>标签有很多属性,有alt、src、class、style属性,其中src属性存放的就是我们需要的图片保存地址,我们根据这个地址就可以进行图片的下载。
那么,让我们先捋一捋这个过程:
我们信心满满地按照这个思路爬取Unsplash试一试,编写代码如下:
# -*- coding:UTF-8 -*-
import requests
if __name__ == '__main__':
target = 'https://unsplash.com/'
req = requests.get(url=target)
print(req.text)
按照我们的设想,我们应该能找到很多<img>标签。但是我们发现,除了一些<script>标签和一些看不懂的代码之外,我们一无所获,一个<img>标签都没有!跟我们在网站审查元素的结果完全不一样,这是为什么?
答案就是,这个网站的所有图片都是动态加载的!网站有静态网站和动态网站之分,上一个实战爬取的网站是静态网站,而这个网站是动态网站,动态加载有一部分的目的就是为了反爬虫。
对于什么是动态加载,你可以这样理解:
我们知道化妆术学的好,贼厉害,可以改变一个人的容貌。相应的,动态加载用的好,也贼厉害,可以改变一个网站的容貌。
动态网站使用动态加载常用的手段就是通过调用JavaScript来实现的。怎么实现JavaScript动态加载,我们不必深究,我们只要知道,动态加载的JavaScript脚本,就像化妆术需要用的化妆品,五花八门。有粉底、口红、睫毛膏等等,它们都有各自的用途。动态加载的JavaScript脚本也一样,一个动态加载的网站可能使用很多JavaScript脚本,我们只要找到负责动态加载图片的JavaScript脚本,不就找到我们需要的链接了吗?
对于初学者,我们不必看懂JavaScript执行的内容是什么,做了哪些事情,因为我们有强大的抓包工具,它自然会帮我们分析。这个强大的抓包工具就是Fiddler:
URL:http://www.telerik.com/fiddler
PS:也可以使用浏览器自带的Networks,但是我更推荐这个软件,因为它操作起来更高效。
安装方法很简单,傻瓜式安装,一直下一步即可,对于经常使用电脑的人来说,应该没有任何难度。
这个软件的使用方法也很简单,打开软件,然后用浏览器打开我们的目标网站,以Unsplash为例,抓包结果如下:
我们可以看到,上图左侧红框处是我们的GET请求的地址,就是网站的URL,右下角是服务器返回的信息,我们可以看到,这些信息也是我们上一个程序获得的信息。这个不是我们需要的链接,我们继续往下看。
我们发现上图所示的就是一个JavaScript请求,看右下侧服务器返回的信息是一个json格式的数据。这里面,就有我们需要的内容。我们局部放大看一下:
这是Fiddler右侧的信息,上面是请求的Headers信息,包括这个Javascript的请求地 址:http://unsplash.com/napi/feeds/home,其他信息我们先不管,我们看看下面的内容。里面有很多图片的信息,包括图片的id,图片的大小,图片的链接,还有下一页的地址。这个脚本以json格式存储传输的数据,json格式是一种轻量级的数据交换格式,起到封装数据的作用,易于人阅读和编写,同时也易于机器解析和生成。这么多链接,可以看到图片的链接有很多,根据哪个链接下载图片呢?先别急,让我们继续分析:
在这个网站,我们可以按这个按钮进行图片下载。我们抓包分下下这个动作,看看发送了哪些请求。
https://unsplash.com/photos/1PrQ2mHW-Fo/download?force=true
https://unsplash.com/photos/JX7nDtafBcU/download?force=true
https://unsplash.com/photos/HCVbP3zqX4k/download?force=true
通过Fiddler抓包,我们发现,点击不同图片的下载按钮,GET请求的地址都是不同的。但是它们很有规律,就是中间有一段代码是不一样的,其他地方都一样。中间那段代码是不是很熟悉?没错,它就是我们之前抓包分析得到json数据中的照片的id。我们只要解析出每个照片的id,就可以获得图片下载的请求地址,然后根据这个请求地址,我们就可以下载图片了。那么,现在的首要任务就是解析json数据了。
json格式的数据也是分层的。可以看到next_page里存放的是下一页的请求地址,很显然Unsplash下一页的内容,也是动态加载的。在photos下面的id里,存放着图片的id,这个就是我们需要获得的图片id号。
怎么编程提取这些json数据呢?我们也是分步完成:
编写代码,尝试获取json数据:
# -*- coding:UTF-8 -*-
import requests
if __name__ == '__main__':
target = 'http://unsplash.com/napi/feeds/home'
req = requests.get(url=target)
print(req.text)
很遗憾,程序报错了,问题出在哪里?通过错误信息,我们可以看到SSL认证错误,SSL认证是指客户端到服务器端的认证。一个非常简单的解决这个认证错误的方法就是设置requests.get()方法的verify参数。这个参数默认设置为True,也就是执行认证。我们将其设置为False,绕过认证不就可以了?
有想法就要尝试,编写代码如下:
# -*- coding:UTF-8 -*-
import requests
if __name__ == '__main__':
target = 'http://unsplash.com/napi/feeds/home'
req = requests.get(url=target, verify=False)
print(req.text)
认证问题解决了,又有新问题了:
可以看到,我们GET请求又失败了,这是为什么?这个网站反爬虫的手段除了动态加载,还有一个反爬虫手段,那就是验证Request Headers。接下来,让我们分析下这个Requests Headers:
我截取了Fiddler的抓包信息,可以看到Requests Headers里又很多参数,有Accept、Accept-Encoding、Accept-Language、DPR、User-Agent、Viewport-Width、accept-version、Referer、x-unsplash-client、authorization、Connection、Host。它们都是什么意思呢?
专业的解释能说的太多,我挑重点:
Unsplash是根据哪个参数反爬虫的呢?根据我的测试,是authorization。我们只要通过程序手动添加这个参数,然后再发送GET请求,就可以顺利访问了。怎么什么设置呢?还是requests.get()方法,我们只需要添加headers参数即可。编写代码如下:
# -*- coding:UTF-8 -*-
import requests
if __name__ == '__main__':
target = 'http://unsplash.com/napi/feeds/home'
headers = {'authorization':'your Client-ID'}
req = requests.get(url=target, headers=headers, verify=False)
print(req.text)
headers参数值是通过字典传入的。记得将上述代码中your Client-ID换成诸位自己抓包获得的信息。代码运行结果如下:
皇天不负有心人,可以看到我们已经顺利获得json数据了,里面有next_page和照片的id。接下来就是解析json数据。根据我们之前分析可知,next_page放在了json数据的最外侧,照片的id放在了photos->id里。我们使用json.load()方法解析数据,编写代码如下:
# -*- coding:UTF-8 -*-
import requests, json
if __name__ == '__main__':
target = 'http://unsplash.com/napi/feeds/home'
headers = {'authorization':'your Client-ID'}
req = requests.get(url=target, headers=headers, verify=False)
html = json.loads(req.text)
next_page = html['next_page']
print('下一页地址:',next_page)
for each in html['photos']:
print('图片ID:',each['id'])
解析json数据很简单,跟字典操作一样,就是字典套字典。json.load()里面的参数是原始的json格式的数据。程序运行结果如下:
图片的ID已经获得了,再通过字符串处理一下,就生成了我们需要的图片下载请求地址。根据这个地址,我们就可以下载图片了。下载方式,使用直接写入文件的方法。
(3)整合代码
每次获取链接加一个1s延时,因为人在浏览页面的时候,翻页的动作不可能太快。我们要让我们的爬虫尽量友好一些。
# -*- coding:UTF-8 -*-
import requests, json, time, sys
from contextlib import closing
class get_photos(object):
def __init__(self):
self.photos_id = []
self.download_server = 'https://unsplash.com/photos/xxx/download?force=trues'
self.target = 'http://unsplash.com/napi/feeds/home'
self.headers = {'authorization':'your Client-ID'}
"""
函数说明:获取图片ID
Parameters:
无
Returns:
无
Modify:
2017-09-13
"""
def get_ids(self):
req = requests.get(url=self.target, headers=self.headers, verify=False)
html = json.loads(req.text)
next_page = html['next_page']
for each in html['photos']:
self.photos_id.append(each['id'])
time.sleep(1)
for i in range(4):
req = requests.get(url=next_page, headers=self.headers, verify=False)
html = json.loads(req.text)
next_page = html['next_page']
for each in html['photos']:
self.photos_id.append(each['id'])
time.sleep(1)
"""
函数说明:图片下载
Parameters:
无
Returns:
无
Modify:
2017-09-13
"""
def download(self, photo_id, filename):
headers = {'User-Agent':'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/61.0.3163.79 Safari/537.36'}
target = self.download_server.replace('xxx', photo_id)
with closing(requests.get(url=target, stream=True, verify = False, headers = self.headers)) as r:
with open('%d.jpg' % filename, 'ab+') as f:
for chunk in r.iter_content(chunk_size = 1024):
if chunk:
f.write(chunk)
f.flush()
if __name__ == '__main__':
gp = get_photos()
print('获取图片连接中:')
gp.get_ids()
print('图片下载中:')
for i in range(len(gp.photos_id)):
print(' 正在下载第%d张图片' % (i+1))
gp.download(gp.photos_id[i], (i+1))
下载速度还行,有的图片下载慢是因为图片太大。可以看到右侧也打印了一些警报信息,这是因为我们没有进行SSL验证。
学会了爬取图片,简单的动态加载的网站也难不倒你了。赶快试试国内的一些图片网站吧!
(1)实战背景
爱奇艺的VIP视频只有会员能看,普通用户只能看前6分钟。比如加勒比海盗5:
URL:http://www.iqiyi.com/v_19rr7qhfg0.html#vfrm=19-9-0-1
我们怎么免费看VIP视频呢?一个简单的方法,就是通过旋风视频VIP解析网站。
URL:http://api.xfsub.com/
这个网站为我们提供了免费的视频解析,它的通用解析方式是:
http://api.xfsub.com/index.php?url=[播放地址或视频id]
比如,对于绣春刀这个电影,我们只需要在浏览器地址栏输入:
http://api.xfsub.com/index.php?url=http://www.iqiyi.com/v_19rr7qhfg0.html#vfrm=19-9-0-1
这样,我们就可以在线观看这些VIP视频了:
但是这个网站只提供了在线解析视频的功能,没有提供下载接口,如果想把视频下载下来,我们就可以利用网络爬虫进行抓包,将视频下载下来。
(2)实战升级
分析方法相同,我们使用Fiddler进行抓包:
我们可以看到,有用的请求并不多,我们逐条分析。我们先看第一个请求返回的信息。
可以看到第一个请求是GET请求,没有什么有用的信息,继续看下一条。
我们看到,第二条GET请求地址变了,并且在返回的信息中,我们看到,这个网页执行了一个POST请求。POST请求是啥呢?它跟GET请求正好相反,GET是从服务器获得数据,而POST请求是向服务器发送数据,服务器再根据POST请求的参数,返回相应的内容。这个POST请求有四个参数,分别为time、key、url、type。记住这个有用的信息,我们在抓包结果中,找一下这个请求,看看这个POST请求做了什么。
很显然,这个就是我们要找的POST请求,我们可以看到POST请求的参数以及返回的json格式的数据。其中url存放的参数如下:
xfsub_api\/url.php?key=02896e4af69fb18f70129b6046d7c718&time=1505724557&url=http%3A%2F%2Fwww.iqiyi.com%2Fv_19rr7qhfg0.html&type=&xml=1
这个信息有转义了,但是没有关系,我们手动提取一下,变成如下形式:
xfsub_api/url.php?key=02896e4af69fb18f70129b6046d7c718&time=1505724557&url=http://www.iqiyi.com/v_19rr7qhfg0.html&type=&xml=1
我们已经知道了这个解析视频的服务器的域名,再把域名加上:
http://api.xfsub.com/xfsub_api\url.php?key=02896e4af69fb18f70129b6046d7c718&time=1505724557&url=http://www.iqiyi.com/v_19rr7qhfg0.html&type=&xml=1
这里面存放的是什么东西?不会视频解析后的地址吧?我们有浏览器打开这个地址看一下:
果然,我们可以看到视频地址近在眼前啊,URL如下:
http://disp.titan.mgtv.com/vod.do?fmt=4&pno=1121&fid=1FEA2622E0BD9A1CA625FBE9B5A238A6&file=/c1/2017/09/06_0/1FEA2622E0BD9A1CA625FBE9B5A238A6_20170906_1_1_705.mp4
我们再打开这个视频地址:
瞧,我们就这样得到了这个视频在服务器上的缓存地址。根据这个地址,我们就可以轻松下载视频了。
PS:需要注意一点,这些URL地址,都是有一定时效性的,很快就会失效,因为里面包含时间信息。所以,各位在分析的时候,要根据自己的URL结果打开网站才能看到视频。
接下来,我们的任务就是编程实现我们所分析的步骤,根据不同的视频播放地址获得视频存放的地址。
现在梳理一下编程思路:
(3)编写代码
编写代码的时候注意一个问题,就是我们需要使用requests.session()保持我们的会话请求。简单理解就是,在初次访问服务器的时候,服务器会给你分配一个身份证明。我们需要拿着这个身份证去继续访问,如果没有这个身份证明,服务器就不会再让你访问。这也就是这个服务器的反爬虫手段,会验证用户的身份。
#-*- coding:UTF-8 -*-
import requests,re, json
from bs4 import BeautifulSoup
class video_downloader():
def __init__(self, url):
self.server = 'http://api.xfsub.com'
self.api = 'http://api.xfsub.com/xfsub_api/?url='
self.get_url_api = 'http://api.xfsub.com/xfsub_api/url.php'
self.url = url.split('#')[0]
self.target = self.api + self.url
self.s = requests.session()
"""
函数说明:获取key、time、url等参数
Parameters:
无
Returns:
无
Modify:
2017-09-18
"""
def get_key(self):
req = self.s.get(url=self.target)
req.encoding = 'utf-8'
self.info = json.loads(re.findall('"url.php",\ (.+),', req.text)[0]) #使用正则表达式匹配结果,将匹配的结果存入info变量中
"""
函数说明:获取视频地址
Parameters:
无
Returns:
video_url - 视频存放地址
Modify:
2017-09-18
"""
def get_url(self):
data = {'time':self.info['time'],
'key':self.info['key'],
'url':self.info['url'],
'type':''}
req = self.s.post(url=self.get_url_api,data=data)
url = self.server + json.loads(req.text)['url']
req = self.s.get(url)
bf = BeautifulSoup(req.text,'xml') #因为文件是xml格式的,所以要进行xml解析。
video_url = bf.find('file').string #匹配到视频地址
return video_url
if __name__ == '__main__':
url = 'http://www.iqiyi.com/v_19rr7qhfg0.html#vfrm=19-9-0-1'
vd = video_downloader(url)
vd.get_key()
print(vd.get_url())
思路已经给出,希望喜欢爬虫的人可以在运行下代码之后,自己重头编写程序,因为只有经过自己分析和测试之后,才能真正明白这些代码的意义。上述代码运行结果如下:
我们已经顺利获得了mp4这个视频文件地址。根据视频地址,使用urllib.request.urlretrieve()即可将视频下载下来。编写代码如下:
#-*- coding:UTF-8 -*-
import requests,re, json, sys
from bs4 import BeautifulSoup
from urllib import request
class video_downloader():
def __init__(self, url):
self.server = 'http://api.xfsub.com'
self.api = 'http://api.xfsub.com/xfsub_api/?url='
self.get_url_api = 'http://api.xfsub.com/xfsub_api/url.php'
self.url = url.split('#')[0]
self.target = self.api + self.url
self.s = requests.session()
"""
函数说明:获取key、time、url等参数
Parameters:
无
Returns:
无
Modify:
2017-09-18
"""
def get_key(self):
req = self.s.get(url=self.target)
req.encoding = 'utf-8'
self.info = json.loads(re.findall('"url.php",\ (.+),', req.text)[0]) #使用正则表达式匹配结果,将匹配的结果存入info变量中
"""
函数说明:获取视频地址
Parameters:
无
Returns:
video_url - 视频存放地址
Modify:
2017-09-18
"""
def get_url(self):
data = {'time':self.info['time'],
'key':self.info['key'],
'url':self.info['url'],
'type':''}
req = self.s.post(url=self.get_url_api,data=data)
url = self.server + json.loads(req.text)['url']
req = self.s.get(url)
bf = BeautifulSoup(req.text,'xml') #因为文件是xml格式的,所以要进行xml解析。
video_url = bf.find('file').string #匹配到视频地址
return video_url
"""
函数说明:回调函数,打印下载进度
Parameters:
a b c - 返回信息
Returns:
无
Modify:
2017-09-18
"""
def Schedule(self, a, b, c):
per = 100.0*a*b/c
if per > 100 :
per = 1
sys.stdout.write(" " + "%.2f%% 已经下载的大小:%ld 文件大小:%ld" % (per,a*b,c) + '\r')
sys.stdout.flush()
"""
函数说明:视频下载
Parameters:
url - 视频地址
filename - 视频名字
Returns:
无
Modify:
2017-09-18
"""
def video_download(self, url, filename):
request.urlretrieve(url=url,filename=filename,reporthook=self.Schedule)
if __name__ == '__main__':
url = 'http://www.iqiyi.com/v_19rr7qhfg0.html#vfrm=19-9-0-1'
vd = video_downloader(url)
filename = '加勒比海盗5'
print('%s下载中:' % filename)
vd.get_key()
video_url = vd.get_url()
print(' 获取地址成功:%s' % video_url)
vd.video_download(video_url, filename+'.mp4')
print('\n下载完成!')
urlretrieve()有三个参数,第一个url参数是视频存放的地址,第二个参数filename是保存的文件名,最后一个是回调函数,它方便我们查看下载进度。代码量不大,很简单,主要在于分析过程。代码运行结果如下:
下载速度挺快的,几分钟视频下载好了。
对于这个程序,感兴趣的朋友可以进行扩展一下,设计出一个小软件,根据用户提供的url,提供PC在线观看、手机在线观看、视频下载等功能。
*请认真填写需求信息,我们会在24小时内与您取得联系。