Archive for python

对搜索引擎、文件索引、文档转换、数据检索、站点备份或迁移等应用程序来说,经常用到对网页(即HTML文件)的解析处理。事实上,通过Python 语言提供的各种模块,我们无需借助Web服务器或者Web浏览器就能够解析和处理HTML文档。本文将详细介绍如何利用Python抓取和解析网页。首 先,我们介绍一个可以帮助简化打开位于本地和Web上的HTML文档的Python模块,然后,我们论述如何使用Python模块来迅速解析在HTML文 件中的数据,从而处理特定的内容,如链接、图像和Cookie等。最后,我们会给出一个规整HTML文件的格式标签的例子,通过这个例子您会发现使用 python处理HTML文件的内容是非常简单的一件事情。

一、解析URL

通过Python所带的urlparse模块,我们能够轻松地把URL分解成元件,之后,还能将这些元件重新组装成一个URL。当我们处理HTML 文档的时候,这项功能是非常方便的。
  import urlparse

  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基地址以字符/结尾。 下面是上面几个函数的详细一点的用法举例:
  import urlparse

  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的解析结果
  ('http', 'www.google.com', '/search', '',

  '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文档。
  import urllib

  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位置有关的元数据,比如内容长度、内容类型,等等。下面通过一个较为详细的例子来对这些函数进行说明。
  import urllib

  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) )
上面代码的运行结果如下所示:
  Date: Fri, 26 Jun 2009 10:22:11 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 09: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等。

Continue

对搜索引擎、文件索引、文档转换、数据检索、站点备份或迁移等应用程序来说,经常用到对网页(即HTML文件)的解析处理。事实上,通过 Python语言提供的各种模块,我们无需借助Web服务器或者Web浏览器就能够解析和处理HTML文档。本文上篇中,我们介绍了一个可以帮助简化打开 位于本地和Web上的HTML文档的Python模块。在本文中,我们将论述如何使用Python模块来迅速解析在HTML文件中的数据,从而处理特定的 内容,如链接、图像和Cookie等。同时还会介绍如何规范HTML文件的格式标签。 一、从HTML文档中提取链接 Python语言还有一个非常有用的模块HTMLParser,该模块使我们能够根据HTML文档中的标签来简洁、高效地解析HTML文档。所以,在处理HTML文档的时候,HTMLParser是最常用的模块之一。

import 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 HTMLParser 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 HTMLParser 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 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()
上述代码的运行结果如下所示:
Opening URL ==================== 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 09: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 HTMLParser 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 HTMLParser 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 urllib2 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 os 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 HTMLParser 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_starttag(tag, attrs) 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 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"/> <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> <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文件的格式标签的例子,希望本 文对您会有所帮助。

Continue

简单的抓取网页:

import urllib.request   
url="http://google.cn/"  
response=urllib.request.urlopen(url)    #返回文件对象
page=response.read()
直接将URL保存为本地文件:  
import urllib.request  
url="http://www.xxxx.com/1.jpg"
urllib.request.urlretrieve(url,r"d:\temp\1.jpg")
  POST方式:  
import urllib.parse  
import urllib.request  
 
url="http://liuxin-blog.appspot.com/messageboard/add" 
 
values={"content":"命令行发出网页请求测试"}  
data=urllib.parse.urlencode(values) 

#创建请求对象  
req=urllib.request.Request(url,data) 
#获得服务器返回的数据  
response=urllib.request.urlopen(req) 
#处理数据  
page=response.read()
  GET方式:  
import urllib.parse  
import urllib.request  
 
url="http://www.google.cn/webhp" 
 
values={"rls":"ig"}  
data=urllib.parse.urlencode(values)  
 
theurl=url+"?"+data 
#创建请求对象  
req=urllib.request.Request(theurl) 
#获得服务器返回的数据  
response=urllib.request.urlopen(req) 
#处理数据  
page=response.read()
  有2个常用的方法,geturl(),info() geturl()的设置是为了辨别是否有服务器端的网址重定向,而info()则包含了一系列的信息。 中文问题的处理,会用到 encode()编码 dencode()解码:

Continue

#-*-coding:utf-8-*-
import urllib2, urllib, cookielib
import re
import getpass
import sqlite3
import random
import time

class Discuz:
    def __init__(self,user,pwd,args):
        self.username = user
        self.password = pwd
        self.args = args
        self.regex = {
            'loginreg':'',
            'replyreg':'',
            'tidreg': '[\s\S]+?'
        }
        self.conn = None
        self.cur = None
        self.islogin = False
        self.login()
        self.InitDB()

    def login(self):
        try:
            loginPage = urllib2.urlopen(self.args['loginurl']).read()
            formhash = re.search(self.regex['loginreg'], loginPage)
            formhash = formhash.group(1)
            #print 'login formhash:', formhash
            print 'start login...'
            cj = cookielib.CookieJar()
            opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cj))
            user_agent = 'Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; Mozilla/4.0 \
                    (compatible; MSIE 6.0; Windows NT 5.1; SV1) ; .NET CLR 2.0.507'
            opener.addheaders = [('User-agent', user_agent)]
            urllib2.install_opener(opener)
            logindata = urllib.urlencode({
                'cookietime':    2592000,
                'formhash': formhash,
                'loginfield':'username',
                'username':    self.username,
                'password':    self.password,
                'questionid':    0,
                'referer': self.args['referer']
                })
            request = urllib2.Request(self.args['loginsubmiturl'],logindata)
            response = urllib2.urlopen(request)
            self.islogin = True
            print 'login success...'
        except Exception,e:
                print 'loggin error: %s' % e

    def PostReply(self, fid, tid, content):
        try:
            sql = "select * from post where fid='%s' and tid='%s'" % (fid,tid)
            self.cur.execute(sql)
            if self.cur.rowcount == -1:
                tidurl = self.args['tidurl'] % tid
                replysubmiturl = self.args['replysubmiturl'] % (fid,tid)
                tidPage = urllib2.urlopen(tidurl).read()
                formhash = re.search(self.regex['replyreg'], tidPage)
                formhash = formhash.group(1)
                #print 'reply formhash:', formhash
                print 'start reply...'
                replydata = urllib.urlencode({
                    'formhash': formhash,
                    'message': content,
                    'subject': '',
                    'usesig':'1'
                })
                request = urllib2.Request(replysubmiturl,replydata)
                response = urllib2.urlopen(request)
                sql = "insert into post values ('%s', '%s', '%d')" % (fid, tid, 1)
                self.cur.execute(sql)
                self.conn.commit()
                print 'reply success for [%s]' % tidurl
            else:
                print 'Skip! Thread:%s is already replied...' % tid
        except Exception, e:
                print 'reply error: %s' % e

    def GetTids(self, fid):
        if self.islogin:
            fidurl = self.args['fidurl'] % fid
            response = urllib2.urlopen(fidurl)
            content = response.read()
            tids = re.findall(self.regex['tidreg'], content)
            return tids
        else:
            print 'Error Please Login...'

    def InitDB(self):
        self.conn = sqlite3.connect('data.db')
        self.cur = self.conn.cursor()
        sql = '''create table if not exists post (
            fid text,
            tid text,
            replied integer)'''
        self.cur.execute(sql)
        self.conn.commit()

if __name__ == '__main__':
    username = raw_input('username:').strip()
    password = getpass.getpass('password:').strip()
    args = {
            'loginurl': 'http://www.xxx.com/logging.php?action=login',
            'loginsubmiturl': 'http://www.xxx.com/logging.php?action=login&loginsubmit=yes',
            'fidurl': 'http://www.xxx.com/forum-%s-1.html',
            'tidurl': 'http://www.xxx.com/thread-%s-1-1.html',
            'replysubmiturl': 'http://www.xxx.com/post.php?action=reply&replysubmit=yes&infloat=yes&handlekey=fastpost&fid=%s&tid=%s',
            'referer':'http://www.xxx.com/index.php'
    }
    dz = Discuz(username, password,args)
    fid = '45'
    tids = dz.GetTids('45')
    replylist = [
            u'不错,支持一下,呵呵',
            u'已阅,顶一下',
            u'看看,顶你,呵呵',
            u'多谢分享,顶一下',
            u'说的不错,支持一下',
            u'提着水桶到处转,哪里缺水哪里灌! ',
            u'你太油菜了!'
    ]
    for tid in tids:
        content = random.choice(replylist)
        content = content.encode('gbk')
        dz.PostReply('45',tid, content)
        time.sleep(20)
- 下面简单说下过程: 首先是得到了login的post地址:http://www.xxx.com/logging.php?action=login&loginsubmit=yes 几个关键的parameter是
formhash cookietime formhash loginfield password questionid referer username
  • cookietime 浏览器自动给的是 2592000
  • loginfield 默认的username
  • password 密码
  • questionid 这个貌似是登录时的回答问题,这个论坛没有强制回答所以用默认的0
  • referer 这个则是引用地址 http://www.xxx.com/index.php
  • username 用户名
  • formhash 最后这个貌似这个是随机的,不固定,可也是个关键参数,所以就直接用正则查找之
args = {
            'loginurl': 'http://www.xxx.com/logging.php?action=login',
            'loginsubmiturl': 'http://www.xxx.com/logging.php?action=login&amp;loginsubmit=yes',
            'fidurl': 'http://www.xxx.com/forum-%s-1.html',
            'tidurl': 'http://www.xxx.com/thread-%s-1-1.html',
            'replysubmiturl': 'http://www.xxx.com/post.php?action=reply&amp;replysubmit=yes&amp;infloat=yes&amp;handlekey=fastpost&amp;fid=%s&amp;tid=%s',
            'referer':'http://www.xxx.com/index.php'
    }
  • loginurl为登录面页,用于获得formhash的值
  • loginsubmiturl为post登录参数的地址
  • fidurl这个是版块的ID,url中%s那里即为fid,这样的url http://www.xxx.com/forum-45-1.html,fid即为45
  • tidurl是帖子的id,查找方法同上
  • replysubmiturl这个是回复帖子post参数的url,要定位一个帖子前提得知道fid和tid
  • referer这个是引用地址,用网站的首页即可

Continue

对于大部分论坛,我们想要抓取其中的帖子分析,首先需要登录,否则无法查看。 这是因为 HTTP 协议是一个无状态(Stateless)的协议,服务器如何知道当前请求连接的用户是否已经登录了呢?有两种方式: 在URI 中显式地使用 Session ID; 利用 Cookie,大概过程是登录一个网站后会在本地保留一个 Cookie,当继续浏览这个网站的时候,浏览器会把 Cookie 连同地址请求一起发送过去。 Python 提供了相当丰富的模块,所以对于这种网络操作只要几句话就可以完成。我以登录 QZZN 论坛为例,事实上下面的程序几乎所有的 PHPWind 类型的论坛都是适用的。

# -*- coding: GB2312 -*-

from urllib import urlencode
import cookielib, urllib2

# cookie
cj = cookielib.LWPCookieJar()
opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cj))
urllib2.install_opener(opener)

# Login
user_data = {'pwuser': '你的用户名',
             'pwpwd': '你的密码',
             'step':'2'
            }
url_data = urlencode(user_data)
login_r = opener.open("http://bbs.qzzn.com/login.php", url_data)
一些注释: urllib2 显然是比 urllib 高级一点的模块,里面包括了如何使用 Cookies。 在 urllib2 中,每个客户端可以用一个 opener 来抽象,每个 opener 又可以增加多个 handler 来增强其功能。 在构造 opener 时指定了 HTTPCookieProcessor 做为 handler,因此这个 handler 支持 Cookie。 使用 isntall_opener 后,调用 urlopen 时会使用这个 opener。 如果不需要保存 Cookie,cj 这个参数可以省略。 user_data 存放的就是登录所需要的信息,在登录论坛的时候把这个信息传递过去就行了。 urlencode 功能是把字典 user_data 编码成"?pwuser=username&pwpwd=password"的形式,这样做是为了使程序易读一些。 最后一个问题是,pwuser、pwpwd 这类的名字是从哪儿来的,这就要分析需要登录的网页了。我们知道,一般的登录界面都是一个表单,节选如下: 从这里可以看出,我们需要输入的用户名密码对应的就是 pwuser 和 pwpwd,而 step 对应的则是登录(这个是尝试出来的)。
... 用户名 UID 马上注册 密 码 找回密码 ...
注意到,这个论坛表单采用的是 post 方式,如果是 get 方式则本文的方法就需要变动一下,不能直接 open,而是应该首先 Request,然后再 open。更详细的请看手册...

Continue

 # -*- coding: utf-8 -*-  
 import re  
 import urllib  
 import urllib2  
 import cookielib  
   
 #获取CSDN博客标题和正文  
 url = "http://blog.csdn.net/[username]/archive/2010/07/05/5712850.aspx"  
 sock = urllib.urlopen(url)  
 html = sock.read()  
 sock.close()  
 content = re.findall('(?<=blogstory">).*(?=

Continue

  学用python也有3个多月了,用得最多的还是各类爬虫脚本:写过抓代理本机验证的脚本,写过在discuz论坛中自动登录自动发贴的脚本,写过自动收邮件的脚本,写过简单的验证码识别的脚本,本来想写google music的抓取脚本的,结果有了强大的gmbox,也就不用写了。 - 这些脚本有一个共性,都是和web相关的,总要用到获取链接的一些方法,再加上simplecd这个半爬虫半网站的项目,累积不少爬虫抓站的经验,在此总结一下,那么以后做东西也就不用重复劳动了。 1.最基本的抓站

import urllib2
content = urllib2.urlopen(‘http://XXXX’).read()
2.使用代理服务器 这在某些情况下比较有用,比如IP被封了,或者比如IP访问的次数受到限制等等。
import urllib2
proxy_support = urllib2.ProxyHandler({'http':'http://XX.XX.XX.XX:XXXX'})
opener = urllib2.build_opener(proxy_support, urllib2.HTTPHandler)
urllib2.install_opener(opener)
content = urllib2.urlopen('http://XXXX').read()
3.需要登录的情况 登录的情况比较麻烦我把问题拆分一下: - 3.1 cookie的处理
import urllib2, cookielib
cookie_support= urllib2.HTTPCookieProcessor(cookielib.CookieJar())
opener = urllib2.build_opener(cookie_support, urllib2.HTTPHandler)
urllib2.install_opener(opener)
content = urllib2.urlopen('http://XXXX').read()
是的没错,如果想同时用代理和cookie,那就加入proxy_support然后operner改为
opener = urllib2.build_opener(proxy_support, cookie_support, urllib2.HTTPHandler)
3.2 表单的处理 登录必要填表,表单怎么填?首先利用工具截取所要填表的内容 比如我一般用firefox+httpfox插件来看看自己到底发送了些什么包 这个我就举个例子好了,以verycd为例,先找到自己发的POST请求,以及POST表单项:
python爬虫抓站
可以看到verycd的话需要填username,password,continueURI,fk,login_submit这几项,其中fk是 随机生成的(其实不太随机,看上去像是把epoch时间经过简单的编码生成的),需要从网页获取,也就是说得先访问一次网页,用正则表达式等工具截取返回 数据中的fk项。continueURI顾名思义可以随便写,login_submit是固定的,这从源码可以看出。还有 username,password那就很显然了。 - 好的,有了要填写的数据,我们就要生成postdata  
import urllib
postdata=urllib.urlencode({
    'username':'XXXXX',
    'password':'XXXXX',
    'continueURI':'http://www.verycd.com/',
    'fk':fk,
    'login_submit':'登录'
})
然后生成http请求,再发送请求:
req = urllib2.Request(
    url = 'http://secure.verycd.com/signin/*/http://www.verycd.com/',
    data = postdata
)
result = urllib2.urlopen(req).read()
3.3 伪装成浏览器访问 某些网站反感爬虫的到访,于是对爬虫一律拒绝请求 这时候我们需要伪装成浏览器,这可以通过修改http包中的header来实现
headers = {
    'User-Agent':'Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.1.6) Gecko/20091201 Firefox/3.5.6'
}
req = urllib2.Request(
    url = 'http://secure.verycd.com/signin/*/http://www.verycd.com/',
 data = postdata,
    headers = headers
)
- 3.4 反”反盗链” 某些站点有所谓的反盗链设置,其实说穿了很简单,就是检查你发送请求的header里面,referer站点是不是他自己,所以我们只需要像3.3一样,把headers的referer改成该网站即可,以黑幕著称地cnbeta为例:
headers = {
    'Referer':'http://www.cnbeta.com/articles'
}
headers是一个dict数据结构,你可以放入任何想要的header,来做一些伪装。例如,有些自作聪明的网站总喜欢窥人隐私,别人通过代理 访问,他偏偏要读取header中的X-Forwarded-For来看看人家的真实IP,没话说,那就直接把X-Forwarde-For改了吧,可以 改成随便什么好玩的东东来欺负欺负他,呵呵。 - 3.5 终极绝招 有时候即使做了3.1-3.4,访问还是会被据,那么没办法,老老实实把httpfox中看到的headers全都写上,那一般也就行了。 再不行,那就只能用终极绝招了,selenium直接控制浏览器来进行访问,只要浏览器可以做到的,那么它也可以做到。类似的还有pamie,watir,等等等等。 - 4.多线程并发抓取 单线程太慢的话,就需要多线程了,这里给个简单的线程池模板 这个程序只是简单地打印了1-10,但是可以看出是并发地。
from threading import Thread
from Queue import Queue
from time import sleep
#q是任务队列
#NUM是并发线程总数
#JOBS是有多少任务
q = Queue()
NUM = 2
JOBS = 10
#具体的处理函数,负责处理单个任务
def do_somthing_using(arguments):
    print arguments
#这个是工作进程,负责不断从队列取数据并处理
def working():
    while True:
        arguments = q.get()
        do_somthing_using(arguments)
        sleep(1)
        q.task_done()
#fork NUM个线程等待队列
for i in range(NUM):
    t = Thread(target=working)
    t.setDaemon(True)
    t.start()
#把JOBS排入队列
for i in range(JOBS):
    q.put(i)
#等待所有JOBS完成
q.join()
5.验证码的处理 碰到验证码咋办?这里分两种情况处理: - 1.google那种验证码,凉拌 - 2.简单的验证码:字符个数有限,只使用了简单的平移或旋转加噪音而没有扭曲的,这种还是有可能可以处理的,一般思路是旋转的转回来,噪音去掉,然后划分单个字符,划分好了以后再通过特征提取的方法(例如PCA)降维并生成特征库,然后把验证码和特征库进行比较。这个比较复杂,一篇博文是说不完的,这里就不展开了,具体做法请弄本相关教科书好好研究一下。 - 3.事实上有些验证码还是很弱的,这里就不点名了,反正我通过2的方法提取过准确度非常高的验证码,所以2事实上是可行的。 - 6.总结 基本上我遇到过的所有情况,用以上方法都顺利解决了,不太清楚还有没有其他漏掉的情况,所以本文到这里就完成了,以后要是碰上其他情况,再补充相关方法好了:)

Continue