【IT168 技术专稿】对搜索引擎、文件索引、文档转换、数据检索、站点备份或迁移等应用程序来说，经常用到对网页(即HTML文件)的解析处理。事实上，通过Python语言提供的各种模块，我们无需借助Web服务器或者Web浏览器就能够解析和处理HTML文档。本文将详细介绍如何利用Python抓取和解析网页。首先，我们介绍一个可以帮助简化打开位于本地和Web上的HTML文档的Python模块，然后，我们论述如何使用Python模块来迅速解析在HTML文件中的数据，从而处理特定的内容，如链接、图像和Cookie等。最后，我们会给出一个规整HTML文件的格式标签的例子，通过这个例子您会发现使用python处理HTML文件的内容是非常简单的一件事情。
一、解析URL
通过Python所带的urlparse模块，我们能够轻松地把URL分解成元件，之后，还能将这些元件重新组装成一个URL。当我们处理HTML 文档的时候，这项功能是非常方便的。
parsedTuple = urlparse.urlparse(
" http://www.google.com/search? hl = en & q = urlparse & btnG = Google + Search " ) unparsedURL = urlparse.urlunparse((URLscheme, \
URLlocation, URLpath, '' , '' , '' ))
newURL = urlparse.urljoin(unparsedURL,
" /module-urllib2/request-objects.html " )
函数urlparse(urlstring [, default_scheme [, allow_fragments]])的作用是将URL分解成不同的组成部分，它从urlstring中取得URL，并返回元组 (scheme, netloc, path, parameters, query, fragment)。注意，返回的这个元组非常有用，例如可以用来确定网络协议(HTTP、FTP等等 )、服务器地址、文件路径，等等。
函数urlunparse(tuple)的作用是将URL的组件装配成一个URL，它接收元组(scheme, netloc, path, parameters, query, fragment)后，会重新组成一个具有正确格式的URL，以便供Python的其他HTML解析模块使用。
函数urljoin(base, url [, allow_fragments]) 的作用是拼接URL，它以第一个参数作为其基地址，然后与第二个参数中的相对地址相结合组成一个绝对URL地址。函数urljoin在通过为URL基地址附加新的文件名的方式来处理同一位置处的若干文件的时候格外有用。需要注意的是，如果基地址并非以字符/结尾的话，那么URL基地址最右边部分就会被这个相对路径所替换。比如，URL的基地址为Http://www.testpage.com/pub，URL的相对地址为test.html，那么两者将合并成http://www.testpage.com/test.html，而非http://www.testpage.com/pub/test.html。如果希望在该路径中保留末端目录，应确保URL基地址以字符/结尾。
下面是上面几个函数的详细一点的用法举例：
URLscheme = " http "
URLlocation = " www.python.org "
URLpath = " lib/module-urlparse.html "
modList = ( " urllib " , " urllib2 " , \
" httplib " , " cgilib " )
# 将地址解析成组件 print " 用Google搜索python时地址栏中URL的解析结果 "
parsedTuple = urlparse.urlparse(
" http://www.google.com/search? hl = en & q = python & btnG = Google + Search " ) print parsedTuple
# 将组件反解析成URL print " \反解析python文档页面的URL "
unparsedURL = urlparse.urlunparse( \
(URLscheme, URLlocation, URLpath, '' , '' , '' ))
print " \t " + unparsedURL
# 将路径和新文件组成一个新的URL print " \n利用拼接方式添加更多python文档页面的URL "
for mod in modList:
newURL = urlparse.urljoin(unparsedURL, \
" module-%s.html " % (mod))
print " \t " + newURL
# 通过为路径添加一个子路径来组成一个新的URL print " \n通过拼接子路径来生成Python文档页面的URL "
newURL = urlparse.urljoin(unparsedURL,
" module-urllib2/request-objects.html " )
print " \t " + newURL
上述代码的执行结果如下所示：
用Google搜索python时地址栏中URL的解析结果
' hl=en&q=python&btnG=Google+Search ' , '' )
反解析python文档页面的URL
http: // www.python.org / lib / module - urlparse.html
利用拼接方式添加更多python文档页面的URL
http: // www.python.org / lib / module - urllib.html
http: // www.python.org / lib / module - urllib2.html
http: // www.python.org / lib / module - httplib.html
http: // www.python.org / lib / module - cgilib.html
通过拼接子路径来生成Python文档页面的URL
http: // www.python.org / lib / module - urllib2 / request - objects.html
二、打开HTML文档
上面介绍了如何解析页面的URL，现在开始讲解如何通过URL打开一个网页。实际上，Python所带的urllib和urllib2这两个模块为我们提供了从URL打开并获取数据的功能，当然，这包括HTML文档。
u = urllib.urlopen(webURL)
u = urllib.urlopen(localURL)
buffer = u.read()
print u.info()
print " 从%s读取了%d 字节数据.\n " % (u.geturl(),len(buffer) )
若要通过urllib模块中的urlopen(url [,data])函数打开一个HTML文档，必须提供该文档的URL地址，包括文件名。函数urlopen不仅可以打开位于远程web服务器上的文件，而且可以打开一个本地文件，并返回一个类似文件的对象，我们可以通过该对象从HTML文档中读出数据。
一旦打开了HTML文档，我们就可以像使用常规文件一样使用read([nbytes])、readline()和readlines()函数来对文件进行读操作。若要读取整个HTML文档的内容的话，您可以使用read()函数，该函数将文件内容作为字符串返回。
打开一个地址之后，您可以使用geturl()函数取得被获取网页的真正的URL。这是很有用的，因为urlopen(或使用的opener对象)也许会伴随一个重定向。获取的网页URL也许和要求的网页URL不一样。
另一个常用的函数是位于从urlopen返回的类文件对象中的info()函数，这个函数可以返回URL位置有关的元数据，比如内容长度、内容类型，等等。下面通过一个较为详细的例子来对这些函数进行说明。
webURL = " http://www.python.org "
localURL = " index.html "
# 通过URL打开远程页面 u = urllib.urlopen(webURL)
buffer = u.read()
print u.info()
print " 从%s读取了%d 字节数据.\n " % (u.geturl(),len(buffer) )
# 通过URL打开本地页面 u = urllib.urlopen(localURL)
buffer = u.read()
print u.info()
print " 从%s读取了%d 字节数据.\n " % (u.geturl(),len(buffer) )
上面代码的运行结果如下所示：
Server: Apache / 2.2 . 9 (Debian) DAV / 2 SVN / 1.5 . 1 mod_ssl / 2.2 . 9 OpenSSL / 0.9 .8g mod_wsgi / 2.3 Python / 2.5 . 2
Last - Modified: Thu, 25 Jun 2009 0 9 : 44 : 54 GMT
ETag: " 105800d-46e7-46d29136f7180 "
Accept - Ranges: bytes
Content - Length: 18151
Connection: close
Content - Type: text / html
从http: // www.python.org读取了18151 字节数据.
Content - Type: text / html
Content - Length: 865
Last - modified: Fri, 26 Jun 2009 10 : 16 : 10 GMT
从index.html读取了865 字节数据.
三、小结
对搜索引擎、文件索引、文档转换、数据检索、站点备份或迁移等应用程序来说，经常用到对网页(即HTML文件)的解析处理。事实上，通过Python语言提供的各种模块，我们无需借助Web服务器或者Web浏览器就能够解析和处理HTML文档。本文中，我们介绍了一个可以帮助简化打开位于本地和Web上的HTML文档的Python模块。在下篇中，我们将论述如何使用Python模块来迅速解析在HTML文件中的数据，从而处理特定的内容，如链接、图像和Cookie等。
【IT168 技术专稿】对搜索引擎、文件索引、文档转换、数据检索、站点备份或迁移等应用程序来说，经常用到对网页(即HTML文件)的解析处理。事实上，通过Python语言提供的各种模块，我们无需借助Web服务器或者Web浏览器就能够解析和处理HTML文档。本文上篇中，我们介绍了一个可以帮助简化打开位于本地和Web上的HTML文档的Python模块。在本文中，我们将论述如何使用Python模块来迅速解析在HTML文件中的数据，从而处理特定的内容，如链接、图像和Cookie等。同时还会介绍如何规范HTML文件的格式标签。
一、从HTML文档中提取链接
Python语言还有一个非常有用的模块HTMLParser，该模块使我们能够根据HTML文档中的标签来简洁、高效地解析HTML文档。所以，在处理HTML文档的时候，HTMLParser是最常用的模块之一。
import urllib
class parseLinks(HTMLParser.HTMLParser):
def handle_starttag(self, tag, attrs):
if tag == ' a ' :
for name,value in attrs:
if name == ' href ' :
print value
print self.get_starttag_text()
lParser = parseLinks()
lParser.feed(urllib.urlopen( " http://www.python.org/index.html " ).read())
处理HTML文档的时候，我们常常需要从其中提取出所有的链接。使用HTMLParser模块后，这项任务将变得易如反掌。首先，我们需要定义一个新的HTMLParser类，以覆盖handle_starttag()方法，我们将使用这个方法来显示所有标签的HRef属性值。
定义好新的HTMLParser类之后，需要创建一个实例来返回HTMLParser对象。然后，就可以使用urllib.urlopen(url)打开HTML文档并读取该HTML文件的内容了。
为了解析HTML文件的内容并显示包含其中的链接，可以使用read()函数将数据传递给HTMLParser对象。HTMLParser对象的feed函数将接收数据，并通过定义的HTMLParser对象对数据进行相应的解析。需要注意，如果传给HTMLParser的feed()函数的数据不完整的话，那么不完整的标签会保存下来，并在下一次调用feed()函数时进行解析。当HTML文件很大，需要分段发送给解析器的时候，这个功能就会有用武之地了。下面是一个具体的例子
import urllib
import sys
# 定义HTML解析器 class parseLinks(HTMLParser.HTMLParser):
def handle_starttag(self, tag, attrs):
if tag == ' a ' :
for name,value in attrs:
if name == ' href ' :
print value
print self.get_starttag_text()
# 创建HTML解析器的实例 lParser = parseLinks()
# 打开HTML文件 lParser.feed(urllib.urlopen( \
" http://www.python.org/index.html " ).read())
lParser.close()
上述代码的运行结果太长，在此省略，您可以自己运行代码试试。
二、从HTML文档中提取图像
处理HTML文档的时候，我们常常需要从其中提取出所有的图像。使用HTMLParser模块后，这项任务将变得易如反掌。首先，我们需要定义一个新的HTMLParser类，以覆盖handle_starttag()方法，该方法的作用是查找img标签，并保存src属性值所指的文件。
import urllib
def getImage(addr):
u = urllib.urlopen(addr)
data = u.read()
class parseImages(HTMLParser.HTMLParser):
def handle_starttag(self, tag, attrs):
if tag == ' img ' :
for name,value in attrs:
if name == ' src ' :
getImage(urlString + " / " + value)
u = urllib.urlopen(urlString)
lParser.feed(u.read())
定义好新的HTMLParser类之后，需要创建一个实例来返回HTMLParser对象。然后，就可以使用urllib.urlopen(url)打开HTML文档并读取该HTML文件的内容了。
为了解析HTML文件的内容并显示包含其中的图像，可以使用feed(data)函数将数据发送至HTMLParser对象。HTMLParser对象的feed函数将接收数据，并通过定义的HTMLParser对象对数据进行相应的解析。下面是一个具体的示例：
import urllib
import sys
urlString = " http://www.python.org "
# 把图像文件保存至硬盘 def getImage(addr):
u = urllib.urlopen(addr)
data = u.read()
splitPath = addr.split( ' / ' )
fName = splitPath.pop()
print " Saving %s " % fName
f = open(fName, ' wb ' )
f.write(data)
f.close()
# 定义HTML解析器 class parseImages(HTMLParser.HTMLParser):
def handle_starttag(self, tag, attrs):
if tag == ' img ' :
for name,value in attrs:
if name == ' src ' :
getImage(urlString + " / " + value)
# 创建HTML解析器的实例 lParser = parseImages()
# 打开HTML文件 u = urllib.urlopen(urlString)
print " Opening URL\n==================== "
print u.info()
# 把HTML文件传给解析器 lParser.feed(u.read())
lParser.close()
上述代码的运行结果如下所示：
====================
Date: Fri, 26 Jun 2009 10 : 54 : 49 GMT
Server: Apache / 2.2 . 9 (Debian) DAV / 2 SVN / 1.5 . 1 mod_ssl / 2.2 . 9 OpenSSL / 0.9 .8g mod_wsgi / 2.3 Python / 2.5 . 2
Last - Modified: Thu, 25 Jun 2009 0 9 : 44 : 54 GMT
ETag: " 105800d-46e7-46d29136f7180 "
Accept - Ranges: bytes
Content - Length: 18151
Connection: close
Content - Type: text / html
Saving python - logo.gif
Saving trans.gif
Saving trans.gif
Saving afnic.fr.png
三、从HTML文档中提取文本
处理HTML文档的时候，我们常常需要从其中提取出所有的文本。使用HTMLParser模块后，这项任务将变得非常简单了。首先，我们需要定义一个新的HTMLParser类，以覆盖handle_data()方法，该方法是用来解析并文本数据的。
import urllib
class parseText(HTMLParser.HTMLParser):
def handle_data(self, data):
if data != ' \n ' :
urlText.append(data)
lParser = parseText()
lParser.feed(urllib.urlopen( \
http: // docs.python.org / lib / module - HTMLParser.html).read())
定义好新的HTMLParser类之后，需要创建一个实例来返回HTMLParser对象。然后，就可以使用urllib.urlopen(url)打开HTML文档并读取该HTML文件的内容了。
为了解析HTML文件的内容并显示包含其中的文本，我们可以使用feed(data)函数将数据传递给HTMLParser对象。HTMLParser对象的feed函数将接收数据，并通过定义的HTMLParser对象对数据进行相应的解析。要注意的是，如果传给HTMLParser的feed()函数的数据不完整的话，那么不完整的标签会保存下来，并在下一次调用feed()函数时进行解析。当HTML文件很大，需要分段发送给解析器的时候，这个功能就会有用武之地了。下面是一个具体的代码示例：
import urllib
urlText = []
# 定义HTML解析器 class parseText(HTMLParser.HTMLParser):
def handle_data(self, data):
if data != ' \n ' :
urlText.append(data)
# 创建HTML解析器的实例 lParser = parseText()
# 把HTML文件传给解析器 lParser.feed(urllib.urlopen( \
“http: // docs.python.org / lib / module - HTMLParser.html” \
).read())
lParser.close()
for item in urlText:
print item
上面代码的运行输出过长，在此略过。
四、从HTML文档中提取Cookies
很多时候，我们都需要处理Cookie，幸运的是Python语言的cookielib模块为我们提供了许多自动处理在HTML中的HTTP Cookie的类。当处理要求为客户端设置Cookie的HTML文档的时候，这些类对我们非常有用。
import cookielib
from urllib2 import urlopen, Request
cJar = cookielib.LWPCookieJar()
opener = urllib2.build_opener( \
urllib2.HTTPCookieProcessor(cJar))
urllib2.install_opener(opener)
r = Request(testURL)
h = urlopen(r)
for ind, cookie in enumerate(cJar):
print " %d - %s " % (ind, cookie)
cJar.save(cookieFile)
为了从HTML文档提取cookies，首先得使用cookielib模块的LWPCookieJar()函数创建一个cookie jar的实例。LWPCookieJar()函数将返回一个对象，该对象可以从硬盘加载Cookie，同时还能向硬盘存放Cookie。
接下来，使用urllib2模块的build_opener([handler, . . .])函数创建一个opener对象，当HTML文件打开时该对象将处理cookies。函数build_opener可以接收零个或多个处理程序(这些程序将按照它们被指定的顺序连接在一起)作为参数并返回一个。
注意，如果想让urlopen()使用opener对象来打开HTML文件的话，可以调用install_opener(opener)函数，并将opener对象传给它。否则，请使用opener对象的open(url)函数来打开HTML文件。
一旦已经创建并安装了opener对象，就可以使用urllib2模块中的Request(url)函数来创建一个Request对象，然后就能使用urlopen(Request)函数来打开HTML文件了。
打开HTML页面后，该页面的所有Cookie将被存放到LWPCookieJar对象中，之后，您可以使用LWPCookieJar对象的save(filename)函数了。
import urllib2
import cookielib
from urllib2 import urlopen, Request
cookieFile = " cookies.dat "
testURL = ' http://maps.google.com/ '
# 为cookie jar 创建实例 cJar = cookielib.LWPCookieJar()
# 创建HTTPCookieProcessor的opener对象 opener = urllib2.build_opener( \
urllib2.HTTPCookieProcessor(cJar))
# 安装HTTPCookieProcessor的opener urllib2.install_opener(opener)
# 创建一个Request对象 r = Request(testURL)
# 打开HTML文件 h = urlopen(r)
print " 页面的头部\n====================== "
print h.info()
print " 页面的Cookies\n====================== "
for ind, cookie in enumerate(cJar):
print " %d - %s " % (ind, cookie)
# 保存cookies cJar.save(cookieFile)
上述代码的运行结果如下所示：
======================
Cache - Control: private
Content - Type: text / html; charset = ISO - 8859 - 1
Set - Cookie: PREF = ID = 5d9692b55f029733:NW = 1 :TM = 1246015608 :LM = 1246015608 :S = frfx -- b3xt73TaEA; expires = Sun, 26 - Jun - 2011 11 : 26 : 48 GMT; path =/ ; domain = .google.com
Date: Fri, 26 Jun 2009 11 : 26 : 48 GMT
Server: mfe
Expires: Fri, 26 Jun 2009 11 : 26 : 48 GMT
Transfer - Encoding: chunked
Connection: close
页面的Cookies
======================
0 -
五、为HTML文档中的属性值添加引号
前面我们讨论了如果根据HTML解析器中的某种处理程序来解析HTML文件，可是有时候我们却需要使用所有的处理程序来处理HTML文档。值得庆幸的是，使用HTMLParser模块解析HTML文件的所有要素并不比处理链接或者图像难多少。
import urllib
class parseAttrs(HTMLParser.HTMLParser):
def handle_starttag(self, tag, attrs):
. . .
attrParser = parseAttrs()
attrParser.init_parser()
attrParser.feed(urllib.urlopen( " test2.html " ).read())
这里，我们将讨论如何使用HTMLParser模块来解析HTML文件，从而为“裸奔”的属性值加上引号。首先，我们要定义一个新的HTMLParser类，以覆盖下面所有的处理程序来为属性值添加引号。
handle_charref(name)
handle_endtag(tag)
handle_entityref(ref)
handle_data(text)
handle_comment(text)
handle_pi(text)
handle_decl(text)
handle_startendtag(tag, attrs)
我们还需要在parser类中定义一个函数来初始化用于存储解析好的数据的变量，同时还要定义另外一个函数来返回解析好的数据。
定义好新的HTMLParser类之后，需要创建一个实例来返回HTMLParser对象。使用我们创建的init函数初始化该解析器，这样，我们就可以使用urllib.urlopen(url)打开HTML文档并读取该HTML文件的内容了。
为了解析HTML文件的内容并给属性值添加引号，可以使用feed(data)函数将数据传递给HTMLParser对象。HTMLParser对象的feed函数将接收数据，并通过定义的HTMLParser对象对数据进行相应的解析。下面是一个具体的示例代码：
import urllib
import sys
# 定义HTML解析器 class parseAttrs(HTMLParser.HTMLParser):
def init_parser (self):
self.pieces = []
def handle_starttag(self, tag, attrs):
fixedAttrs = ""
# for name,value in attrs: for name, value in attrs:
fixedAttrs += " %s=\"%s\" " % (name, value)
self.pieces.append( " <%s %s> " % (tag, fixedAttrs))
def handle_charref(self, name):
self.pieces.append( " &#%s; " % (name))
def handle_endtag(self, tag):
self.pieces.append( "" % (tag))
def handle_entityref(self, ref):
self.pieces.append( " &%s " % (ref))
def handle_data(self, text):
self.pieces.append(text)
def handle_comment(self, text):
self.pieces.append( "" % (text))
def handle_pi(self, text):
self.pieces.append( "" % (text))
def handle_decl(self, text):
self.pieces.append( "" % (text))
def parsed (self):
return "" .join(self.pieces)
# 创建HTML解析器的实例 attrParser = parseAttrs()
# 初始化解析器数据 attrParser.init_parser()
# 把HTML文件传给解析器 attrParser.feed(urllib.urlopen( " test2.html " ).read())
# 显示原来的文件内容 print " 原来的文件\n======================== "
print open( " test2.html " ).read()
# 显示解析后的文件 print " 解析后的文件\n======================== "
print attrParser.parsed()
attrParser.close()
我们还需要建立一个测试文件，名为test2.html，该文件内容可以从上述代码的运行结果看到，具体如下所示：
解析后的文件 ======================== < html > < head > < meta content = " text/html; charset=utf-8 " http - equiv = " content-type " ></ meta > < title > Web页面 </ title > </ head > < body > < h1 > Web页面清单 </ h1 > < a href = " http://www.python.org " > Python网站 </ a > < a href = " test.html " > 本地页面 </ a > < img src = " test.jpg " > </ body > </ html >
六、小结
对搜索引擎、文件索引、文档转换、数据检索、站点备份或迁移等应用程序来说，经常用到对网页(即HTML文件)的解析处理。事实上，通过Python语言提供的各种模块，我们无需借助Web服务器或者Web浏览器就能够解析和处理HTML文档。本文将详细介绍了如何使用Python模块来迅速解析在HTML文件中的数据，从而处理特定的内容，如链接、图像和Cookie等。同时，我们还给出了一个规范HTML文件的格式标签的例子，希望本文对您会有所帮助。