python 爬虫（转，我使用的python3）

时间  2019-12-09
标签 python 爬虫 使用 python3 栏目 Python 繁體版
原文   原文链接
  原文地址：http://blog.csdn.net/pi9nc/article/details/9734437

[Python]网络爬虫（一）：抓取网页的含义和URL基本构成

分类： 爬虫 Python2013-05-13 22:30 1597人阅读 评论(0) 收藏 举报

1、网络爬虫的定义html

网络爬虫，即Web Spider，是一个很形象的名字。把互联网比喻成一个蜘蛛网，那么Spider就是在网上爬来爬去的蜘蛛。网络蜘蛛是经过网页的连接地址来寻找网页的。python

从网站某一个页面（一般是首页）开始，读取网页的内容，找到在网页中的其它连接地址，而后经过这些连接地址寻找下一个网页，这样一直循环下去，直到把这个网站全部的网页git

都抓取完为止。若是把整个互联网当成一个网站，那么网络蜘蛛就能够用这个原理把互联网上全部的网页都抓取下来。web

这样看来，网络爬虫就是一个爬行程序，一个抓取网页的程序。正则表达式

网络爬虫的基本操做是抓取网页。编程

那么如何才能为所欲为地得到本身想要的页面？json

咱们先从URL开始。数组

 

2、浏览网页的过程浏览器

抓取网页的过程其实和读者平时使用IE浏览器浏览网页的道理是同样的。服务器

好比说你在浏览器的地址栏中输入    www.baidu.com    这个地址。

打开网页的过程其实就是浏览器做为一个浏览的“客户端”，向服务器端发送了一次请求，把服务器端的文件“抓”到本地，再进行解释、展示。

HTML是一种标记语言，用标签标记内容并加以解析和区分。

浏览器的功能是将获取到的HTML代码进行解析，而后将原始的代码转变成咱们直接看到的网站页面。

 

3、URI的概念和举例

简单的来说，URL就是在浏览器端输入的    www.baidu.com    这个字符串。

在理解URL以前，首先要理解URI的概念。

什么是URI？

Web上每种可用的资源，如 HTML文档、图像、视频片断、程序等都由一个通用资源标志符(Universal Resource Identifier， URI)进行定位。 

URI一般由三部分组成：

①访问资源的命名机制；

②存放资源的主机名；

③资源自身 的名称，由路径表示。

以下面的URI：
http://www.why.com.cn/myhtml/html1223/

咱们能够这样解释它：

①这是一个能够经过HTTP协议访问的资源，

②位于主机 www.webmonkey.com.cn上，

③经过路径“/html/html40”访问。 

 

4、URL的理解和举例

URL是URI的一个子集。它是Uniform Resource Locator的缩写，译为“统一资源定位 符”。

通俗地说，URL是Internet上描述信息资源的字符串，主要用在各类WWW客户程序和服务器程序上。

采用URL能够用一种统一的格式来描述各类信息资源，包括文件、服务器的地址和目录等。

URL的格式由三部分组成： 

①第一部分是协议(或称为服务方式)。

②第二部分是存有该资源的主机IP地址(有时也包括端口号)。

③第三部分是主机资源的具体地址，如目录和文件名等。

第一部分和第二部分用“://”符号隔开，

第二部分和第三部分用“/”符号隔开。

第一部分和第二部分是不可缺乏的，第三部分有时能够省略。 

 

下面来看看两个URL的小例子。

 

1.HTTP协议的URL示例：
使用超级文本传输协议HTTP，提供超级文本信息服务的资源。 

例：http://www.peopledaily.com.cn/channel/welcome.htm 

其计算机域名为www.peopledaily.com.cn。

超级文本文件(文件类型为.html)是在目录 /channel下的welcome.htm。

这是中国人民日报的一台计算机。 

例：http://www.rol.cn.net/talk/talk1.htm 

其计算机域名为www.rol.cn.net。

超级文本文件(文件类型为.html)是在目录/talk下的talk1.htm。

这是瑞得聊天室的地址，可由此进入瑞得聊天室的第1室。


2．文件的URL
用URL表示文件时，服务器方式用file表示，后面要有主机IP地址、文件的存取路 径(即目录)和文件名等信息。

有时能够省略目录和文件名，但“/”符号不能省略。 

例：file://ftp.yoyodyne.com/pub/files/foobar.txt 

上面这个URL表明存放在主机ftp.yoyodyne.com上的pub/files/目录下的一个文件，文件名是foobar.txt。

例：file://ftp.yoyodyne.com/pub 

表明主机ftp.yoyodyne.com上的目录/pub。 

例：file://ftp.yoyodyne.com/ 

表明主机ftp.yoyodyne.com的根目录。 

 

爬虫最主要的处理对象就是URL，它根据URL地址取得所须要的文件内容，而后对它进行进一步的处理。

所以，准确地理解URL对理解网络爬虫相当重要

 

 

  

[Python]网络爬虫（二）：利用urllib2经过指定的URL抓取网页内容

分类： 爬虫 Python2013-05-13 23:45 1628人阅读 评论(0) 收藏 举报

所谓网页抓取，就是把URL地址中指定的网络资源从网络流中读取出来，保存到本地。 
相似于使用程序模拟IE浏览器的功能，把URL做为HTTP请求的内容发送到服务器端， 而后读取服务器端的响应资源。


在Python中，咱们使用urllib2这个组件来抓取网页。
urllib2是Python的一个获取URLs(Uniform Resource Locators)的组件。

它以urlopen函数的形式提供了一个很是简单的接口。

最简单的urllib2的应用代码只须要四行。

在pythono3以上的版本，urllib2已经被整合到标准库中，因此须要import urllib.request

咱们新建一个文件urllib2_test01.py来感觉一下urllib2的做用：

 

[python]  view plain copy
 
 
  1. import urllib.request
  2. response = urllib.request.urlopen('http://www.baidu.com/')  
  3. html = response.read()  
  4. print(html) 

按下F5能够看到运行的结果：

 

咱们能够打开百度主页，右击，选择查看源代码（火狐OR谷歌浏览器都可），会发现也是彻底同样的内容。

也就是说，上面这四行代码将咱们访问百度时浏览器收到的代码们所有打印了出来。

这就是一个最简单的urllib2的例子。

 

除了"http:"，URL一样可使用"ftp:"，"file:"等等来替代。

HTTP是基于请求和应答机制的：

客户端提出请求，服务端提供应答。

 

urllib2用一个Request对象来映射你提出的HTTP请求。

在它最简单的使用形式中你将用你要请求的地址建立一个Request对象，

经过调用urlopen并传入Request对象，将返回一个相关请求response对象，

这个应答对象如同一个文件对象，因此你能够在Response中调用.read()。

咱们新建一个文件urllib2_test02.py来感觉一下：

 

[python]  view plain copy
 
 
  1. import urllib2    
  2. req = urllib2.Request('http://www.baidu.com')    
  3. response = urllib2.urlopen(req)    
  4. the_page = response.read()    
  5. print the_page  

能够看到输出的内容和test01是同样的。

 

urllib2使用相同的接口处理全部的URL头。例如你能够像下面那样建立一个ftp请求。

[python]  view plain copy
 
 
  1. req = urllib2.Request('ftp://example.com/')  
在HTTP请求时，容许你作额外的两件事。

 

1.发送data表单数据

这个内容相信作过Web端的都不会陌生，

有时候你但愿发送一些数据到URL(一般URL与CGI[通用网关接口]脚本，或其余WEB应用程序挂接)。

在HTTP中,这个常用熟知的POST请求发送。

这个一般在你提交一个HTML表单时由你的浏览器来作。

并非全部的POSTs都来源于表单，你可以使用POST提交任意的数据到你本身的程序。

通常的HTML表单，data须要编码成标准形式。而后作为data参数传到Request对象。

编码工做使用urllib的函数而非urllib2。

咱们新建一个文件urllib2_test03.py来感觉一下：

 

[python]  view plain copy
 
 
  1. import urllib    
  2. import urllib.request   
  3.   
  4. url = 'http://www.someserver.com/register.cgi'    
  5.     
  6. values = {'name' : 'WHY',    
  7.           'location' : 'SDU',    
  8.           'language' : 'Python' }    
  9.   
  10. data = urllib.urlencode(values) # 编码工做  
  11. req = urllib.request(url, data)  # 发送请求同时传data表单  
  12. response = urllib.request.urlopen(req)  #接受反馈的信息  
  13. the_page = response.read()  #读取反馈的内容  

若是没有传送data参数，urllib2使用GET方式的请求。

GET和POST请求的不一样之处是POST请求一般有"反作用"，

它们会因为某种途径改变系统状态(例如提交成堆垃圾到你的门口)。

Data一样能够经过在Get请求的URL自己上面编码来传送。

 

[python]  view plain copy
 
 
  1. import urllib2    
  2. import urllib  
  3.   
  4. data = {}  
  5.   
  6. data['name'] = 'WHY'    
  7. data['location'] = 'SDU'    
  8. data['language'] = 'Python'  
  9.   
  10. url_values = urllib.urlencode(data)    
  11. print url_values  
  12.   
  13. name=Somebody+Here&language=Python&location=Northampton    
  14. url = 'http://www.example.com/example.cgi'    
  15. full_url = url + '?' + url_values  
  16.   
  17. data = urllib2.open(full_url)    

这样就实现了Data数据的Get传送。

 

 

2.设置Headers到http请求

有一些站点不喜欢被程序（非人为访问）访问，或者发送不一样版本的内容到不一样的浏览器。

默认的urllib2把本身做为“Python-urllib/x.y”(x和y是Python主版本和次版本号,例如Python-urllib/2.7)，

这个身份可能会让站点迷惑，或者干脆不工做。

浏览器确认本身身份是经过User-Agent头，当你建立了一个请求对象，你能够给他一个包含头数据的字典。

下面的例子发送跟上面同样的内容，但把自身模拟成Internet Explorer。

 

[python]  view plain copy
 
 
  1. import urllib    
  2. import urllib2    
  3.   
  4. url = 'http://www.someserver.com/cgi-bin/register.cgi'  
  5.   
  6. user_agent = 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)'    
  7. values = {'name' : 'WHY',    
  8.           'location' : 'SDU',    
  9.           'language' : 'Python' }    
  10.   
  11. headers = { 'User-Agent' : user_agent }    
  12. data = urllib.urlencode(values)    
  13. req = urllib2.Request(url, data, headers)    
  14. response = urllib2.urlopen(req)    
  15. the_page = response.read()   

[Python]网络爬虫（三）：异常的处理和HTTP状态码的分类

分类： Python 爬虫2013-05-14 09:51 1358人阅读 评论(5) 收藏 举报

先来讲一说HTTP的异常处理问题。
当urlopen不可以处理一个response时，产生urlError。
不过一般的Python APIs异常如ValueError,TypeError等也会同时产生。
HTTPError是urlError的子类，一般在特定HTTP URLs中产生。
 
1.URLError
一般，URLError在没有网络链接(没有路由到特定服务器)，或者服务器不存在的状况下产生。

这种状况下，异常一样会带有"reason"属性，它是一个tuple（能够理解为不可变的数组），

包含了一个错误号和一个错误信息。

咱们建一个urllib2_test06.py来感觉一下异常的处理：

 

[python]  view plain copy
 
 
  1. import urllib2  
  2.   
  3. req = urllib2.Request('http://www.baibai.com')  
  4.   
  5. try: urllib2.urlopen(req)  
  6.   
  7. except urllib2.URLError, e:    
  8.     print e.reason  


 

按下F5，能够看到打印出来的内容是：

 

[Errno 11001] getaddrinfo failed

也就是说，错误号是11001，内容是getaddrinfo failed

 

2.HTTPError
服务器上每个HTTP 应答对象response包含一个数字"状态码"。

有时状态码指出服务器没法完成请求。默认的处理器会为你处理一部分这种应答。

例如:假如response是一个"重定向"，须要客户端从别的地址获取文档，urllib2将为你处理。

其余不能处理的，urlopen会产生一个HTTPError。

典型的错误包含"404"(页面没法找到)，"403"(请求禁止)，和"401"(带验证请求)。

HTTP状态码表示HTTP协议所返回的响应的状态。

好比客户端向服务器发送请求，若是成功地得到请求的资源，则返回的状态码为200，表示响应成功。

若是请求的资源不存在， 则一般返回404错误。 

HTTP状态码一般分为5种类型，分别以1～5五个数字开头，由3位整数组成：

------------------------------------------------------------------------------------------------

200：请求成功      处理方式：得到响应的内容，进行处理 

201：请求完成，结果是建立了新资源。新建立资源的URI可在响应的实体中获得    处理方式：爬虫中不会遇到 

202：请求被接受，但处理还没有完成    处理方式：阻塞等待 

204：服务器端已经实现了请求，可是没有返回新的信 息。若是客户是用户代理，则无须为此更新自身的文档视图。    处理方式：丢弃

300：该状态码不被HTTP/1.0的应用程序直接使用， 只是做为3XX类型回应的默认解释。存在多个可用的被请求资源。    处理方式：若程序中可以处理，则进行进一步处理，若是程序中不能处理，则丢弃
301：请求到的资源都会分配一个永久的URL，这样就能够在未来经过该URL来访问此资源    处理方式：重定向到分配的URL
302：请求到的资源在一个不一样的URL处临时保存     处理方式：重定向到临时的URL 

304 请求的资源未更新     处理方式：丢弃 

400 非法请求     处理方式：丢弃 

401 未受权     处理方式：丢弃 

403 禁止     处理方式：丢弃 

404 没有找到     处理方式：丢弃 

5XX 回应代码以“5”开头的状态码表示服务器端发现本身出现错误，不能继续执行请求    处理方式：丢弃

 

------------------------------------------------------------------------------------------------

HTTPError实例产生后会有一个整型'code'属性，是服务器发送的相关错误号。

Error Codes错误码
由于默认的处理器处理了重定向(300之外号码)，而且100-299范围的号码指示成功，因此你只能看到400-599的错误号码。
BaseHTTPServer.BaseHTTPRequestHandler.response是一个颇有用的应答号码字典，显示了HTTP协议使用的全部的应答号。

当一个错误号产生后，服务器返回一个HTTP错误号，和一个错误页面。

你可使用HTTPError实例做为页面返回的应答对象response。

这表示和错误属性同样，它一样包含了read,geturl,和info方法。

 

咱们建一个urllib2_test07.py来感觉一下：

 

[python]  view plain copy
 
 
  1. import urllib2  
  2. req = urllib2.Request('http://bbs.csdn.net/callmewhy')  
  3.   
  4. try:  
  5.     urllib2.urlopen(req)  
  6.   
  7. except urllib2.URLError, e:  
  8.   
  9.     print e.code  
  10.     #print e.read()  

按下F5能够看见输出了404的错误码，也就说没有找到这个页面。



3.Wrapping

因此若是你想为HTTPError或URLError作准备，将有两个基本的办法。推荐使用第二种。

 

咱们建一个urllib2_test08.py来示范一下第一种异常处理的方案：

[python]  view plain copy
 
 
  1. from urllib2 import Request, urlopen, URLError, HTTPError  
  2.   
  3. req = Request('http://bbs.csdn.net/callmewhy')  
  4.   
  5. try:  
  6.   
  7.     response = urlopen(req)  
  8.   
  9. except HTTPError, e:  
  10.   
  11.     print 'The server couldn\'t fulfill the request.'  
  12.   
  13.     print 'Error code: ', e.code  
  14.   
  15. except URLError, e:  
  16.   
  17.     print 'We failed to reach a server.'  
  18.   
  19.     print 'Reason: ', e.reason  
  20.   
  21. else:  
  22.     print 'No exception was raised.'  
  23.     # everything is fine  

和其余语言类似，try以后捕获异常而且将其内容打印出来。
这里要注意的一点，except HTTPError 必须在第一个，不然except URLError将一样接受到HTTPError 。
由于HTTPError是URLError的子类，若是URLError在前面它会捕捉到全部的URLError（包括HTTPError ）。
 
 

咱们建一个urllib2_test09.py来示范一下第二种异常处理的方案：

[python]  view plain copy
 
 
  1. from urllib2 import Request, urlopen, URLError, HTTPError  
  2.   
  3. req = Request('http://bbs.csdn.net/callmewhy')  
  4.     
  5. try:    
  6.     
  7.     response = urlopen(req)    
  8.     
  9. except URLError, e:    
  10.     
  11.     if hasattr(e, 'reason'):    
  12.     
  13.         print 'We failed to reach a server.'    
  14.     
  15.         print 'Reason: ', e.reason    
  16.     
  17.     elif hasattr(e, 'code'):    
  18.     
  19.         print 'The server couldn\'t fulfill the request.'    
  20.     
  21.         print 'Error code: ', e.code    
  22.     
  23. else:    
  24.     print 'No exception was raised.'    
  25.     # everything is fine  
  

[Python]网络爬虫（四）：Opener与Handler的介绍和实例应用

分类： Python 爬虫2013-05-14 15:09 1087人阅读 评论(0) 收藏 举报

在开始后面的内容以前，先来解释一下urllib2中的两个个方法：info and geturl 

urlopen返回的应答对象response(或者HTTPError实例)有两个颇有用的方法info()和geturl()

1.geturl()：

这个返回获取的真实的URL，这个颇有用，由于urlopen(或者opener对象使用的)或许会有重定向。获取的URL或许跟请求URL不一样。

以人人中的一个超级连接为例,

 

咱们建一个urllib2_test10.py来比较一下原始URL和重定向的连接：

 

 

[python]  view plain copy
 
 
  1. from urllib2 import Request, urlopen, URLError, HTTPError  
  2.   
  3.   
  4. old_url = 'http://rrurl.cn/b1UZuP'  
  5. req = Request(old_url)  
  6. response = urlopen(req)    
  7. print 'Old url :' + old_url  
  8. print 'Real url :' + response.geturl()  
运行以后能够看到真正的连接指向的网址：

 



2.info()：

这个返回对象的字典对象，该字典描述了获取的页面状况。一般是服务器发送的特定头headers。目前是httplib.HTTPMessage 实例。

经典的headers包含"Content-length"，"Content-type"，和其余内容。

 

咱们建一个urllib2_test11.py来测试一下info的应用：

 

[python]  view plain copy
 
 
  1. from urllib2 import Request, urlopen, URLError, HTTPError  
  2.   
  3. old_url = 'http://www.baidu.com'  
  4. req = Request(old_url)  
  5. response = urlopen(req)    
  6. print 'Info():'  
  7. print response.info()  
运行的结果以下，能够看到页面的相关信息：

 

 

 

下面来讲一说urllib2中的两个重要概念：Openers和Handlers。

1.Openers：

当你获取一个URL你使用一个opener(一个urllib2.OpenerDirector的实例)。

正常状况下，咱们使用默认opener：经过urlopen。

但你可以建立个性的openers。

2.Handles：

Openers使用处理器handlers，全部的“繁重”工做由handlers处理。

每一个handlers知道如何经过特定协议打开URLs，或者如何处理URL打开时的各个方面。

例如HTTP重定向或者HTTP cookies。

 

若是你但愿用特定处理器获取URLs你会想建立一个openers，例如获取一个能处理cookie的opener，或者获取一个不重定向的opener。

 

要建立一个 opener，能够实例化一个OpenerDirector，

而后调用.add_handler(some_handler_instance)。

一样，可使用build_opener，这是一个更加方便的函数，用来建立opener对象，他只须要一次函数调用。
build_opener默认添加几个处理器，但提供快捷的方法来添加或更新默认处理器。

其余的处理器handlers你或许会但愿处理代理，验证，和其余经常使用但有点特殊的状况。

 

install_opener 用来建立（全局）默认opener。这个表示调用urlopen将使用你安装的opener。

Opener对象有一个open方法。

该方法能够像urlopen函数那样直接用来获取urls：一般没必要调用install_opener，除了为了方便。

 

说完了上面两个内容，下面咱们来看一下基本认证的内容，这里会用到上面说起的Opener和Handler。

Basic Authentication 基本验证

为了展现建立和安装一个handler，咱们将使用HTTPBasicAuthHandler。

当须要基础验证时，服务器发送一个header(401错误码) 请求验证。这个指定了scheme 和一个‘realm’，看起来像这样：Www-authenticate: SCHEME realm="REALM".

例如
Www-authenticate: Basic realm="cPanel Users"

客户端必须使用新的请求，并在请求头里包含正确的姓名和密码。

这是“基础验证”，为了简化这个过程，咱们能够建立一个HTTPBasicAuthHandler的实例，并让opener使用这个handler就能够啦。


HTTPBasicAuthHandler使用一个密码管理的对象来处理URLs和realms来映射用户名和密码。

若是你知道realm(从服务器发送来的头里)是什么，你就能使用HTTPPasswordMgr。


一般人们不关心realm是什么。那样的话，就能用方便的HTTPPasswordMgrWithDefaultRealm。

这个将在你为URL指定一个默认的用户名和密码。

这将在你为特定realm提供一个其余组合时获得提供。

咱们经过给realm参数指定None提供给add_password来指示这种状况。

 

最高层次的URL是第一个要求验证的URL。你传给.add_password()更深层次的URLs将一样合适。

说了这么多废话，下面来用一个例子演示一下上面说到的内容。

 

咱们建一个urllib2_test12.py来测试一下info的应用：

 

[python]  view plain copy
 
 
  1. # -*- coding: utf-8 -*-  
  2. import urllib2  
  3.   
  4. # 建立一个密码管理者  
  5. password_mgr = urllib2.HTTPPasswordMgrWithDefaultRealm()  
  6.   
  7. # 添加用户名和密码  
  8.   
  9. top_level_url = "http://example.com/foo/"  
  10.   
  11. # 若是知道 realm, 咱们可使用他代替 ``None``.  
  12. # password_mgr.add_password(None, top_level_url, username, password)  
  13. password_mgr.add_password(None, top_level_url,'why', '1223')  
  14.   
  15. # 建立了一个新的handler  
  16. handler = urllib2.HTTPBasicAuthHandler(password_mgr)  
  17.   
  18. # 建立 "opener" (OpenerDirector 实例)  
  19. opener = urllib2.build_opener(handler)  
  20.   
  21. a_url = 'http://www.baidu.com/'  
  22.   
  23. # 使用 opener 获取一个URL  
  24. opener.open(a_url)  
  25.   
  26. # 安装 opener.  
  27. # 如今全部调用 urllib2.urlopen 将用咱们的 opener.  
  28. urllib2.install_opener(opener)  
  29.   
  30.    

 

注意：以上的例子咱们仅仅提供咱们的HHTPBasicAuthHandler给build_opener。

默认的openers有正常情况的handlers：ProxyHandler，UnknownHandler，HTTPHandler，HTTPDefaultErrorHandler， HTTPRedirectHandler，FTPHandler， FileHandler， HTTPErrorProcessor。

代码中的top_level_url 实际上能够是完整URL(包含"http:"，以及主机名及可选的端口号)。

 

例如：http://example.com/。

也能够是一个“authority”(即主机名和可选的包含端口号)。

例如：“example.com” or “example.com:8080”。

后者包含了端口号。

  

[Python]网络爬虫（四）：Opener与Handler的介绍和实例应用

分类： Python 爬虫2013-05-14 15:09 1087人阅读 评论(0) 收藏 举报

在开始后面的内容以前，先来解释一下urllib2中的两个个方法：info and geturl 

urlopen返回的应答对象response(或者HTTPError实例)有两个颇有用的方法info()和geturl()

1.geturl()：

这个返回获取的真实的URL，这个颇有用，由于urlopen(或者opener对象使用的)或许会有重定向。获取的URL或许跟请求URL不一样。

以人人中的一个超级连接为例,

 

咱们建一个urllib2_test10.py来比较一下原始URL和重定向的连接：

 

 

[python]  view plain copy
 
 
  1. from urllib2 import Request, urlopen, URLError, HTTPError  
  2.   
  3.   
  4. old_url = 'http://rrurl.cn/b1UZuP'  
  5. req = Request(old_url)  
  6. response = urlopen(req)    
  7. print 'Old url :' + old_url  
  8. print 'Real url :' + response.geturl()  
运行以后能够看到真正的连接指向的网址：

 



2.info()：

这个返回对象的字典对象，该字典描述了获取的页面状况。一般是服务器发送的特定头headers。目前是httplib.HTTPMessage 实例。

经典的headers包含"Content-length"，"Content-type"，和其余内容。

 

咱们建一个urllib2_test11.py来测试一下info的应用：

 

[python]  view plain copy
 
 
  1. from urllib2 import Request, urlopen, URLError, HTTPError  
  2.   
  3. old_url = 'http://www.baidu.com'  
  4. req = Request(old_url)  
  5. response = urlopen(req)    
  6. print 'Info():'  
  7. print response.info()  
运行的结果以下，能够看到页面的相关信息：

 

 

 

下面来讲一说urllib2中的两个重要概念：Openers和Handlers。

1.Openers：

当你获取一个URL你使用一个opener(一个urllib2.OpenerDirector的实例)。

正常状况下，咱们使用默认opener：经过urlopen。

但你可以建立个性的openers。

2.Handles：

Openers使用处理器handlers，全部的“繁重”工做由handlers处理。

每一个handlers知道如何经过特定协议打开URLs，或者如何处理URL打开时的各个方面。

例如HTTP重定向或者HTTP cookies。

 

若是你但愿用特定处理器获取URLs你会想建立一个openers，例如获取一个能处理cookie的opener，或者获取一个不重定向的opener。

 

要建立一个 opener，能够实例化一个OpenerDirector，

而后调用.add_handler(some_handler_instance)。

一样，可使用build_opener，这是一个更加方便的函数，用来建立opener对象，他只须要一次函数调用。
build_opener默认添加几个处理器，但提供快捷的方法来添加或更新默认处理器。

其余的处理器handlers你或许会但愿处理代理，验证，和其余经常使用但有点特殊的状况。

 

install_opener 用来建立（全局）默认opener。这个表示调用urlopen将使用你安装的opener。

Opener对象有一个open方法。

该方法能够像urlopen函数那样直接用来获取urls：一般没必要调用install_opener，除了为了方便。

 

说完了上面两个内容，下面咱们来看一下基本认证的内容，这里会用到上面说起的Opener和Handler。

Basic Authentication 基本验证

为了展现建立和安装一个handler，咱们将使用HTTPBasicAuthHandler。

当须要基础验证时，服务器发送一个header(401错误码) 请求验证。这个指定了scheme 和一个‘realm’，看起来像这样：Www-authenticate: SCHEME realm="REALM".

例如
Www-authenticate: Basic realm="cPanel Users"

客户端必须使用新的请求，并在请求头里包含正确的姓名和密码。

这是“基础验证”，为了简化这个过程，咱们能够建立一个HTTPBasicAuthHandler的实例，并让opener使用这个handler就能够啦。


HTTPBasicAuthHandler使用一个密码管理的对象来处理URLs和realms来映射用户名和密码。

若是你知道realm(从服务器发送来的头里)是什么，你就能使用HTTPPasswordMgr。


一般人们不关心realm是什么。那样的话，就能用方便的HTTPPasswordMgrWithDefaultRealm。

这个将在你为URL指定一个默认的用户名和密码。

这将在你为特定realm提供一个其余组合时获得提供。

咱们经过给realm参数指定None提供给add_password来指示这种状况。

 

最高层次的URL是第一个要求验证的URL。你传给.add_password()更深层次的URLs将一样合适。

说了这么多废话，下面来用一个例子演示一下上面说到的内容。

 

咱们建一个urllib2_test12.py来测试一下info的应用：

 

[python]  view plain copy
 
 
  1. # -*- coding: utf-8 -*-  
  2. import urllib2  
  3.   
  4. # 建立一个密码管理者  
  5. password_mgr = urllib2.HTTPPasswordMgrWithDefaultRealm()  
  6.   
  7. # 添加用户名和密码  
  8.   
  9. top_level_url = "http://example.com/foo/"  
  10.   
  11. # 若是知道 realm, 咱们可使用他代替 ``None``.  
  12. # password_mgr.add_password(None, top_level_url, username, password)  
  13. password_mgr.add_password(None, top_level_url,'why', '1223')  
  14.   
  15. # 建立了一个新的handler  
  16. handler = urllib2.HTTPBasicAuthHandler(password_mgr)  
  17.   
  18. # 建立 "opener" (OpenerDirector 实例)  
  19. opener = urllib2.build_opener(handler)  
  20.   
  21. a_url = 'http://www.baidu.com/'  
  22.   
  23. # 使用 opener 获取一个URL  
  24. opener.open(a_url)  
  25.   
  26. # 安装 opener.  
  27. # 如今全部调用 urllib2.urlopen 将用咱们的 opener.  
  28. urllib2.install_opener(opener)  
  29.   
  30.    

 

注意：以上的例子咱们仅仅提供咱们的HHTPBasicAuthHandler给build_opener。

默认的openers有正常情况的handlers：ProxyHandler，UnknownHandler，HTTPHandler，HTTPDefaultErrorHandler， HTTPRedirectHandler，FTPHandler， FileHandler， HTTPErrorProcessor。

代码中的top_level_url 实际上能够是完整URL(包含"http:"，以及主机名及可选的端口号)。

 

例如：http://example.com/。

也能够是一个“authority”(即主机名和可选的包含端口号)。

例如：“example.com” or “example.com:8080”。

后者包含了端口号。

[Python]网络爬虫（五）：urllib2的使用细节与抓站技巧

分类： 爬虫 Python2013-05-14 16:21 1250人阅读 评论(0) 收藏 举报

前面说到了urllib2的简单入门，下面整理了一部分urllib2的使用细节。

 

1.Proxy 的设置

urllib2 默认会使用环境变量 http_proxy 来设置 HTTP Proxy。

若是想在程序中明确控制 Proxy 而不受环境变量的影响，可使用代理。

新建test14来实现一个简单的代理Demo：

[python]  view plain copy
 
 
  1. import urllib2  
  2. enable_proxy = True  
  3. proxy_handler = urllib2.ProxyHandler({"http" : 'http://some-proxy.com:8080'})  
  4. null_proxy_handler = urllib2.ProxyHandler({})  
  5. if enable_proxy:  
  6.     opener = urllib2.build_opener(proxy_handler)  
  7. else:  
  8.     opener = urllib2.build_opener(null_proxy_handler)  
  9. urllib2.install_opener(opener)  

这里要注意的一个细节，使用 urllib2.install_opener() 会设置 urllib2 的全局 opener 。

这样后面的使用会很方便，但不能作更细致的控制，好比想在程序中使用两个不一样的 Proxy 设置等。

比较好的作法是不使用 install_opener 去更改全局的设置，而只是直接调用 opener 的 open 方法代替全局的 urlopen 方法。


2.Timeout 设置
在老版 Python 中（Python2.6前），urllib2 的 API 并无暴露 Timeout 的设置，要设置 Timeout 值，只能更改 Socket 的全局 Timeout 值。
[python]  view plain copy
 
 
  1. import urllib2  
  2. import socket  
  3. socket.setdefaulttimeout(10) # 10 秒钟后超时  
  4. urllib2.socket.setdefaulttimeout(10) # 另外一种方式  

在 Python 2.6 之后，超时能够经过 urllib2.urlopen() 的 timeout 参数直接设置。
[python]  view plain copy
 
 
  1. import urllib2  
  2. response = urllib2.urlopen('http://www.google.com', timeout=10)  

 

3.在 HTTP Request 中加入特定的 Header

要加入 header，须要使用 Request 对象：
[python]  view plain copy
 
 
  1. import urllib2  
  2. request = urllib2.Request('http://www.baidu.com/')  
  3. request.add_header('User-Agent', 'fake-client')  
  4. response = urllib2.urlopen(request)  
  5. print response.read()  

对有些 header 要特别留意，服务器会针对这些 header 作检查
User-Agent : 有些服务器或 Proxy 会经过该值来判断是不是浏览器发出的请求
Content-Type : 在使用 REST 接口时，服务器会检查该值，用来肯定 HTTP Body 中的内容该怎样解析。常见的取值有：
application/xml ： 在 XML RPC，如 RESTful/SOAP 调用时使用
application/json ： 在 JSON RPC 调用时使用
application/x-www-form-urlencoded ： 浏览器提交 Web 表单时使用
在使用服务器提供的 RESTful 或 SOAP 服务时， Content-Type 设置错误会致使服务器拒绝服务

 

 

4.Redirect
urllib2 默认状况下会针对 HTTP 3XX 返回码自动进行 redirect 动做，无需人工配置。要检测是否发生了 redirect 动做，只要检查一下 Response 的 URL 和 Request 的 URL 是否一致就能够了。
[python]  view plain copy
 
 
  1. import urllib2  
  2. my_url = 'http://www.google.cn'  
  3. response = urllib2.urlopen(my_url)  
  4. redirected = response.geturl() == my_url  
  5. print redirected  
  6.   
  7. my_url = 'http://rrurl.cn/b1UZuP'  
  8. response = urllib2.urlopen(my_url)  
  9. redirected = response.geturl() == my_url  
  10. print redirected  

若是不想自动 redirect，除了使用更低层次的 httplib 库以外，还能够自定义HTTPRedirectHandler 类。
[python]  view plain copy
 
 
  1. import urllib2  
  2. class RedirectHandler(urllib2.HTTPRedirectHandler):  
  3.     def http_error_301(self, req, fp, code, msg, headers):  
  4.         print "301"  
  5.         pass  
  6.     def http_error_302(self, req, fp, code, msg, headers):  
  7.         print "303"  
  8.         pass  
  9.   
  10. opener = urllib2.build_opener(RedirectHandler)  
  11. opener.open('http://rrurl.cn/b1UZuP')  

 

5.Cookie

urllib2 对 Cookie 的处理也是自动的。若是须要获得某个 Cookie 项的值，能够这么作：
[python]  view plain copy
 
 
  1. import urllib2  
  2. import cookielib  
  3. cookie = cookielib.CookieJar()  
  4. opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cookie))  
  5. response = opener.open('http://www.baidu.com')  
  6. for item in cookie:  
  7.     print 'Name = '+item.name  
  8.     print 'Value = '+item.value  

运行以后就会输出访问百度的Cookie值：

 

6.使用 HTTP 的 PUT 和 DELETE 方法

urllib2 只支持 HTTP 的 GET 和 POST 方法，若是要使用 HTTP PUT 和 DELETE ，只能使用比较低层的 httplib 库。虽然如此，咱们仍是能经过下面的方式，使 urllib2 可以发出 PUT 或DELETE 的请求：
[python]  view plain copy
 
 
  1. import urllib2  
  2. request = urllib2.Request(uri, data=data)  
  3. request.get_method = lambda: 'PUT' # or 'DELETE'  
  4. response = urllib2.urlopen(request)  

 

7.获得 HTTP 的返回码

对于 200 OK 来讲，只要使用 urlopen 返回的 response 对象的 getcode() 方法就能够获得 HTTP 的返回码。但对其它返回码来讲，urlopen 会抛出异常。这时候，就要检查异常对象的 code 属性了：
[python]  view plain copy
 
 
  1. import urllib2  
  2. try:  
  3.     response = urllib2.urlopen('http://bbs.csdn.net/why')  
  4. except urllib2.HTTPError, e:  
  5.     print e.code  


8.Debug Log

使用 urllib2 时，能够经过下面的方法把 debug Log 打开，这样收发包的内容就会在屏幕上打印出来，方便调试，有时能够省去抓包的工做
[python]  view plain copy
 
 
  1. import urllib2  
  2. httpHandler = urllib2.HTTPHandler(debuglevel=1)  
  3. httpsHandler = urllib2.HTTPSHandler(debuglevel=1)  
  4. opener = urllib2.build_opener(httpHandler, httpsHandler)  
  5. urllib2.install_opener(opener)  
  6. response = urllib2.urlopen('http://www.google.com')  

这样就能够看到传输的数据包内容了：

 

 

9.表单的处理

登陆必要填表，表单怎么填？

首先利用工具截取所要填表的内容。
好比我通常用firefox+httpfox插件来看看本身到底发送了些什么包。
以verycd为例，先找到本身发的POST请求，以及POST表单项。
能够看到verycd的话须要填username,password,continueURI,fk,login_submit这几项，其中fk是随机生成的（其实不太随机，看上去像是把epoch时间通过简单的编码生成的），须要从网页获取，也就是说得先访问一次网页，用正则表达式等工具截取返回数据中的fk项。continueURI顾名思义能够随便写，login_submit是固定的，这从源码能够看出。还有username，password那就很显然了：

 

[python]  view plain copy
 
 
  1. # -*- coding: utf-8 -*-  
  2. import urllib  
  3. import urllib2  
  4. postdata=urllib.urlencode({  
  5.     'username':'汪小光',  
  6.     'password':'why888',  
  7.     'continueURI':'http://www.verycd.com/',  
  8.     'fk':'',  
  9.     'login_submit':'登陆'  
  10. })  
  11. req = urllib2.Request(  
  12.     url = 'http://secure.verycd.com/signin',  
  13.     data = postdata  
  14. )  
  15. result = urllib2.urlopen(req)  
  16. print result.read()   

 

10.假装成浏览器访问
某些网站反感爬虫的到访，因而对爬虫一概拒绝请求
这时候咱们须要假装成浏览器，这能够经过修改http包中的header来实现

[python]  view plain copy
 
 
  1. #…  
  2.   
  3. headers = {  
  4.     'User-Agent':'Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.1.6) Gecko/20091201 Firefox/3.5.6'  
  5. }  
  6. req = urllib2.Request(  
  7.     url = 'http://secure.verycd.com/signin/*/http://www.verycd.com/',  
  8.     data = postdata,  
  9.     headers = headers  
  10. )  
  11. #...  

11.对付"反盗链"
某些站点有所谓的反盗链设置，其实说穿了很简单，

 

就是检查你发送请求的header里面，referer站点是否是他本身，

因此咱们只须要像把headers的referer改为该网站便可，以cnbeta为例：

#...
headers = {
    'Referer':'http://www.cnbeta.com/articles'
}
#...

 

headers是一个dict数据结构，你能够放入任何想要的header，来作一些假装。

例如，有些网站喜欢读取header中的X-Forwarded-For来看看人家的真实IP，能够直接把X-Forwarde-For改了。

[Python]网络爬虫（六）：一个简单的百度贴吧的小爬虫

分类： 爬虫 Python2013-05-14 21:36 1185人阅读 评论(10) 收藏 举报
[python]  view plain copy
 
 
  1. # -*- coding: utf-8 -*-  
  2. #---------------------------------------  
  3. #   程序：百度贴吧爬虫  
  4. #   版本：0.1  
  5. #   做者：why  
  6. #   日期：2013-05-14  
  7. #   语言：Python 2.7  
  8. #   操做：输入带分页的地址，去掉最后面的数字，设置一下起始页数和终点页数。  
  9. #   功能：下载对应页码内的全部页面并存储为html文件。  
  10. #---------------------------------------  
  11.    
  12. import string, urllib2  
  13.    
  14. #定义百度函数  
  15. def baidu_tieba(url,begin_page,end_page):     
  16.     for i in range(begin_page, end_page+1):  
  17.         sName = string.zfill(i,5) + '.html'#自动填充成六位的文件名  
  18.         print '正在下载第' + str(i) + '个网页，并将其存储为' + sName + '......'  
  19.         f = open(sName,'w+')  
  20.         m = urllib2.urlopen(url + str(i)).read()  
  21.         f.write(m)  
  22.         f.close()  
  23.    
  24.    
  25. #-------- 在这里输入参数 ------------------  
  26.   
  27. # 这个是山东大学的百度贴吧中某一个帖子的地址  
  28. #bdurl = 'http://tieba.baidu.com/p/2296017831?pn='  
  29. #iPostBegin = 1  
  30. #iPostEnd = 10  
  31.   
  32. bdurl = str(raw_input(u'请输入贴吧的地址，去掉pn=后面的数字：\n'))  
  33. begin_page = int(raw_input(u'请输入开始的页数：\n'))  
  34. end_page = int(raw_input(u'请输入终点的页数：\n'))  
  35. #-------- 在这里输入参数 ------------------  
  36.    
  37.   
  38. #调用  
  39. baidu_tieba(bdurl,begin_page,end_page)  

[Python]网络爬虫（七）：Python中的正则表达式教程

分类： 爬虫 Python2013-05-15 13:29 1212人阅读 评论(0) 收藏 举报
 

目录(?)[+]

 
接下来准备用糗百作一个爬虫的小例子。

可是在这以前，先详细的整理一下Python中的正则表达式的相关内容。

正则表达式在Python爬虫中的做用就像是老师点名时用的花名册同样，是必不可少的神兵利器。

 

 

1、 正则表达式基础

1.1.概念介绍

正则表达式是用于处理字符串的强大工具，它并非Python的一部分。

其余编程语言中也有正则表达式的概念，区别只在于不一样的编程语言实现支持的语法数量不一样。

它拥有本身独特的语法以及一个独立的处理引擎，在提供了正则表达式的语言里，正则表达式的语法都是同样的。

下图展现了使用正则表达式进行匹配的流程：

正则表达式的大体匹配过程是：

1.依次拿出表达式和文本中的字符比较，

2.若是每个字符都能匹配，则匹配成功；一旦有匹配不成功的字符则匹配失败。

3.若是表达式中有量词或边界，这个过程会稍微有一些不一样。

下图列出了Python支持的正则表达式元字符和语法：   

 

 

1.2. 数量词的贪婪模式与非贪婪模式

 

正则表达式一般用于在文本中查找匹配的字符串。

贪婪模式，老是尝试匹配尽量多的字符；

非贪婪模式则相反，老是尝试匹配尽量少的字符。

Python里数量词默认是贪婪的。

例如：正则表达式"ab*"若是用于查找"abbbc"，将找到"abbb"。

而若是使用非贪婪的数量词"ab*?"，将找到"a"。

 

1.3. 反斜杠的问题

与大多数编程语言相同，正则表达式里使用"\"做为转义字符，这就可能形成反斜杠困扰。

假如你须要匹配文本中的字符"\"，那么使用编程语言表示的正则表达式里将须要4个反斜杠"\\\\"：

第一个和第三个用于在编程语言里将第二个和第四个转义成反斜杠，

转换成两个反斜杠\\后再在正则表达式里转义成一个反斜杠用来匹配反斜杠\。

这样显然是很是麻烦的。

Python里的原生字符串很好地解决了这个问题，这个例子中的正则表达式可使用r"\\"表示。

一样，匹配一个数字的"\\d"能够写成r"\d"。

有了原生字符串，妈妈不再用担忧个人反斜杠问题~

 

 

2、 介绍re模块

2.1.  Compile

Python经过re模块提供对正则表达式的支持。

使用re的通常步骤是：

Step1：先将正则表达式的字符串形式编译为Pattern实例。

Step2：而后使用Pattern实例处理文本并得到匹配结果（一个Match实例）。

Step3：最后使用Match实例得到信息，进行其余的操做。

咱们新建一个re01.py来试验一下re的应用：

 

[python]  view plain copy
 
 
  1. # -*- coding: utf-8 -*-  
  2. #一个简单的re实例，匹配字符串中的hello字符串  
  3.   
  4. #导入re模块  
  5. import re  
  6.    
  7. # 将正则表达式编译成Pattern对象，注意hello前面的r的意思是“原生字符串”  
  8. pattern = re.compile(r'hello')  
  9.    
  10. # 使用Pattern匹配文本，得到匹配结果，没法匹配时将返回None  
  11. match1 = pattern.match('hello world!')  
  12. match2 = pattern.match('helloo world!')  
  13. match3 = pattern.match('helllo world!')  
  14.   
  15. #若是match1匹配成功  
  16. if match1:  
  17.     # 使用Match得到分组信息  
  18.     print match1.group()  
  19. else:  
  20.     print 'match1匹配失败！'  
  21.   
  22.   
  23. #若是match2匹配成功  
  24. if match2:  
  25.     # 使用Match得到分组信息  
  26.     print match2.group()  
  27. else:  
  28.     print 'match2匹配失败！'  
  29.   
  30.   
  31. #若是match3匹配成功  
  32. if match3:  
  33.     # 使用Match得到分组信息  
  34.     print match3.group()  
  35. else:  
  36.     print 'match3匹配失败！'  

能够看到控制台输出了匹配的三个结果：

 

下面来具体看看代码中的关键方法。

★ re.compile(strPattern[, flag]):

这个方法是Pattern类的工厂方法，用于将字符串形式的正则表达式编译为Pattern对象。

第二个参数flag是匹配模式，取值可使用按位或运算符'|'表示同时生效，好比re.I | re.M。

另外，你也能够在regex字符串中指定模式，

好比re.compile('pattern', re.I | re.M)与re.compile('(?im)pattern')是等价的。

可选值有：

  •     re.I(全拼：IGNORECASE): 忽略大小写（括号内是完整写法，下同）
  •    re.M(全拼：MULTILINE): 多行模式，改变'^'和'$'的行为（参见上图）
  •     re.S(全拼：DOTALL): 点任意匹配模式，改变'.'的行为
  •     re.L(全拼：LOCALE): 使预约字符类 \w \W \b \B \s \S 取决于当前区域设定
  •     re.U(全拼：UNICODE): 使预约字符类 \w \W \b \B \s \S \d \D 取决于unicode定义的字符属性
  •     re.X(全拼：VERBOSE): 详细模式。这个模式下正则表达式能够是多行，忽略空白字符，并能够加入注释。

 

如下两个正则表达式是等价的：

 

[python]  view plain copy
 
 
  1. # -*- coding: utf-8 -*-  
  2. #两个等价的re匹配,匹配一个小数  
  3. import re  
  4.   
  5. a = re.compile(r"""\d +  # the integral part 
  6.                    \.    # the decimal point 
  7.                    \d *  # some fractional digits""", re.X)  
  8.   
  9. b = re.compile(r"\d+\.\d*")  
  10.   
  11. match11 = a.match('3.1415')  
  12. match12 = a.match('33')  
  13. match21 = b.match('3.1415')  
  14. match22 = b.match('33')   
  15.   
  16. if match11:  
  17.     # 使用Match得到分组信息  
  18.     print match11.group()  
  19. else:  
  20.     print u'match11不是小数'  
  21.       
  22. if match12:  
  23.     # 使用Match得到分组信息  
  24.     print match12.group()  
  25. else:  
  26.     print u'match12不是小数'  
  27.       
  28. if match21:  
  29.     # 使用Match得到分组信息  
  30.     print match21.group()  
  31. else:  
  32.     print u'match21不是小数'  
  33.   
  34. if match22:  
  35.     # 使用Match得到分组信息  
  36.     print match22.group()  
  37. else:  
  38.     print u'match22不是小数'  

re提供了众多模块方法用于完成正则表达式的功能。

 

这些方法可使用Pattern实例的相应方法替代，惟一的好处是少写一行re.compile()代码，

但同时也没法复用编译后的Pattern对象。

这些方法将在Pattern类的实例方法部分一块儿介绍。

如一开始的hello实例能够简写为：

[html]  view plain copy
 
 
  1. # -*- coding: utf-8 -*-  
  2. #一个简单的re实例，匹配字符串中的hello字符串  
  3. import re  
  4.   
  5. m = re.match(r'hello', 'hello world!')  
  6. print m.group()  

re模块还提供了一个方法escape(string)，用于将string中的正则表达式元字符如*/+/?等以前加上转义符再返回

 

2.2. Match

Match对象是一次匹配的结果，包含了不少关于这次匹配的信息，可使用Match提供的可读属性或方法来获取这些信息。

属性：

  1. string: 匹配时使用的文本。
  2. re: 匹配时使用的Pattern对象。
  3. pos: 文本中正则表达式开始搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。
  4. endpos: 文本中正则表达式结束搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。
  5. lastindex: 最后一个被捕获的分组在文本中的索引。若是没有被捕获的分组，将为None。
  6. lastgroup: 最后一个被捕获的分组的别名。若是这个分组没有别名或者没有被捕获的分组，将为None。

方法：

  1. group([group1, …])：
    得到一个或多个分组截获的字符串；指定多个参数时将以元组形式返回。group1可使用编号也可使用别名；编号0表明整个匹配的子串；不填写参数时，返回group(0)；没有截获字符串的组返回None；截获了屡次的组返回最后一次截获的子串。
  2. groups([default])： 
    以元组形式返回所有分组截获的字符串。至关于调用group(1,2,…last)。default表示没有截获字符串的组以这个值替代，默认为None。
  3. groupdict([default])：
    返回以有别名的组的别名为键、以该组截获的子串为值的字典，没有别名的组不包含在内。default含义同上。
  4. start([group])： 
    返回指定的组截获的子串在string中的起始索引（子串第一个字符的索引）。group默认值为0。
  5. end([group])：
    返回指定的组截获的子串在string中的结束索引（子串最后一个字符的索引+1）。group默认值为0。
  6. span([group])：
    返回(start(group), end(group))。
  7. expand(template)： 
    将匹配到的分组代入template中而后返回。template中可使用\id或\g<id>、\g<name>引用分组，但不能使用编号0。\id与\g<id>是等价的；但\10将被认为是第10个分组，若是你想表达\1以后是字符'0'，只能使用\g<1>0。
下面来用一个py实例输出全部的内容加深理解：

 

[python]  view plain copy
 
 
  1. # -*- coding: utf-8 -*-  
  2. #一个简单的match实例  
  3.   
  4. import re  
  5. # 匹配以下内容：单词+空格+单词+任意字符  
  6. m = re.match(r'(\w+) (\w+)(?P<sign>.*)', 'hello world!')  
  7.   
  8. print "m.string:", m.string  
  9. print "m.re:", m.re  
  10. print "m.pos:", m.pos  
  11. print "m.endpos:", m.endpos  
  12. print "m.lastindex:", m.lastindex  
  13. print "m.lastgroup:", m.lastgroup  
  14.   
  15. print "m.group():", m.group()  
  16. print "m.group(1,2):", m.group(1, 2)  
  17. print "m.groups():", m.groups()  
  18. print "m.groupdict():", m.groupdict()  
  19. print "m.start(2):", m.start(2)  
  20. print "m.end(2):", m.end(2)  
  21. print "m.span(2):", m.span(2)  
  22. print r"m.expand(r'\g<2> \g<1>\g<3>'):", m.expand(r'\2 \1\3')  
  23.    
  24. ### output ###  
  25. # m.string: hello world!  
  26. # m.re: <_sre.SRE_Pattern object at 0x016E1A38>  
  27. # m.pos: 0  
  28. # m.endpos: 12  
  29. # m.lastindex: 3  
  30. # m.lastgroup: sign  
  31. # m.group(1,2): ('hello', 'world')  
  32. # m.groups(): ('hello', 'world', '!')  
  33. # m.groupdict(): {'sign': '!'}  
  34. # m.start(2): 6  
  35. # m.end(2): 11  
  36. # m.span(2): (6, 11)  
  37. # m.expand(r'\2 \1\3'): world hello!  


 

 

2.3. Pattern

Pattern对象是一个编译好的正则表达式，经过Pattern提供的一系列方法能够对文本进行匹配查找。

Pattern不能直接实例化，必须使用re.compile()进行构造，也就是re.compile()返回的对象。

Pattern提供了几个可读属性用于获取表达式的相关信息：

  1. pattern: 编译时用的表达式字符串。
  2. flags: 编译时用的匹配模式。数字形式。
  3. groups: 表达式中分组的数量。
  4. groupindex: 以表达式中有别名的组的别名为键、以该组对应的编号为值的字典，没有别名的组不包含在内。
能够用下面这个例子查看pattern的属性：

 

[python]  view plain copy
 
 
  1. # -*- coding: utf-8 -*-  
  2. #一个简单的pattern实例  
  3.   
  4. import re  
  5. p = re.compile(r'(\w+) (\w+)(?P<sign>.*)', re.DOTALL)  
  6.    
  7. print "p.pattern:", p.pattern  
  8. print "p.flags:", p.flags  
  9. print "p.groups:", p.groups  
  10. print "p.groupindex:", p.groupindex  
  11.    
  12. ### output ###  
  13. # p.pattern: (\w+) (\w+)(?P<sign>.*)  
  14. # p.flags: 16  
  15. # p.groups: 3  
  16. # p.groupindex: {'sign': 3}  

下面重点介绍一下pattern的实例方法及其使用。

 

1.match

match(string[, pos[, endpos]]) | re.match(pattern, string[, flags])：

这个方法将从string的pos下标处起尝试匹配pattern；

若是pattern结束时仍可匹配，则返回一个Match对象；

若是匹配过程当中pattern没法匹配，或者匹配未结束就已到达endpos，则返回None。

pos和endpos的默认值分别为0和len(string)；

re.match()没法指定这两个参数，参数flags用于编译pattern时指定匹配模式。

注意：这个方法并非彻底匹配。

当pattern结束时若string还有剩余字符，仍然视为成功。

想要彻底匹配，能够在表达式末尾加上边界匹配符'$'。

下面来看一个Match的简单案例：

[python]  view plain copy
 
 
  1. # encoding: UTF-8  
  2. import re  
  3.    
  4. # 将正则表达式编译成Pattern对象  
  5. pattern = re.compile(r'hello')  
  6.    
  7. # 使用Pattern匹配文本，得到匹配结果，没法匹配时将返回None  
  8. match = pattern.match('hello world!')  
  9.    
  10. if match:  
  11.     # 使用Match得到分组信息  
  12.     print match.group()  
  13.    
  14. ### 输出 ###  
  15. # hello  

 

 

 

2.search
search(string[, pos[, endpos]]) | re.search(pattern, string[, flags]): 
这个方法用于查找字符串中能够匹配成功的子串。

从string的pos下标处起尝试匹配pattern，

若是pattern结束时仍可匹配，则返回一个Match对象；

若没法匹配，则将pos加1后从新尝试匹配；

直到pos=endpos时仍没法匹配则返回None。

pos和endpos的默认值分别为0和len(string))；

re.search()没法指定这两个参数，参数flags用于编译pattern时指定匹配模式。

那么它和match有什么区别呢？

match()函数只检测re是否是在string的开始位置匹配，

search()会扫描整个string查找匹配，

 

match（）只有在0位置匹配成功的话才有返回，若是不是开始位置匹配成功的话，match()就返回none
例如：
print(re.match(‘super’, ‘superstition’).span())

会返回(0, 5)

print(re.match(‘super’, ‘insuperable’))

则返回None

search()会扫描整个字符串并返回第一个成功的匹配
例如：

print(re.search(‘super’, ‘superstition’).span())

返回(0, 5)
print(re.search(‘super’, ‘insuperable’).span())

返回(2, 7)

看一个search的实例：

 

[python]  view plain copy
 
 
  1. # -*- coding: utf-8 -*-  
  2. #一个简单的search实例  
  3.   
  4. import re  
  5.    
  6. # 将正则表达式编译成Pattern对象  
  7. pattern = re.compile(r'world')  
  8.    
  9. # 使用search()查找匹配的子串，不存在能匹配的子串时将返回None  
  10. # 这个例子中使用match()没法成功匹配  
  11. match = pattern.search('hello world!')  
  12.    
  13. if match:  
  14.     # 使用Match得到分组信息  
  15.     print match.group()  
  16.    
  17. ### 输出 ###  
  18. # world  

 

 

 

3.split

split(string[, maxsplit]) | re.split(pattern, string[, maxsplit]):
按照可以匹配的子串将string分割后返回列表。

maxsplit用于指定最大分割次数，不指定将所有分割。

 

[python]  view plain copy
 
 
  1. import re  
  2.    
  3. p = re.compile(r'\d+')  
  4. print p.split('one1two2three3four4')  
  5.    
  6. ### output ###  
  7. # ['one', 'two', 'three', 'four', '']  

 

 

4.findall

findall(string[, pos[, endpos]]) | re.findall(pattern, string[, flags]):
搜索string，以列表形式返回所有能匹配的子串。

 

[python]  view plain copy
 
 
  1. import re  
  2.    
  3. p = re.compile(r'\d+')  
  4. print p.findall('one1two2three3four4')  
  5.    
  6. ### output ###  
  7. # ['1', '2', '3', '4']  

 

 

5.finditer

finditer(string[, pos[, endpos]]) | re.finditer(pattern, string[, flags]):
搜索string，返回一个顺序访问每个匹配结果（Match对象）的迭代器。

 

[html]  view plain copy
 
 
  1. import re  
  2.    
  3. p = re.compile(r'\d+')  
  4. for m in p.finditer('one1two2three3four4'):  
  5.     print m.group(),  
  6.    
  7. ### output ###  
  8. # 1 2 3 4  

 

6.sub

sub(repl, string[, count]) | re.sub(pattern, repl, string[, count]):
使用repl替换string中每个匹配的子串后返回替换后的字符串。 
当repl是一个字符串时，可使用\id或\g<id>、\g<name>引用分组，但不能使用编号0。 
当repl是一个方法时，这个方法应当只接受一个参数（Match对象），并返回一个字符串用于替换（返回的字符串中不能再引用分组）。 
count用于指定最多替换次数，不指定时所有替换。

 

[python]  view plain copy
 
 
  1. import re  
  2.    
  3. p = re.compile(r'(\w+) (\w+)')  
  4. s = 'i say, hello world!'  
  5.    
  6. print p.sub(r'\2 \1', s)  
  7.    
  8. def func(m):  
  9.     return m.group(1).title() + ' ' + m.group(2).title()  
  10.    
  11. print p.sub(func, s)  
  12.    
  13. ### output ###  
  14. # say i, world hello!  
  15. # I Say, Hello World!  

7.subn

 

subn(repl, string[, count]) |re.sub(pattern, repl, string[, count]):
返回 (sub(repl, string[, count]), 替换次数)。

 

[python]  view plain copy
 
 
  1. import re  
  2.    
  3. p = re.compile(r'(\w+) (\w+)')  
  4. s = 'i say, hello world!'  
  5.    
  6. print p.subn(r'\2 \1', s)  
  7.    
  8. def func(m):  
  9.     return m.group(1).title() + ' ' + m.group(2).title()  
  10.    
  11. print p.subn(func, s)  
  12.    
  13. ### output ###  
  14. # ('say i, world hello!', 2)  
  15. # ('I Say, Hello World!', 2)  

至此，Python的正则表达式基本介绍就算是完成了^_^
  

[Python]网络爬虫（八）：糗事百科的网络爬虫（v0.2）源码及解析

分类： Python 爬虫2013-05-15 20:59 1208人阅读 评论(7) 收藏 举报

项目内容：

用Python写的糗事百科的网络爬虫。

使用方法：

新建一个Bug.py文件，而后将代码复制到里面后，双击运行。

程序功能：

在命令提示行中浏览糗事百科。

原理解释：

首先，先浏览一下糗事百科的主页：http://www.qiushibaike.com/hot/page/1

能够看出来，连接中page/后面的数字就是对应的页码，记住这一点为之后的编写作准备。

而后，右击查看页面源码：

观察发现，每个段子都用div标记，其中class必为content，title是发帖时间，咱们只须要用正则表达式将其“扣”出来就能够了。

明白了原理以后，剩下的就是正则表达式的内容了，能够参照这篇博文：

http://blog.csdn.net/wxg694175346/article/details/8929576

 

运行效果：

 

 

[python]  view plain copy
 
 
  1. # -*- coding: utf-8 -*-  
  2. #---------------------------------------  
  3. #   程序：糗百爬虫  
  4. #   版本：0.2  
  5. #   做者：why  
  6. #   日期：2013-05-15  
  7. #   语言：Python 2.7  
  8. #   操做：输入quit退出阅读糗事百科  
  9. #   功能：按下回车依次浏览今日的糗百热点  
  10. #   更新：解决了命令提示行下乱码的问题  
  11. #---------------------------------------  
  12.    
  13. import urllib2  
  14. import urllib  
  15. import re  
  16. import thread  
  17. import time  
  18.   
  19. #----------- 处理页面上的各类标签 -----------  
  20. class HTML_Tool:  
  21.     # 用非 贪婪模式 匹配 \t 或者 \n 或者 空格 或者 超连接 或者 图片  
  22.     BgnCharToNoneRex = re.compile("(\t|\n| |<a.*?>|<img.*?>)")  
  23.       
  24.     # 用非 贪婪模式 匹配 任意<>标签  
  25.     EndCharToNoneRex = re.compile("<.*?>")  
  26.   
  27.     # 用非 贪婪模式 匹配 任意<p>标签  
  28.     BgnPartRex = re.compile("<p.*?>")  
  29.     CharToNewLineRex = re.compile("(<br/>|</p>|<tr>|<div>|</div>)")  
  30.     CharToNextTabRex = re.compile("<td>")  
  31.   
  32.     # 将一些html的符号实体转变为原始符号  
  33.     replaceTab = [("<","<"),(">",">"),("&","&"),("&","\""),(" "," ")]  
  34.       
  35.     def Replace_Char(self,x):  
  36.         x = self.BgnCharToNoneRex.sub("",x)  
  37.         x = self.BgnPartRex.sub("\n    ",x)  
  38.         x = self.CharToNewLineRex.sub("\n",x)  
  39.         x = self.CharToNextTabRex.sub("\t",x)  
  40.         x = self.EndCharToNoneRex.sub("",x)  
  41.   
  42.         for t in self.replaceTab:  
  43.             x = x.replace(t[0],t[1])  
  44.         return x  
  45. #----------- 处理页面上的各类标签 -----------  
  46.   
  47.   
  48. #----------- 加载处理糗事百科 -----------  
  49. class HTML_Model:  
  50.       
  51.     def __init__(self):  
  52.         self.page = 1  
  53.         self.pages = []  
  54.         self.myTool = HTML_Tool()  
  55.         self.enable = False  
  56.   
  57.     # 将全部的段子都扣出来，添加到列表中而且返回列表  
  58.     def GetPage(self,page):  
  59.         myUrl = "http://m.qiushibaike.com/hot/page/" + page  
  60.         myResponse  = urllib2.urlopen(myUrl)  
  61.         myPage = myResponse.read()  
  62.         #encode的做用是将unicode编码转换成其余编码的字符串  
  63.         #decode的做用是将其余编码的字符串转换成unicode编码  
  64.         unicodePage = myPage.decode("utf-8")  
  65.   
  66.         # 找出全部class="content"的div标记  
  67.         #re.S是任意匹配模式，也就是.能够匹配换行符  
  68.         myItems = re.findall('<div.*?class="content".*?title="(.*?)">(.*?)</div>',unicodePage,re.S)  
  69.         items = []  
  70.         for item in myItems:  
  71.             # item 中第一个是div的标题，也就是时间  
  72.             # item 中第二个是div的内容，也就是内容  
  73.             items.append([item[0].replace("\n",""),item[1].replace("\n","")])  
  74.         return items  
  75.   
  76.     # 用于加载新的段子  
  77.     def LoadPage(self):  
  78.         # 若是用户未输入quit则一直运行  
  79.         while self.enable:  
  80.             # 若是pages数组中的内容小于2个  
  81.             if len(self.pages) < 2:  
  82.                 try:  
  83.                     # 获取新的页面中的段子们  
  84.                     myPage = self.GetPage(str(self.page))  
  85.                     self.page += 1  
  86.                     self.pages.append(myPage)  
  87.                 except:  
  88.                     print '没法连接糗事百科！'  
  89.             else:  
  90.                 time.sleep(1)  
  91.           
  92.     def ShowPage(self,q,page):  
  93.         for items in q:  
  94.             print u'第%d页' % page , items[0]  
  95.             print self.myTool.Replace_Char(items[1])  
  96.             myInput = raw_input()  
  97.             if myInput == "quit":  
  98.                 self.enable = False  
  99.                 break  
  100.           
  101.     def Start(self):  
  102.         self.enable = True  
  103.         page = self.page  
  104.   
  105.         print u'正在加载中请稍候......'  
  106.           
  107.         # 新建一个线程在后台加载段子并存储  
  108.         thread.start_new_thread(self.LoadPage,())  
  109.           
  110.         #----------- 加载处理糗事百科 -----------  
  111.         while self.enable:  
  112.             # 若是self的page数组中存有元素  
  113.             if self.pages:  
  114.                 nowPage = self.pages[0]  
  115.                 del self.pages[0]  
  116.                 self.ShowPage(nowPage,page)  
  117.                 page += 1  
  118.   
  119.   
  120. #----------- 程序的入口处 -----------  
  121. print u""" 
  122. --------------------------------------- 
  123.    程序：糗百爬虫 
  124.    版本：0.1 
  125.    做者：why 
  126.    日期：2013-05-15 
  127.    语言：Python 2.7 
  128.    操做：输入quit退出阅读糗事百科 
  129.    功能：按下回车依次浏览今日的糗百热点 
  130. --------------------------------------- 
  131. """  
  132.   
  133.   
  134. print u'请按下回车浏览今日的糗百内容：'  
  135. raw_input(' ')  
  136. myModel = HTML_Model()  
  137. myModel.Start() 
  

[Python]网络爬虫（九）：百度贴吧的网络爬虫（v0.4）源码及解析

分类： 爬虫 Python2013-05-16 13:48 1361人阅读 评论(10) 收藏 举报

百度贴吧的爬虫制做和糗百的爬虫制做原理基本相同，都是经过查看源码扣出关键数据，而后将其存储到本地txt文件。

 

项目内容：

用Python写的百度贴吧的网络爬虫。

使用方法：

新建一个BugBaidu.py文件，而后将代码复制到里面后，双击运行。

程序功能：

将贴吧中楼主发布的内容打包txt存储到本地。

原理解释：

首先，先浏览一下某一条贴吧，点击只看楼主并点击第二页以后url发生了一点变化，变成了：

http://tieba.baidu.com/p/2296712428?see_lz=1&pn=1

能够看出来，see_lz=1是只看楼主，pn=1是对应的页码，记住这一点为之后的编写作准备。

这就是咱们须要利用的url。

接下来就是查看页面源码。

首先把题目抠出来存储文件的时候会用到。

能够看到百度使用gbk编码，标题使用h1标记：

 

[html]  view plain copy
 
 
  1. <h1 class="core_title_txt" title="【原创】时尚首席（关于时尚，名利，事业，爱情，励志）">【原创】时尚首席（关于时尚，名利，事业，爱情，励志）</h1>  

一样，正文部分用div和class综合标记，接下来要作的只是用正则表达式来匹配便可。

运行截图：

生成的txt文件：

 

 

 

[python]  view plain copy
 
 
  1. # -*- coding: utf-8 -*-  
  2. #---------------------------------------  
  3. #   程序：百度贴吧爬虫  
  4. #   版本：0.5  
  5. #   做者：why  
  6. #   日期：2013-05-16  
  7. #   语言：Python 2.7  
  8. #   操做：输入网址后自动只看楼主并保存到本地文件  
  9. #   功能：将楼主发布的内容打包txt存储到本地。  
  10. #---------------------------------------  
  11.    
  12. import string  
  13. import urllib2  
  14. import re  
  15.   
  16. #----------- 处理页面上的各类标签 -----------  
  17. class HTML_Tool:  
  18.     # 用非 贪婪模式 匹配 \t 或者 \n 或者 空格 或者 超连接 或者 图片  
  19.     BgnCharToNoneRex = re.compile("(\t|\n| |<a.*?>|<img.*?>)")  
  20.       
  21.     # 用非 贪婪模式 匹配 任意<>标签  
  22.     EndCharToNoneRex = re.compile("<.*?>")  
  23.   
  24.     # 用非 贪婪模式 匹配 任意<p>标签  
  25.     BgnPartRex = re.compile("<p.*?>")  
  26.     CharToNewLineRex = re.compile("(<br/>|</p>|<tr>|<div>|</div>)")  
  27.     CharToNextTabRex = re.compile("<td>")  
  28.   
  29.     # 将一些html的符号实体转变为原始符号  
  30.     replaceTab = [("<","<"),(">",">"),("&","&"),("&","\""),(" "," ")]  
  31.       
  32.     def Replace_Char(self,x):  
  33.         x = self.BgnCharToNoneRex.sub("",x)  
  34.         x = self.BgnPartRex.sub("\n    ",x)  
  35.         x = self.CharToNewLineRex.sub("\n",x)  
  36.         x = self.CharToNextTabRex.sub("\t",x)  
  37.         x = self.EndCharToNoneRex.sub("",x)  
  38.   
  39.         for t in self.replaceTab:    
  40.             x = x.replace(t[0],t[1])    
  41.         return x    
  42.       
  43. class Baidu_Spider:  
  44.     # 申明相关的属性  
  45.     def __init__(self,url):    
  46.         self.myUrl = url + '?see_lz=1'  
  47.         self.datas = []  
  48.         self.myTool = HTML_Tool()  
  49.         print u'已经启动百度贴吧爬虫，咔嚓咔嚓'  
  50.     
  51.     # 初始化加载页面并将其转码储存  
  52.     def baidu_tieba(self):  
  53.         # 读取页面的原始信息并将其从gbk转码  
  54.         myPage = urllib2.urlopen(self.myUrl).read().decode("gbk")  
  55.         # 计算楼主发布内容一共有多少页  
  56.         endPage = self.page_counter(myPage)  
  57.         # 获取该帖的标题  
  58.         title = self.find_title(myPage)  
  59.         print u'文章名称：' + title  
  60.         # 获取最终的数据  
  61.         self.save_data(self.myUrl,title,endPage)  
  62.   
  63.     #用来计算一共有多少页  
  64.     def page_counter(self,myPage):  
  65.         # 匹配 "共有<span class="red">12</span>页" 来获取一共有多少页  
  66.         myMatch = re.search(r'class="red">(\d+?)</span>', myPage, re.S)  
  67.         if myMatch:    
  68.             endPage = int(myMatch.group(1))  
  69.             print u'爬虫报告：发现楼主共有%d页的原创内容' % endPage  
  70.         else:  
  71.             endPage = 0  
  72.             print u'爬虫报告：没法计算楼主发布内容有多少页！'  
  73.         return endPage  
  74.   
  75.     # 用来寻找该帖的标题  
  76.     def find_title(self,myPage):  
  77.         # 匹配 <h1 class="core_title_txt" title="">xxxxxxxxxx</h1> 找出标题  
  78.         myMatch = re.search(r'<h1.*?>(.*?)</h1>', myPage, re.S)  
  79.         title = u'暂无标题'  
  80.         if myMatch:  
  81.             title  = myMatch.group(1)  
  82.         else:  
  83.             print u'爬虫报告：没法加载文章标题！'  
  84.         # 文件名不能包含如下字符： \ / ： * ? " < > |  
  85.         title = title.replace('\\','').replace('/','').replace(':','').replace('*','').replace('?','').replace('"','').replace('>','').replace('<','').replace('|','')  
  86.         return title  
  87.   
  88.   
  89.     # 用来存储楼主发布的内容  
  90.     def save_data(self,url,title,endPage):  
  91.         # 加载页面数据到数组中  
  92.         self.get_data(url,endPage)  
  93.         # 打开本地文件  
  94.         f = open(title+'.txt','w+')  
  95.         f.writelines(self.datas)  
  96.         f.close()  
  97.         print u'爬虫报告：文件已下载到本地并打包成txt文件'  
  98.         print u'请按任意键退出...'  
  99.         raw_input();  
  100.   
  101.     # 获取页面源码并将其存储到数组中  
  102.     def get_data(self,url,endPage):  
  103.         url = url + '&pn='  
  104.         for i in range(1,endPage+1):  
  105.             print u'爬虫报告：爬虫%d号正在加载中...' % i  
  106.             myPage = urllib2.urlopen(url + str(i)).read()  
  107.             # 将myPage中的html代码处理并存储到datas里面  
  108.             self.deal_data(myPage.decode('gbk'))  
  109.               
  110.   
  111.     # 将内容从页面代码中抠出来  
  112.     def deal_data(self,myPage):  
  113.         myItems = re.findall('id="post_content.*?>(.*?)</div>',myPage,re.S)  
  114.         for item in myItems:  
  115.             data = self.myTool.Replace_Char(item.replace("\n","").encode('gbk'))  
  116.             self.datas.append(data+'\n')  
  117.   
  118.   
  119.   
  120. #-------- 程序入口处 ------------------  
  121. print u"""#--------------------------------------- 
  122. #   程序：百度贴吧爬虫 
  123. #   版本：0.5 
  124. #   做者：why 
  125. #   日期：2013-05-16 
  126. #   语言：Python 2.7 
  127. #   操做：输入网址后自动只看楼主并保存到本地文件 
  128. #   功能：将楼主发布的内容打包txt存储到本地。 
  129. #--------------------------------------- 
  130. """  
  131.   
  132. # 以某小说贴吧为例子  
  133. # bdurl = 'http://tieba.baidu.com/p/2296712428?see_lz=1&pn=1'  
  134.   
  135. print u'请输入贴吧的地址最后的数字串：'  
  136. bdurl = 'http://tieba.baidu.com/p/' + str(raw_input(u'http://tieba.baidu.com/p/'))   
  137.   
  138. #调用  
  139. mySpider = Baidu_Spider(bdurl)  
  140. mySpider.baidu_tieba()  
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程