Python爬虫基础

来源：互联网发布：caffe model zoo 编辑：程序博客网时间：2024/06/16 16:02

一、基础了解：

1.什么是爬虫

爬虫，即网络爬虫，大家可以理解为在网络上爬行的一直蜘蛛，互联网就比作一张大网，而爬虫便是在这张网上爬来爬去的蜘蛛咯，如果它遇到资源，那么它就会抓取下来。想抓取什么？这个由你来控制它咯。

比如它在抓取一个网页，在这个网中他发现了一条道路，其实就是指向网页的超链接，那么它就可以爬到另一张网上来获取数据。这样，整个连在一起的大网对这之蜘蛛来说触手可及，分分钟爬下来不是事儿。

2.浏览网页的过程

在用户浏览网页的过程中，我们可能会看到许多好看的图片，比如 http://image.baidu.com/ ，我们会看到几张的图片以及百度搜索框，这个过程其实就是用户输入网址之后，经过DNS服务器，找到服务器主机，向服务器发出一个请求，服务器经过解析之后，发送给用户的浏览器 HTML、JS、CSS 等文件，浏览器解析出来，用户便可以看到形形色色的图片了。

因此，用户看到的网页实质是由 HTML 代码构成的，爬虫爬来的便是这些内容，通过分析和过滤这些 HTML 代码，实现对图片、文字等资源的获取。

3.URL的含义

URL，即统一资源定位符，也就是我们说的网址，统一资源定位符是对可以从互联网上得到的资源的位置和访问方法的一种简洁的表示，是互联网上标准资源的地址。互联网上的每个文件都有一个唯一的URL，它包含的信息指出文件的位置以及浏览器应该怎么处理它。

URL的格式由三部分组成：
①第一部分是协议(或称为服务方式)。
②第二部分是存有该资源的主机IP地址(有时也包括端口号)。
③第三部分是主机资源的具体地址，如目录和文件名等。

爬虫爬取数据时必须要有一个目标的URL才可以获取数据，因此，它是爬虫获取数据的基本依据，准确理解它的含义对爬虫学习有很大帮助。

4. 爬虫框架

下面是它的官方介绍：
HTML, XML源数据选择及提取的内置支持
（1）提供了一系列在spider之间共享的可复用的过滤器(即 Item Loaders)，对智能处理爬取数据提供了内置支持。
（2）通过 feed导出提供了多格式(JSON、CSV、XML)，多存储后端(FTP、S3、本地文件系统)的内置支持
（3）提供了media pipeline，可以自动下载爬取到的数据中的图片(或者其他资源)。
（4）高扩展性：您可以通过使用 signals ，设计好的API(中间件, extensions, pipelines)来定制实现您的功能。
内置的中间件及扩展为下列功能提供了支持:
cookies and session 处理
HTTP 压缩
HTTP 认证
HTTP 缓存
user-agent模拟
robots.txt
爬取深度限制
（5）针对非英语语系中不标准或者错误的编码声明, 提供了自动检测以及健壮的编码支持。
（6）支持根据模板生成爬虫。在加速爬虫创建的同时，保持在大型项目中的代码更为一致。详细内容请参阅 genspider 命令。
（7）针对多爬虫下性能评估、失败检测，提供了可扩展的状态收集工具。
（8）提供交互式shell终端 , 为您测试XPath表达式，编写和调试爬虫提供了极大的方便
（9）提供 System service, 简化在生产环境的部署及运行
（10）内置 Web service, 使您可以监视及控制您的机器
（11）内置 Telnet终端，通过在Scrapy进程中钩入Python终端，使您
可以查看并且调试爬虫
（12）Logging 为您在爬取过程中捕捉错误提供了方便
（13）支持 Sitemaps 爬取
（14）具有缓存的DNS解析器

二、Urllib库的基本使用

1.分分钟扒一个网页下来

其中Python urllib和urllib2 库的用法：urllib和urllib2库是学习Python爬虫最基本的库，利用这个库我们可以得到网页的内容，并对内容用正则表达式提取分析，得到我们想要的结果

怎样扒网页呢？其实就是根据URL来获取它的网页信息，虽然我们在浏览器中看到的是一幅幅优美的画面，但是其实是由浏览器解释才呈现出来的，实质它是一段HTML代码，加 JS、CSS，如果把网页比作一个人，那么HTML便是他的骨架，JS便是他的肌肉，CSS便是它的衣服。所以最重要的部分是存在于HTML中的，下面我们就写个例子来扒一个网页下来。
本篇涉及的代码都基于Python版本2.7

import urllib2  response = urllib2.urlopen("http://www.baidu.com")print response.read()  # 读取源码

这个网页的源码已经被我们扒下来了

2. 分析扒网页的方法

response = urllib2.urlopen("http://www.baidu.com")

首先我们调用的是urllib2库里面的urlopen方法，传入一个URL，这个网址是百度首页，协议是HTTP协议，当然你也可以把HTTP换做FTP,FILE,HTTPS 等等，只是代表了一种访问控制协议，urlopen一般接受三个参数，它的参数如下：

urlopen(url, data, timeout)

其中urlopen一般接受三个参数，它的参数如下：
第一个参数url即为URL，第二个参数data是访问URL时要传送的数据，第三个timeout是设置超时时间。

第二三个参数是可以不传送的，data默认为空None，timeout默认为 socket._GLOBAL_DEFAULT_TIMEOUT

第一个参数URL是必须要传送的，在这个例子里面我们传送了百度的URL，执行urlopen方法之后，返回一个response对象，返回信息便保存在这里面。

print response.read()

response对象有一个read方法，可以返回获取到的网页内容。
运行结果：

<html><head>    <meta http-equiv="content-type" content="text/html;charset=utf-8">    <meta http-equiv="X-UA-Compatible" content="IE=Edge">    <meta content="always" name="referrer">    <meta name="theme-color" content="#2932e1">    <link rel="shortcut icon" href="/favicon.ico" type="image/x-icon" />    <link rel="search" type="application/opensearchdescription+xml" href="/content-search.xml" title="百度搜索" />     <link rel="icon" sizes="any" mask href="//www.baidu.com/img/baidu.svg">    <link rel="dns-prefetch" href="//s1.bdstatic.com"/>    <link rel="dns-prefetch" href="//t1.baidu.com"/>    <link rel="dns-prefetch" href="//t2.baidu.com"/>    <link rel="dns-prefetch" href="//t3.baidu.com"/>    <link rel="dns-prefetch" href="//t10.baidu.com"/>    <link rel="dns-prefetch" href="//t11.baidu.com"/>    <link rel="dns-prefetch" href="//t12.baidu.com"/>    <link rel="dns-prefetch" href="//b1.bdstatic.com"/>    ......    ......

如果不加read()方法，直接打印出了该对象的描述：

<addinfourl at 63493304 whose fp = <socket._fileobject object at 0x03C8A670>>

3.构造Requset

实上面的urlopen参数可以传入一个request请求,它其实就是一个Request类的实例，构造时需要传入Url,Data等等的内容。比如上面的两行代码，我们可以这么改写

import urllib2request = urllib2.Request("http://www.baidu.com")response = urllib2.urlopen(request)print response.read()

运行结果是完全一样的，只不过中间多了一个request对象，推荐大家这么写，因为在构建请求时还需要加入好多内容，通过构建一个request，服务器响应请求得到应答，这样显得逻辑上清晰明确。

4.POST和GET数据传送

上面的程序演示了最基本的网页抓取，不过，现在大多数网站都是动态网页，需要你动态地传递参数给它，它做出对应的响应。所以，在访问时，我们需要传递数据给它。最常见的情况是什么？对了，就是登录注册的时候呀。

把数据用户名和密码传送到一个URL，然后你得到服务器处理之后的响应，这个该怎么办？下面让我来为小伙伴们揭晓吧！

数据传送分为POST和GET两种方式，两种方式有什么区别呢？

最重要的区别是GET方式是直接以链接形式访问，链接中包含了所有的参数，当然如果包含了密码的话是一种不安全的选择，不过你可以直观地看到自己提交了什么内容。POST则不会在网址上显示所有的参数，不过如果你想直接查看提交了什么就不太方便了，大家可以酌情选择。

POST方式：
上面我们说了data参数是干嘛的？对了，它就是用在这里的，我们传送的数据就是这个参数data，下面演示一下POST方式。

import urllibimport urllib2values = {"username":"xxxxx","password":"XXXX"}data = urllib.urlencode(values) url = "https://passport.csdn.net/account/login?from=http://my.csdn.net/my/mycsdn"request = urllib2.Request(url,data)response = urllib2.urlopen(request)print response.read()

我们引入了urllib库，现在我们模拟登陆CSDN，当然上述代码可能登陆不进去，因为还要做一些设置头部header的工作，或者还有一些参数重点内容没有设置全，还没有提及到在此就不写上去了，在此只是说明登录的原理。我们需要定义一个字典，名字为values，参数我设置了username和 password，下面利用urllib的urlencode方法将字典编码，命名为data，构建request时传入两个参数，url和data，运行程序，即可实现登陆，返回的便是登陆后呈现的页面内容。当然你可以自己搭建一个服务器来测试一下。

运行结果：

<html>  <head>    <meta charset="utf-8" />    <meta http-equiv="X-UA-Compatible" content="IE=edge"/>    <meta property="qc:admins" content="24530273213633466654" />    <meta name="viewport" content="width=device-width, initial-scale=1.0"/>    <title>帐号登录</title>    ........    ........

GET方式：
至于GET方式我们可以直接把参数写到网址上面，直接构建一个带参数的URL出来即可

values={}values['username'] = "任一账号"values['password']="密码"data = urllib.urlencode(values) url = "http://passport.csdn.net/account/login"geturl = url + "?"+dataprint(geturl)request = urllib2.Request(geturl)response = urllib2.urlopen(request)print response.read()

print geturl，打印输出一下url，发现其实就是原来的url加？然后加编码后的参数

http://passport.csdn.net/account/login?username=****&passwor

三、Urllib库的高级用法

1.设置Headers

有些网站不会同意程序直接用上面的方式进行访问，如果识别有问题，那么站点根本不会响应，所以为了完全模拟浏览器的工作，我们需要设置一些Headers 的属性。

首先，打开我们的浏览器，调试浏览器F12，打开网络监听，示意如下，比如知乎，点登录之后，我们会发现登陆之后界面都变化了，出现一个新的界面，实质上这个页面包含了许许多多的内容，这些内容也不是一次性就加载完成的，实质上是执行了好多次请求，一般是首先请求HTML文件，然后加载JS，CSS 等等，经过多次请求之后，网页的骨架和肌肉全了，整个网页的效果也就出来了。关于调试浏览器F12在另一篇博文中介绍。

下面的这个例子只是说明了怎样设置的headers，其中，agent就是请求的身份，如果没有写入请求身份，那么服务器不一定会响应，所以可以在headers中设置agent

import urllib  import urllib2  url = 'http://www.server.com/login' # 任意一个网站登陆user_agent = 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)'  values = {'username' : 'cqc',  'password' : 'XXXX' }  headers = { 'User-Agent' : user_agent }  data = urllib.urlencode(values)  request = urllib2.Request(url, data, headers)  response = urllib2.urlopen(request)  page = response.read()print(page)

这样，我们设置了一个headers，在构建request时传入，在请求时，就加入了headers传送，服务器若识别了是浏览器发来的请求，就会得到响应。

另外，我们还有对付”反盗链”的方式，对付防盗链，服务器会识别headers中的referer是不是它自己，如果不是，有的服务器不会响应，所以我们还可以在headers中加入referer

例如我们可以构建下面的headers

headers = { 'User-Agent' : 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)', 'Referer':'http://www.zhihu.com/articles' }

同上面的方法，在传送请求时把ers传入Request参数里，这样就能应付防盗链了。

另外headers的一些属性，下面的需要特别注意一下：

User-Agent : 有些服务器或 Proxy 会通过该值来判断是否是浏览器发出的请求Content-Type : 在使用 REST 接口时，服务器会检查该值，用来确定 HTTP Body 中的内容该怎样解析。application/ ： 在 XML RPC，如 RESTful/SOAP 调用时使用application/json ： 在 JSON RPC 调用时使用application/x-www-form-urlencoded ： 浏览器提交 Web 表单时使用在使用服务器提供的 RESTful 或 SOAP 服务时， Content-Type 设置错误会导致服务器拒绝服务

其他的有必要的可以审查浏览器的headers内容，在构建时写入同样的数据即可

2. Proxy（代理）的设置

urllib2 默认会使用 http_proxy 来设置 HTTP Proxy。假如一个网站它会限制某一段时间某个IP 的访问次数，如果访问次数过多，它会禁止你的访问。所以你可以设置一些来帮助你做工作，每隔一段时间换一个代理，网站君都不知道是谁在捣鬼了，这酸爽！

下面一段代码说明了proxy的设置用法

import urllib2enable_proxy = Trueproxy_handler = urllib2.ProxyHandler({"http" : 'http://some-proxy.com:8080'})null_proxy_handler = urllib2.ProxyHandler({})if enable_proxy:    opener = urllib2.build_opener(proxy_handler)else:    opener = urllib2.build_opener(null_proxy_handler)urllib2.install_opener(opener)

3.Timeout 设置

上一节已经说过urlopen方法了，第三个参数就是timeout的设置，可以设置等待多久超时，为了解决一些网站实在响应过慢而造成的影响。

例如下面的代码,如果第二个参数为空那么要特别指定是timeout是多少，写明形参，如果data已经传入，则不必。

import urllib2response = urllib2.urlopen('http://www.baidu.com', timeout=10)

import urllib2response = urllib2.urlopen('http://www.baidu.com',data, 10)

4.使用 HTTP 的 PUT 和 DELETE 方法

http协议有六种请求方法，get,put,delete,post,options，我们有时候需要用到PUT方式或者DELETE方式请求。

PUT：这个方法比较少见。HTML表单也不支持这个。本质上来讲， PUT和POST极为相似，都是向服务器发送数据，但它们之间有一个重要区别，PUT通常指定了资源的存放位置，而POST则没有，POST的数据存放位置由服务器自己决定。

DELETE：删除某一个资源。基本上这个也很少见，不过还是有一些地方比如amazon的S3云服务里面就用的这个方法来删除资源。

如果要使用 HTTP PUT 和 DELETE ，只能使用比较低层的 httplib 库。虽然如此，我们还是能通过下面的方式，使 urllib2 能够发出 PUT 或DELETE 的请求，不过用的次数的确是少，在这里提一下。

import urllib2request = urllib2.Request(uri, data=data)request.get_method = lambda: 'PUT' # or 'DELETE'response = urllib2.urlopen(request)

5.使用DebugLog

可以通过下面的方法把 Debug Log 打开，这样收发包的内容就会在屏幕上打印出来，方便调试，这个也不太常用，仅提一下

import urllib2httpHandler = urllib2.HTTPHandler(debuglevel=1)httpsHandler = urllib2.HTTPSHandler(debuglevel=1)opener = urllib2.build_opener(httpHandler, httpsHandler)urllib2.install_opener(opener)response = urllib2.urlopen('http://www.baidu.com')

以上便是一部分高级特性，前三个是重要内容，在后面，还有cookies的设置还有异常的处理，小伙伴们加油！

四、URLError异常处理

本节在这里主要说的是URLError还有HTTPError，以及对它们的一些处理

1.URLError

首先解释下URLError可能产生的原因：
（1）网络无连接，即本机无法上网
（2）连接不到特定的服务器
（3）服务器不存在
在代码中，我们需要用try-except语句来包围并捕获相应的异常。下面是一个例子，先感受下它的风骚

import urllib2requset = urllib2.Request('http://www.xxxxx.com')try:    urllib2.urlopen(requset)except urllib2.URLError, e:    print e.reason

我们利用了 urlopen方法访问了一个不存在的网址，运行结果如下：

[Errno 10060]

2.HTTPError

HTTPError是URLError的子类，在你利用urlopen方法发出一个请求时，服务器上都会对应一个应答对象response，其中它包含一个数字”状态码”。举个例子，假如response是一个”重定向”，需到别的地址获取文档，urllib2将对此进行处理。

其他不能处理的，urlopen会产生一个HTTPError，对应相应的状态吗，HTTP状态码表示HTTP协议所返回的响应的状态。下面将状态码归结如下：

100：继续 客户端应当继续发送请求。客户端应当继续发送请求的剩余部分，或者如果请求已经完成，忽略这个响应。101： 转换协议 在发送完这个响应最后的空行后，将会切换到在Upgrade 消息头中定义的那些协议。只有在切换新的协议更有好处的时候才应该采取类似措施。102：继续处理 由WebDAV（RFC 2518）扩展的状态码，代表处理将被继续执行。200：请求成功 处理方式：获得响应的内容，进行处理201：请求完成，结果是创建了新资源。新创建资源的URI可在响应的实体中得到 处理方式：爬虫中不会遇到202：请求被接受，但处理尚未完成 处理方式：阻塞等待204：服务器端已经实现了请求，但是没有返回新的信 息。如果客户是用户，则无须为此更新自身的文档视图。 处理方式：丢弃300：该状态码不被HTTP/1.0的应用程序直接使用， 只是作为3XX类型回应的默认解释。存在多个可用的被请求资源。 处理方式：若程序中能够处理，则进行进一步处理，如果程序中不能处理，则丢弃301：请求到的资源都会分配一个永久的URL，这样就可以在将来通过该URL来访问此资源 处理方式：重定向到分配的URL302：请求到的资源在一个不同的URL处临时保存 处理方式：重定向到临时的URL304：请求的资源未更新 处理方式：丢弃400：非法请求 处理方式：丢弃401：未授权 处理方式：丢弃403：禁止 处理方式：丢弃404：没有找到 处理方式：丢弃500：服务器内部错误 服务器遇到了一个未曾预料的状况，导致了它无法完成对请求的处理。一般来说，这个问题都会在的源代码出现错误时出现。501：服务器无法识别 服务器不支持当前请求所需要的某个功能。当服务器无法识别请求的方法，并且无法支持其对任何资源的请求。502：错误网关 作为网关或者工作的服务器尝试执行请求时，从上游服务器接收到无效的响应。503：服务出错 由于临时的维护或者过载，服务器当前无法处理请求。这个状况是临时的，并且将在一段时间以后恢复。

HTTPError实例产生后会有一个code属性，这就是是服务器发送的相关错误号。
因为urllib2可以为你处理重定向，也就是3开头的代号可以被处理，并且100-299范围的号码指示成功，所以你只能看到400-599的错误号码。

下面我们写一个例子来感受一下，捕获的异常是HTTPError，它会带有一个code属性，就是错误代号，另外我们又打印了reason属性，这是它的父类URLError的属性。

import urllib2req = urllib2.Request('http://blog.csdn.net/cqcre')try:    urllib2.urlopen(req)except urllib2.HTTPError, e:    print e.code    print e.reason

运行结果：

403Forbidden

错误代号是403，错误原因是Forbidden，说明服务器禁止访问。

我们知道，HTTPError的父类是URLError，根据经验，父类的异常应当写到子类异常的后面，如果子类捕获不到，那么可以捕获父类的异常，所以上述的代码可以这么改写：

import urllib2req = urllib2.Request('http://blog.csdn.net/cqcre')try:    urllib2.urlopen(req)except urllib2.HTTPError, e:    print e.codeexcept urllib2.URLError, e:    print e.reasonelse:    print "OK"

如果捕获到了HTTPError，则输出code，不会再处理URLError异常。如果发生的不是HTTPError，则会去捕获URLError异常，输出错误原因。

另外还可以加入 hasattr属性提前对属性进行判断，代码改写如下：

import urllib2req = urllib2.Request('http://blog.csdn.net/cqcre')try:    urllib2.urlopen(req)except urllib2.URLError, e:    if hasattr(e,"code"):        print e.code    if hasattr(e,"reason"):        print e.reasonelse:    print "OK"

首先对异常的属性进行判断，以免出现属性输出报错的现象。

五、Cookie的使用

上一节我们研究了一下爬虫的异常处理问题，那么接下来我们一起来看一下Cookie的使用。

为什么要使用Cookie呢？

Cookie，指某些网站为了辨别用户身份、进行session跟踪而储存在用户本地终端上的数据（通常经过加密）

比如说有些网站需要登录后才能访问某个页面，在登录之前，你想抓取某个页面内容是不允许的。那么我们可以利用Urllib2库保存我们登录的Cookie，然后再抓取其他页面就达到目的了。

在此之前呢，我们必须先介绍一个opener的概念。

1.Opener

当你获取一个URL你使用一个opener(一个urllib2.OpenerDirector的实例)。在前面，我们都是使用的默认的opener，也就是urlopen。它是一个特殊的opener，可以理解成opener的一个特殊实例，传入的参数仅仅是url，timeout。

如果我们需要用到Cookie，只用这个opener是不能达到目的的，所以我们需要创建更一般的opener来实现对Cookie的设置。

2.Cookielib

cookielib模块的主要作用是提供可存储cookie的对象，以便于与urllib2模块配合使用来访问Internet资源。 Cookielib模块非常强大，我们可以利用本模块的CookieJar类的对象来捕获cookie并在后续连接请求时重新发送，比如可以实现模拟登录功能。该模块主要的对象有CookieJar、FileCookieJar、MozillaCookieJar、LWPCookieJar。

它们的关系：CookieJar —-派生—->FileCookieJar —-派生—–>MozillaCookieJar和LWPCookieJar

1）获取Cookie保存到变量
首先，我们先利用CookieJar对象实现获取cookie的功能，到变量中，先来感受一下

import urllib2import cookielib#声明一个CookieJar对象实例来保存cookiecookie = cookielib.CookieJar()#利用urllib2库的HTTPCookieProcessor对象来创建cookie处理器handler=urllib2.HTTPCookieProcessor(cookie)#通过handler来构建openeropener = urllib2.build_opener(handler)#此处的open方法同urllib2的urlopen方法，也可以传入requestresponse = opener.open('http://www.baidu.com')for item in cookie:    print 'Name = '+item.name    print 'Value = '+item.value

我们使用以上方法将cookie保存到变量中，然后打印出了cookie中的值，运行结果如下：

Name = BAIDUIDValue = 4F18C7F9B9790FDD7C7D4E6E820AFD00:FG=1Name = BIDUPSIDValue = 4F18C7F9B9790FDD7C7D4E6E820AFD00Name = H_PS_PSSIDValue = 1438_21091_17001_20927Name = PSTMValue = 1500474009Name = BDSVRTMValue = 0Name = BD_HOMEValue = 0

2）保存Cookie到文件
在上面的方法中，我们将cookie保存到了cookie这个变量中，如果我们想将cookie保存到文件中该怎么做呢？这时，我们就要用到

FileCookieJar这个对象了，在这里我们使用它的子类MozillaCookieJar来实现Cookie的保存

import cookielibimport urllib2#设置保存cookie的文件，同级目录下的cookie.txtfilename = 'cookie.txt'#声明一个MozillaCookieJar对象实例来保存cookie，之后写入文件cookie = cookielib.MozillaCookieJar(filename)#利用urllib2库的HTTPCookieProcessor对象来创建cookie处理器handler = urllib2.HTTPCookieProcessor(cookie)#通过handler来构建openeropener = urllib2.build_opener(handler)#创建一个请求，原理同urllib2的urlopenresponse = opener.open("http://www.baidu.com")#保存cookie到文件cookie.save(ignore_discard=True, ignore_expires=True)

关于最后save方法的两个参数在此说明一下：

ignore_discard: save even cookies set to be discarded.ignore_expires: save even cookies that have expiredThe file is overwritten if it already exists

由此可见，ignore_discard的意思是即使cookies将被丢弃也将它保存下来，ignore_expires的意思是如果在该文件中 cookies已经存在，则覆盖原文件写入，在这里，我们将这两个全部设置为True。运行之后，cookies将被保存到cookie.txt文件中，我们查看一下内容

# Netscape HTTP Cookie File# http://curl.haxx.se/rfc/cookie_spec.html# This is a generated file!  Do not edit..baidu.com  TRUE    /   FALSE   3647958166  BAIDUID 9DBDB8C9B6F3A63E4BAB7A3B5C785054:FG=1.baidu.com  TRUE    /   FALSE   3647958166  BIDUPSID    9DBDB8C9B6F3A63E4BAB7A3B5C785054.baidu.com  TRUE    /   FALSE       H_PS_PSSID  1441_21090_22073.baidu.com  TRUE    /   FALSE   3647958166  PSTM    1500474523www.baidu.com   FALSE   /   FALSE       BDSVRTM 0www.baidu.com   FALSE   /   FALSE       BD_HOME 0

3）从文件中获取Cookie并访问
那么我们已经做到把Cookie保存到文件中了，如果以后想使用，可以利用下面的方法来读取cookie并访问网站，感受一下

import cookielibimport urllib2#创建MozillaCookieJar实例对象cookie = cookielib.MozillaCookieJar()#从文件中读取cookie内容到变量cookie.load('cookie.txt', ignore_discard=True, ignore_expires=True)#创建请求的requestreq = urllib2.Request("http://www.baidu.com")#利用urllib2的build_opener方法创建一个openeropener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cookie))response = opener.open(req)print response.read()

设想，如果我们的 cookie.txt 文件中保存的是某个人登录百度的cookie，那么我们提取出这个cookie文件内容，就可以用以上方法模拟这个人的账号登录百度。

4）利用cookie模拟网站登录
下面我们以我们学校的为例，利用cookie实现模拟登录，并将cookie信息保存到文本文件中

import urllibimport urllib2import cookielibfilename = 'cookie.txt'#声明一个MozillaCookieJar对象实例来保存cookie，之后写入文件cookie = cookielib.MozillaCookieJar(filename)opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cookie))postdata = urllib.urlencode({            'stuid':'201200131012',            'pwd':'23342321'        })#登录教务系统的URLloginUrl = 'http://jwxt.sdu.edu.cn:7890/pls/wwwbks/bks_login2.login'#模拟登录，并把cookie保存到变量result = opener.open(loginUrl,postdata)#保存cookie到cookie.txt中cookie.save(ignore_discard=True, ignore_expires=True)#利用cookie请求访问另一个网址，此网址是成绩查询网址gradeUrl = 'http://jwxt.sdu.edu.cn:7890/pls/wwwbks/bkscjcx.curscopre'#请求访问成绩查询网址result = opener.open(gradeUrl)print result.read()

以上程序的原理如下

创建一个带有cookie的opener，在访问登录的URL时，将登录后的cookie保存下来，然后利用这个cookie来访问其他网址。

如登录之后才能查看的查询呀，本学期课表呀等等网址，模拟登录就这么实现啦，我们现在可以顺利获取网站信息了，接下来就是把网站里面有效内容提取出来，下一节我们去会会正则表达式！

六、正则表达式

在前面我们已经搞定了怎样获取页面的内容，不过还差一步，这么多杂乱的代码夹杂文字我们怎样把它提取出来整理呢？下面就开始介绍一个十分强大的工具，正则表达式！

1.了解正则表达式

正则表达式是对字符串操作的一种公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。

正则表达式是用来匹配字符串非常强大的工具，在其他编程语言中同样有正则表达式的概念，Python同样不例外，利用了正则表达式，我们想要从返回的页面内容提取出我们想要的内容就易如反掌了。

正则表达式的大致匹配过程是：
1.依次拿出表达式和文本中的字符比较，
2.如果每一个字符都能匹配，则匹配成功；一旦有匹配不成功的字符则匹配失败。
3.如果表达式中有量词或边界，这个过程会稍微有一些不同。

2.正则表达式的语法规则

Python中正则表达式的一些匹配规则这里就不介绍了

3.正则表达式相关注解

（1）数量词的贪婪模式与非贪婪模式
正则表达式通常用于在文本中查找匹配的字符串。Python里数量词默认是贪婪的（在少数语言里也可能是默认非贪婪），总是尝试匹配尽可能多的字符；非贪婪的则相反，总是尝试匹配尽可能少的字符。例如：正则表达式”ab*”如果用于查找”abbbc，将找到”abbb”。而如果使用非贪婪的数量词”ab*?”，将找到”a”。

注：我们一般使用非贪婪模式来提取。

（2）反斜杠问题
与大多数相同，正则表达式里使用”\”作为转义字符，这就可能造成反斜杠困扰。假如你需要匹配文本中的字符”\”，那么使用编程语言表示的正则表达式里将需要4个反斜杠”\\”：前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。

Python里的原生字符串很好地解决了这个问题，这个例子中的正则表达式可以使用r”\”表示。同样，匹配一个数字的”\d”可以写成r”\d”。有了原生字符串，就不用担心是不是漏写了反斜杠，写出来的表达式也更直观。

4.Python Re模块

ython 自带了re模块，它提供了对正则表达式的支持。主要用到的方法列举如下：

#返回pattern对象re.compile(string[,flag])  #以下为匹配所用函数re.match(pattern, string[, flags])re.search(pattern, string[, flags])re.split(pattern, string[, maxsplit])re.findall(pattern, string[, flags])re.finditer(pattern, string[, flags])re.sub(pattern, repl, string[, count])re.subn(pattern, repl, string[, count])

在介绍这几个方法之前，我们先来介绍一下pattern的概念，pattern可以理解为一个匹配模式，那么我们怎么获得这个匹配模式呢？很简单，我们需要利用re.compile方法就可以。例如

pattern = re.compile(r'hello')

在参数中我们传入了原生字符串对象，通过compile方法编译生成一个pattern对象，然后我们利用这个对象来进行进一步的匹配。

另外大家可能注意到了另一个参数 flags，在这里解释一下这个参数的含义：

参数是匹配模式，取值可以使用按位或运算符’|’表示同时生效，比如re.I | re.M。

可选值有：

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): 详细模式。这个模式下正则表达式可以是多行，忽略空白字符，并可以加入注释。

在刚才所说的另外几个方法例如 re.match 里我们就需要用到这个pattern了，下面我们一一介绍。

注：以下七个方法中的s同样是代表匹配模式的意思，如果在pattern生成时已经指明了flags，那么在下面的方法中就不需要传入这个参数了。
（1）re.match(pattern, string[, flags])
这个方法将会从string（我们要匹配的字符串）的开头开始，尝试匹配pattern，一直向后匹配，如果遇到无法匹配的字符，立即返回 None，如果匹配未结束已经到达string的末尾，也会返回None。两个结果均表示匹配失败，否则匹配pattern成功，同时匹配终止，不再对 string向后匹配。下面我们通过一个例子理解一下：

# -*- coding: utf-8 -*-#导入re模块import re# 将正则表达式编译成Pattern对象，注意hello前面的r的意思是“原生字符串”pattern = re.compile(r'hello')# 使用re.match匹配文本，获得匹配结果，无法匹配时将返回Noneresult1 = re.match(pattern,'hello')result2 = re.match(pattern,'helloo CQC!')result3 = re.match(pattern,'helo CQC!')result4 = re.match(pattern,'hello CQC!')#如果1匹配成功if result1:    # 使用Match获得分组信息    print result1.group()else:    print '1匹配失败！'#如果2匹配成功if result2:    # 使用Match获得分组信息    print result2.group()else:    print '2匹配失败！'#如果3匹配成功if result3:    # 使用Match获得分组信息    print result3.group()else:    print '3匹配失败！'#如果4匹配成功if result4:    # 使用Match获得分组信息    print result4.group()else:    print '4匹配失败！'

运行结果：

hellohello3匹配失败！hello

匹配分析

1.第一个匹配，pattern正则表达式为’hello’，我们匹配的目标字符串string也为hello，从头至尾完全匹配，匹配成功。

2.第二个匹配，string为helloo CQC，从string头开始匹配pattern完全可以匹配，pattern匹配结束，同时匹配终止，后面的o CQC不再匹配，返回匹配成功的信息。

3.第三个匹配，string为helo CQC，从string头开始匹配pattern，发现到 ‘o’ 时无法完成匹配，匹配终止，返回None

4.第四个匹配，同第二个匹配原理，即使遇到了空格符也不会受影响。

下面我们说一下关于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代表整个匹配的子串；不填写参数时，返回(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(), end(group))。
7.expand(template):
将匹配到的分组代入template中然后返回。template中可以使用\id或\g、\g引用分组，但不能使用编号0。\id与\g是等价的；但\10将被认为是第10个分组，如果你想表达\1之后是字符’0’，只能使用\g0。

下面我们用一个例子来体会一下

import re# 匹配如下内容：单词+空格+单词+任意字符m = re.match(r'(\w+) (\w+)(?P.*)', 'hello world!')print "m.string:", m.stringprint "m.re:", m.reprint "m.pos:", m.posprint "m.endpos:", m.endposprint "m.lastindex:", m.lastindexprint "m.lastgroup:", m.lastgroupprint "m.group():", m.group()print "m.group(1,2):", m.group(1, 2)print "m.groups():", m.groups()print "m.groupdict():", m.groupdict()print "m.start(2):", m.start(2)print "m.end(2):", m.end(2)print "m.span(2):", m.span(2)print r"m.expand(r'\g \g\g'):", m.expand(r'\2 \1\3')### output #### m.string: hello world!# m.re: # m.pos: 0# m.endpos: 12# m.lastindex: 3# m.lastgroup: sign# m.group(1,2): ('hello', 'world')# m.groups(): ('hello', 'world', '!')# m.groupdict(): {'sign': '!'}# m.start(2): 6# m.end(2): 11# m.span(2): (6, 11)# m.expand(r'\2 \1\3'): world hello!

（2）re.search(pattern, string[, flags])

search方法与match方法极其类似，区别在于match()只检测re是不是在string的开始匹配，search()会扫描整个string查找匹配，match（）只有在0位置匹配成功的话才有返回，如果不是开始位置匹配成功的话，match()就返回None。同样，search方法的返回对象同样match()返回对象的方法和属性。我们用一个例子感受一下

#导入re模块import re# 将正则表达式编译成Pattern对象pattern = re.compile(r'world')# 使用search()查找匹配的子串，不存在能匹配的子串时将返回None# 这个例子中使用match()无法成功匹配match = re.search(pattern,'hello world!')if match:    # 使用Match获得分组信息    print match.group()### 输出 #### world

（3）re.split(pattern, string[, maxsplit])

按照能够匹配的子串将string分割后返回列表。maxsplit用于指定最大分割次数，不指定将全部分割。我们通过下面的例子感受一下。

import repattern = re.compile(r'\d+')print re.split(pattern,'one1two2three3four4')### 输出 #### ['one', 'two', 'three', 'four', '']

（4）re.findall(pattern, string[, flags])
搜索string，以列表形式返回全部能匹配的子串。我们通过这个例子来感受一下

import repattern = re.compile(r'\d+')print re.findall(pattern,'one1two2three3four4')### 输出 #### ['1', '2', '3', '4']

（5）re.finditer(pattern, string[, flags])

搜索string，返回一个顺序访问每一个匹配结果（Match对象）的迭代器。我们通过下面的例子来感受一下

import repattern = re.compile(r'\d+')for m in re.finditer(pattern,'one1two2three3four4'):    print m.group(),### 输出 #### 1 2 3 4

（6）re.sub(pattern, repl, string[, count])

使用repl替换string中每一个匹配的子串后返回替换后的字符串。
当repl是一个字符串时，可以使用\id或\g、\g引用分组，但不能使用编号0。
当repl是一个方法时，这个方法应当只接受一个参数（Match对象），并返回一个字符串用于替换（返回的字符串中不能再引用分组）。
count用于指定最多替换次数，不指定时全部替换。

import repattern = re.compile(r'(\w+) (\w+)')s = 'i say, hello world!'print re.sub(pattern,r'\2 \1', s)def func(m):    return m.group(1).title() + ' ' + m.group(2).title()print re.sub(pattern,func, s)### output #### say i, world hello!# I Say, Hello World!

（7）re.subn(pattern, repl, string[, count])

返回 (sub(repl, string[, count]), 替换次数)。

import repattern = re.compile(r'(\w+) (\w+)')s = 'i say, hello world!'print re.subn(pattern,r'\2 \1', s)def func(m):    return m.group(1).title() + ' ' + m.group(2).title()print re.subn(pattern,func, s)### output #### ('say i, world hello!', 2)# ('I Say, Hello World!', 2)

转自：

http://python.jobbole.com/81332/

阅读全文

1 0