我爱正则表达式 » fanfou http://iregex.org 原创、翻译、转载关于正则表达式的文章 Sun, 27 Jun 2010 04:20:24 +0000 en hourly 1 http://wordpress.org/?v=3.0 使用饭否新版API编写批量抓取饭否消息的程序 http://iregex.org/blog/fanfou-msg-extractor-via-new-api.html http://iregex.org/blog/fanfou-msg-extractor-via-new-api.html#comments Tue, 06 Jan 2009 02:27:50 +0000 rex http://iregex.org/?p=52 我在断断续续地写一款抓饭程序。预想的功能包括：下载、更新饭否消息，搜索，统计。

近日饭否官方释出搜索功能，可以使用关键字搜索自己曾经发布的消息。作离线版的饭否消息管理工具，似乎没有必要。不过，有的网友习惯将饭否消息列到blog上，因此，我的程序还是有用的。

我原来写的程序，时间都消耗在饭否消息的下载、解析上。好在饭否新版API提供了任意页码的饭否消息，大大简化了抓取难度，因此编写一款饭否消息管理工具不再是一件难事。以python语言为例，我把自己的思路写出来，供各位有类似兴趣的朋友参考。

  1. 两种导出方式：(网页解析|饭否API)的比较。
    1. 难易度：使用网页解析的方式，无疑是比较复杂的，不论是使用正则表达式解析，还是使用XML方式解析。现在饭否提供完备的API，可以按页码导出近乎所有的饭否消息，将导出饭否消息程序的难度降至新低。
    2. 可靠性：我觉得使用手工的网页解析的方式，可以掌控每一个环节、细节，因此，得到的结果也最可靠。而使用API，经过实践，发现还存在漏消息的情况。
    3. 涵盖面：使用手工网页解析方式，可以抓取普通饭否消息、彩信、“饭否分享”消息等等，当然也可以只抓分享、只抓私信、@me消息，等等。而API方式只允许抓取普通饭否消息。
  2. 饭否消息的下载。

    1. 使用curl命令行模式。
      根据饭否官方API文档网页，（旧版饭否API，新版饭否API），有这样一句话：

      如果你的系统中有 cURL，就可以通过非常简单的方式使用这些API了。

      正是由于这句话的指引，我才认识了curl，并让它在我在程序中发挥了巨大的作用。cURL具有windows/linux版本，支持php/python/perl语言，是一种强烈推荐的下载利器。我习惯使用http://api.fanfou.com/statuses/user_timeline.[json|xml|rss]这条api来下载饭否消息。由于它支持id、since_id、page，我只要使用下面的命令，就能下载自己的饭否消息：


      GeSHi Error: GeSHi could not find the language txt (using path /home/zhasm/www/iregex.org/wp-content/plugins/codecolorer/lib/geshi/) (code 2)

      它的作用是：下载id为zhasm的饭否消息，第1－180页，保存为”页码.xml”网页。第1页就是 1.xml，依次类推。

      之后，可以cat *.xml >complete.xml，将所有的饭否消息合并到complete.xml文件中。就可以准备下一步的解析。

    2. 使用程序下载
      python,perl,php，无甚区别。我还是习惯使用curl模块来实现。以python为例：


      GeSHi Error: GeSHi could not find the language txt (using path /home/zhasm/www/iregex.org/wp-content/plugins/codecolorer/lib/geshi/) (code 2)

      这个python函数能够接受饭友ID，页码page，以及其它参数，下载饭否消息页面。注意，它只是下载完整的页面，还不能解析。

  3. 饭否消息的解析
    1. 消息格式
      我们先观察一下饭否消息的格式，再来做“解剖”：
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      <statuses>
          <status>
              <created_at>Mon Jan 05 05:56:36 +0000 2009</created_at>
              <id>M6pa52Ykb1s</id>
              <text>[抓饭]由于饭否释出新的API，我用python重写了抓饭工具，共150行（包括注释）。功能：下载、同步、输出饭否消息（不重复下载旧消息；不处理彩信、分享）。命令行版已经写完。GUI太烦琐了。现在网速慢，今晚还要聚会，只好明晚上传程序。</text>
              <source>网页</source>
              <truncated>false</truncated>
              <in_reply_to_status_id></in_reply_to_status_id>
              <in_reply_to_user_id></in_reply_to_user_id>
              <favorited>false</favorited>
              <in_reply_to_screen_name></in_reply_to_screen_name>
              <user>
                  <id>zhasm</id>
                  <name>.rex</name>
                  <screen_name>.rex</screen_name>
                  <location>北京</location>
                  <description>?【内测ing】好玩、有用的饭否批量处理程序：

      http://code.google.com/p/fanfoufans/?</description>
                  <profile_image_url>http://avatar.fanfou.com/s0/00/57/sg.jpg?1225428475</profile_image_url>
                  <url>http://fanfou.com/zhasm</url>
                  <protected>false</protected>
                  <followers_count>229</followers_count>
              </user>
          </status>
          ...
          </statuses>
    2. 使用xml方式解析
      这个相对简单，因为可以使用xpath技术。例如，如果找饭否消息，可以使用表达式//statuses/status/text，定位发送时间，可以用//statuses/status/created_at，诸如此类。
    3. 正则表达式（python版）
      这个相对于xpath是复杂些，不过还算做是比较简单的正则表达式应用，因为所需解析的文本极其“正则”。正则式如下：
      1
      2
      3
      4
      5
      p=re.compile(
              r"""<created_at>([^&lt;]+)</created_at>\s*
              <id>([^&lt;]+)</id>\s*
              <text>(.*?)</text>\s*
              <source>([^&lt;]+)</source>\s*"""      , re.DOTALL | re.VERBOSE)

      说明：

      • 使用了re.VERBOSE，来指定空格宽松模式，便于将一条长长的正则式折行来写；
      • 使用了re.DOTALL模式，来指定点号”.”可以匹配包括换行符在内的所有文本。饭否的text字段会出现特殊字符，正则式可以处理，xml却会折戟沉沙。以前我使用xpath解析时可费了不少力气处理特殊字符。而正则式一个点号就能解决。
      • 其它字段，例如created_at，source，来来回回就那几个可以预测的字符，我使用([^<]+)来匹配和捕获。它表示，捕获在下一个<之前的所有文本。
      • 由于>和<之间会有不定数量的（0个或多个）空白字符，我加入了\s*来匹配。

      写好正则表达式后，解析只需要两行：

      1
      2
      p.match(text)
      return p.findall(text)
  4. 存储
    1. 建立表格
      我使用Sqlite库来处理数据。先存储，再输出。sqlite语句为：
      1
      2
      3
      4
      5
      6
      cu.execute("""create table if not exists msg(
                  content Text,
                  uuid Varchar(12) NOT NULL PRIMARY KEY,
                  time Time,
                  tool Text
                  )"      "")

      创建时先看一眼该表是否存在。如果不存在才创建。  

    2. 存储：
      每解析一页（20条消息），存储一次，再commit()一次，方便、高效。
    3. 同步更新
      谁也不希望每次下载，都需要从第1条，一直下载到当前的第3333条；当你更新至第3344条时，其实只需更新最新的11条即可，没必要再重复下载前边的3333条。这一点对于用户来说，是节约下载时间；对于饭否官方服务器来说，是节省负荷。

      看一下饭否官方为此而新释出的api参数：since_id 

      * since_id (可选) – 仅返回比此 ID 大的消息。 示例： http://api.fanfou.com/statuses/user_timeline.xml?since_id=6IAZmgy1TzA1

      有了这枚参数的支持，我们就很省事了：

      1
      curl -#1 http://api.fanfou.com/statuses/user_timeline.xml?id=zhasm&amp;page=[N]&amp;since_id=6IAZmgy1TzA1 (N可变；since_id不变。)

      这样，就可以持续下载，一直到上次更新的那条了。我设定的退出条件是，下载函数返回的条数为0。这时该页已经不再返回新的消息，视为结束。
      怎样找到上次更新的临界点呢？我用的sql语句是：

      1
      2
      select distinct uuid from msg order by time DESC limit 1
      #在msg消息表中，以时间为序，找到1项最新的uuid，返回之。
      • 如果存在（非空表），我就让它生成&since_id=uuid格式的条件语句，加在curl的下载条件中。
      • 如果不存在（新建立的表），则上述的条件语句置空。 
  5. 细节
    还有一些细节问题，需要编程者操心，你不能把这些问题留给程序的使用者。
    1. 时区的转换
      观察饭否API返回的文本，它的created_at字段给出的时间格式是这样的：

      Mon Jan 05 11:35:27 +0000 2009

      它表示的是，2009年1月5日11:35:27，周一。时区是0时区。
      可是绝大多数饭否用户使用的时区是东八区。上面的时间格式、时区，都需要调整。我写函数是：

      1
      2
      3
      4
      5
      6
      7
      8
      9
      def time_from_0_to_8(timestr,timezone=8):

          TIMEFORMAT="%a %b %d %X +0000 %Y"
          #Sat Jan 03 23:08:54 +0000 2009
          ISOTIMEFORMAT='%Y-%m-%d %X'
          x=time.strptime(timestr, TIMEFORMAT)
          m=time.mktime(x)+60*60*timezone
          p=time.strftime(ISOTIMEFORMAT,time.localtime(m))
          return p

      其中timezone的默认值是8（for 东八区），如果你需要，当然你可以将其换成你需要的时间值。

    2. escape编码
      为了让饭否消息更加安全（html语法上），许多字符都被转义为其对应的escape编码，例如小于号<会被替换成<，以免与网页格式所需要的<混淆。我利用了这一点（而不是自己再转回来），将所输出的消息使用html方式输出，这样原来被转义的字符，在浏览器中还会显出原形。由于饭否消息默认的编码格式是UTF8，我当然也在输出页面加上：
      1
      <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />

至此，解析、下载、输出的工作就都解释完毕。在饭否强大的API的支持下，编写饭否程序，尤其是以下载消息为基础的程序，其门槛已经降到新低。至于各位编程爱好者能做出什么应用，那就八仙过海，各显神通吧。我把自己的程序附在文后，以资参考。编译好的命令行版程序就先不发了。我目前在做GUI。

附：python程序。需要安装若干调用模块，请自行下载。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
#!/bin/env python
# -*- coding: utf-8 -*-

import sys
reload(sys)
sys.setdefaultencoding("utf-8")             #ensure the utf8 encoding
import pysqlite2.dbapi2 as sqlite           #sqlite3
import re                                   #regular expression to parse msg
import pycurl                               #downloading engine
import StringIO                             #to  receive the downloaded text
import time                                 #time zone convertion

# important regex to parse the xml file
p=re.compile(
        r"""<created_at>([^<]+)</created_at>\s*
        <id>([^<]+)</id>\s*
        <text>(.*?)</text>\s*
        <source>([^<]+)</source>\s*""", re.DOTALL | re.VERBOSE)

###############################################################################
def time_from_0_to_8(timestr,timezone=8):
    '''convert fanfou +0000 time string to locole chinese time string.
     if you live in another timezone, please modify the timezone parameter.
    '''
    TIMEFORMAT="%a %b %d %X +0000 %Y"
    #Sat Jan 03 23:08:54 +0000 2009
    ISOTIMEFORMAT='%Y-%m-%d %X'
    x=time.strptime(timestr, TIMEFORMAT)
    m=time.mktime(x)+60*60*timezone
    p=time.strftime(ISOTIMEFORMAT,time.localtime(m))
    return p

###############################################################################
def download(id,page=1,other=""):
    """
    to download user id's message by page number. the default
    page is the 1st one.
    """
    c = pycurl.Curl()
    url="http://api.fanfou.com/statuses/user_timeline.xml?id=%s%s&page=%d"%(id,other,page)
    c.setopt(pycurl.URL, url)
    c.setopt(pycurl.HTTPHEADER, ["Accept:"])
    b = StringIO.StringIO()
    c.setopt(pycurl.WRITEFUNCTION, b.write)
    c.perform()
    return b.getvalue()


def parsemsg(text,p):
    '''
    parse all the messeges from the given text,
    return the message timestamp, msg tex, and uuid.
    the structure of the returned list:
    list[(time,id,msg,tool),(time,id,msg,tool)...]
    '''
    p.match(text)
    return p.findall(text)

###############################################################################
def initdb(id):
    '''
        init the database, create if not exists.
    '''
    dbname=id+'.db3'
    cx=sqlite.connect(dbname)
    cu=cx.cursor()
    cu.execute("""create table if not exists msg(
            content Text,
            uuid Varchar(12) NOT NULL PRIMARY KEY,
            time Time,
            tool Text
            )""")
    return cx

def latest_uid(db):
    cu=db.cursor()
    cu.execute('select distinct uuid from msg order by time DESC limit 1')
    rs=cu.fetchone()
    if rs:
        return rs[0]
    else:
        return ''

def store(list,db):
    '''
    list[(time,id,msg,tool),(time,id,msg,tool)...]
    '''
    cu=db.cursor()
    index=0
    for item in list:
        time=time_from_0_to_8(item[0])
        id=item[1]
        msg=item[2]
        tool=item[3]
        try:
            cu.execute('''insert into msg values("%s","%s","%s","%s")''' % (msg,id,time,tool))
            index+=1
        except:
            print 'insert error'
    db.commit()
    print "%d messages parsed" % index

def printmsg(db,index,sep="　"):
    cu=db.cursor()
    cu.execute('select content, time from msg where 1 order by time')
    rs=cu.fetchone()
    result=""
    while rs:
        result+=str(index)+sep+rs[0]+sep+rs[1]+"<br />\n"
        rs=cu.fetchone()
        index+=1
    return result
 ###############################################################################
id=sys.argv[1]
if len(id)<2:
    print "please start this program with your id"
    print "for example: ff.exe zhasm, where zhasm is the fanfou id"
    exit()

db=initdb(id)
since=latest_uid(db)
if since:
    condition="&since_id="+since
else:
    condition=''
page=160
while 1:
    print 'downloading page',page
    msg=download(id,page,'')
    list=parsemsg(msg,p)    
    store(list,db)
    if len(list)==0:
        break
    page+=1
filename=id+".html"
file = open(filename,"w")
file.write('''
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
</head>
<body>''' )
file.write(printmsg(db,1))
file.write('''
    </body>
    </html>''')
file.close( )
]]> http://iregex.org/blog/fanfou-msg-extractor-via-new-api.html/feed 3 饭否消息解析之从minidom到xpath http://iregex.org/blog/fanfou-message-extractor-from-minidom-to-xpath.html http://iregex.org/blog/fanfou-message-extractor-from-minidom-to-xpath.html#comments Tue, 14 Oct 2008 10:00:58 +0000 rex http://iregex.org/?p=35 抛板砖，引白玉：为何不用xpath，什么是xpath？

最近拾起了以前的小项目，在完善上篇文章发布后，“那个谁”的回复让我很感兴趣。他问，“为什么不用xpath？”

xpath是什么东东？我反问。反问之前，当然少不了先google一番，以免……那个啥。

首先映入眼帘的是w3c ，对xpath的介绍如下：

XPath is a language for addressing parts of an XML document, designed to be used by both XSLT and XPointer.

直译为中文就是，

XPath 是一种语言，用于在XML文档中定位各部分内容，可由XSLT或XPointer调用。

还搜索到xpath的教程，在这里。草草看过，当时并未着意。

虽如此，但是python里的minidom模块，也有此功效呀。为什么非要使用xpath呢？尤其是考虑到在python中还需要额外安装，不如minidom之放之四海而皆可运行。

跟那个谁再交流，意见仍是“力荐”。还推荐我细读教程，并在firefox里使用XPath Checker插件。

于是就照办了。

发硎新试,其快可知

一试XPath Checker，果然石破天惊。选中部分网页文字后，在右键菜单中选”View Xpath”，立即显示出该节点的XPath路径。层次清晰，定位精准。只是我对其语法尚未了了。于是细读教程，边学边用；半小时后，已经能够运用到之前写的饭否信息抓取程序上。虽然写代码还有些吃力，但是思路很清晰，不会纠缠于细节中无法脱身。

那个谁还提议，一般的html文档不是标准的xml文档，因此用xpath解析时，最好格式化一下。

我也注意到这个问题了。从饭否html中取出的有用内容，只占全文的一小部分；额外的部分白白拖慢速度，增强析取难度。

经过实验，我将原代码改进如下：

1. 仍用原来的minidom模块下载、分析文档，只取<ol>与</ol>之间的部分。这部分保存成字符串格式，备用。只取需要的那部分，使结构清晰，层次浅显。

2. 使用xpath来解析上一步取出的字串。

到现在，/，//，@，[]，=，等等，每个符号都从原来的meaningless变成helpful，在我的工具箱中有了合适的位置，随取随用，十分方便。我已经成了xpath的受益者。现在才觉得学习xpath真是很有趣、有用。

目前还有个小问题，无法使用纯粹的xpath语法解决。问题描述如下：

xpath只能解析实体内容，不能”囫囵吞枣”地解析。例如：

1
2
3
<li>
    <a href='http://a.com'>hello world</a>
</li>

在view xpath 下，使用/li/a，得到的是

1
<a href='http://a.com'>hello world</a>

全部内容；

但是在python下，使用

1
method=doc.xpath(u'''string(/li/a)''')

虽然，也能通过/li/a/@href得到’http://a.com’的内容。

却只能得到hello world。xpath把所有的<>之内的东西给消灭掉了。很诡异。

遇到这种情况，如果我想得到整条的信息，就使用list.childNodes[index-1].firstChild.toxml()[22:-7]这种变通方式。不过，之前的doc = Parse(str(list.toxml()))我觉得用得挺好，是自己的一个”创举”，在程序中再度使用一下传统的xml解析方式，也无可厚非。当然，如果能够在xpath下把上述所有的事情都处理掉，是最好的。

经过了一点点的修补、改进，最终的饭否消息程序如下（核心代码部分）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
    def __getMsgByPage__(self,page):

        url="http://fanfou.com/"+self.user+"/p."+str(page)
        node = minidom.parse(urllib2.urlopen(url))
        list = node.getElementsByTagName("ol")[0]
        doc = Parse(str(list.toxml()))
        cu=self.sql.cursor()
        max=doc.xpath(u'''count(/ol/li)''')
        max=int(max)+1
        if max==1:
            return 0
        max=int(max)
        for index in range(1,max):
            method=doc.xpath(u'''string(/ol/li[%d]//span[@class='method'])''' % index)[2:]
            method=method.replace(' ','')
            if method=="彩信":
                time=doc.xpath(u'''string(/ol/li[%d]//span[@class="time"]/@title)'''\
                        % index)
                uuid=doc.xpath(u'''string(/ol/li[%d]//a[@class='photo']/@href)'''\
                        % index) [-11:]
            else:
                time=doc.xpath(u'''string(/ol/li[%d]//a[@class='time']/@title)'''\
                        % index)
                uuid=doc.xpath(u'''string(/ol/li[%d]//a[@class='time']/@href)''' % index)[-11:]

            content = list.childNodes[index-1].firstChild.toxml()[22:-7]
            # content, uuid, time, method are now available for further use.

最关键的代码，只有几行而已。省掉了原来长篇累牍的coding。效率也错，我将自己近3000条饭否消息批量下载，共150余页，历时86秒。饭否服务器也很给面子，中途没有封锁我。

总结一下：Xpath很适合在xml中定位各部分内容，定位精准，描述性极佳，是xml中的搜索利器。经常做xml解析的，不妨尝试一把。

个人感言

从纯手工正则表达式解析，到使用minidom解析，再到使用xpath，看似弯路，其实蛮有收获。从自己事必躬亲精确控制每一个细节（用手工作），再到借助工具实现一部分功能（手脑并用），再到完全用合适的工具来处理全部事情（用脑工作），似乎正是良性的发展路径。自豪地说，由于我已经使用过纯手工正则表达式的解析，即使现有的工具不适合我，我进可攻，退可守；我知道解析的细节，现有的工具（好看的封装而已嘛）骗不了我，即使它包装得再好，还是正则表达式在作引擎（曾经读过python处理xml的相关库文件的python代码，感谢开源）；从追求实现(it works!)到追求卓越的实现(the excellent solution)，也是进步的必然。我不是说使用正则式就低级——我从来没有说过诸如此类的话，不论是对正则表达式，还是对正则表达式的使用者；事实上，正则表达式一直是我的箧中飞刃；我爱正则表达式！——只是说，不同的工具在合适的场合，有不同的效用。不单要知道某种工具的缺点以便能够避其短，更重要的是要知道它的优点以便扬其长。这样才能从容地调兵遣将，手下无不可用之工具。

相关链接：

]]> http://iregex.org/blog/fanfou-message-extractor-from-minidom-to-xpath.html/feed 5 饭否消息析取之regex vs xml http://iregex.org/blog/fanfou-message-extractor-regex-vs-xml.html http://iregex.org/blog/fanfou-message-extractor-regex-vs-xml.html#comments Wed, 08 Oct 2008 10:53:59 +0000 rex http://iregex.org/?p=33 页内导航：

批量导出饭否程序的方法很多，但是基本思路都是先将该网页保存到本地，然后将有用的饭否消息析取出来。本文不讨论如何下载饭否网页了（使用迅雷、wget、curl等），重点讨论对于下载到本地的网页，如何将有用的饭否消息析取出来。

小插曲：能否只用官方的API来获取全部饭否消息？

您或许会提议为什么不使用饭否自身的API。是的，饭否的API更快捷方便，兼容性很强。只是，饭否官方只提供下载前20条饭否消息的API。如果纯粹使用饭否官方API来下载全部饭否消息的方法也不是没有，只是很邪恶：

1
2
3
4
5
6
while (true)
{
    download 20 messages via API;
    store them;
    delete this 20 messages via API;
}

一边下载一边删除，确实总能得到全部消息。删除了前面的20条，能保证后面的20条以新消息的面目出现。这在理论上是行得通的。但是我们需要的是英雄Heroes里Peter那样无损的复制方式，而不是Sylar那样的残忍的剪切方式，呵呵。既然官方的API有限制，我们就自己动手了。请继续阅读本文。

饭否消息结构

打开一个饭否消息网页的源代码，例如本人的
http://fanfou.com/regex/p.1（其实http://fanfou.com/regex是http://fanfou.com/regex/p.1的快捷方式。这里使用完整的路径，以便体现其一般性。），观察可见，有用的饭否消息在这个框架里面：（代码较长，阅读请点击展开）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
<ol>
    <li>
        <span class="content">
            代码非抄不能懂也。</span>
        <span class="stamp">
            <a class="time" title="2008-10-03 12:07" href="/statuses/QD6qHiqUbeE">
                2008-10-03 12:07</a>
            <span class="method">
                通过 <a href="http://del.icio.us/fanfou/API%E5%BA%94%E7%94%A8" target="_blank">
                    API</a>
            </span>
        </span>
    </li>

    <li>
        <span class="content">
            向自由的身心致敬！ - 早嗷嗷也盼~晚安安也盼~望穿安安双眼~~怎知道今日里打土匪进深山自己的队伍来哎到嗷~面安前安呐啊啊啊啊啊~~~ <a href="http://fanfou.com/linkto/aHR0cDovL3d3dy5kb3ViYW4uY29tL2V2ZW50LzEwMjczNDg3Lw" target="_blank">
                http://www.douban.com/event/10273487/</a>
        </span>
        <span class="stamp">
            <a class="time" title="2008-10-06 14:07" href="/share/bd96z1U-gHw">
                2008-10-06 14:07</a>
            <span class="method">
                通过<a href="http://help.fanfou.com/share_button.html" target="_blank">
                    饭否分享</a>
            </span>
        </span>
    </li>

    <li>
        <span class="content">
            <a class="photo" href="http://fanfou.com/photo/8JsezhHM_VU">
                <img src="http://photo.fanfou.com/m0/00/19/e2_36807.jpg" alt="caixinceshi - no description" />
            </a>
            上传了新照片：caixinceshi - no description</span>
        <span class="stamp">
            <span class="time" title="2008-10-03 11:33">
                2008-10-03 11:33</span>
            <span class="method">
                通过<a href="http://help.fanfou.com/mobile_mms.html" target="_blank">
                    彩信</a>
            </span>
        </span>
    </li>
    #更多的<li>...</li>条目，每页最多20条。
</ol>

Tips：在分析饭否源代码时，饭否消息全在一行，不便于阅读。您可以拷贝所需要的代码（注意前后结构的匹配呼应）到vim中，执行:%s/>/>\r/g(将每个>后面加上一个换行符)，再按ggvG全选，按=格式代码，所有的代码就成了漂亮的缩进格式，便于阅读了。


使用regex解析饭否消息

下面是使用regex来解析饭否消息的代码（直接拷贝自本人原来的perl抓饭程序。）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
my $ffmsg=qr{
    <li>
        <span class="content">
            (.*?)
        </span>
        <span class="stamp">
            <a href="/(?:statuses|share)/([-_a-zA-Z0-9]{11})" class="time" title="([-: 0-9]{16})">
                [^<]+
            </a>
            <span class="method">
                通过(网页|(?:\s*<[^>]+>)[^<]+(?:</a>))
            </span>
        </span>
    </li>
' }xi;

可以看出，使用正则表达式，能够比较真实地再现原网页代码的风貌。有几处小地方需要说明一下：

  • 在第一组小括号里，我使用了([^<]+?)来捕获消息正文（一条完整的消息可以分为：消息正文；发送时间；消息uuid例如QD6qHiqUbeE，发送方法，类型（彩信还是文本））。最初是使用.*?的。但是这样不精确，有时候两条消息竟然混合在一起。而([^<]+?)捕获的是从当前位置开始至下一个<之前的所有内容。或许您会问，这不怕受到消息正文中可能出现的<的影响吗？答案是：不会受到影响。因为饭否会把所有的<以及其实有可能影响解析的字符，都转换成<的形式了，因此它不影响解析。同时，使用精确的正则表达式有助于提高效率，让不匹配的正则式尽早失败。
  • (?:statuses|share)。这条正则表达式是用来捕获饭否的uuid。它不但能捕获以普通方法发布的消息（网页、短信、手机、API、IM工具等），还能捕获由“饭否分享”工具发布的消息。我不是很喜欢饭否分享这个工具。（或许改天有时间写篇文章，揭露它的缺点？）之所以把“饭否分享”消息和普通消息分开来说，是因为两者的结构是不一样的。
  • 通过(网页|(?:\s*<[^>]+>)[^<]+(?:))这条正则式，既用了捕获型括号，又用了非捕获型括号。使用后者，能有效地避免程序太复杂，便于按序号引用（$1,$2等，如果越多则越混乱，修改正则式后，更是乱成一团遭），还能节省内存（如果程序中捕获了太多的内容，而不及时释放，或许会占尽资源。毕竟不是只捕获几十字节。要考虑到饭否用户或许有近十万条的饭否消息。指的是苹果流冰这样的“万玻南痨话”）
  • xi选项：x是为了使用忽略空白字符和允许注释；i选项是忽略大小写。

使用正则表达式来析取饭否消息文本，需要考虑的细节很多。一处不细致，程序运行起来就会给你难看。饭否彩信的格式就略过不分析了。道理相同，点到为止。


使用xml解析饭否消息

再来看一下在python下，使用xml来解析饭否消息。注：该程序参考了ppip的pyfan程序。
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
from xml.dom import minidom, Node #引人解析工具：xml小马驹！
node = minidom.parse(urllib2.urlopen("http://fanfou.com/zhasm/p.1"))
#抓取页面http://fanfou.com/zhasm/p.1 的全部内容到变量node中
l = node.getElementsByTagName("ol")[0]
#将饭否消息部分内容保存到变量l中
for c in range(0, number):
    # 时间
    if l.childNodes[c].hasAttribute("class"):
        continue
    content = (
            #时间:
            l.childNodes[c].childNodes[5].\
            firstChild.getAttribute("title"),
            #消息正文 :
            childNodes[c].childNodes[0].toxml()[22:-7],
            #uuid
            l.childNodes[c].childNodes[5].firstChild.\
            getAttribute("href")[10:]
            )

在xml文件中，前后呼应的标签，成了鲜活的特征，这些特征可以被xml解析函数很容易地辨识出来，并提取出所需内容。

  • childNodes[c].childNodes[0].toxml()[22:-7]：这条语句的意思是，对于每一条饭否消息（childNodes[c]），其消息内容的第一个节点（childNodes[0]），截取其第23字节到倒数第7字节的内容。它是指哪一段呢？其实就是每一对<span class=”content”>…</span>之间点号所示的内容。
  • 每条消息的发送时间、正文、uuid，保存在tuple中。

取得了内容之后，至于之后的煎炒烹炸，就悉听尊便了。

值得一提的是，本人在大量下载饭否消息时，不止一次遇到过饭否页面无法访问的情况。问了饭否郭万怀，答曰为了减轻服务器负载，每个IP地址下每分钟允许访问100个页面。超过此数就会自动屏蔽。我测试的结果是少于100页。比较靠谱的间隔是，每析取一页，sleep(15)。是有些慢了。没办法。当然，也有人说，执行本人以前写的抓饭程序，一次下载几百页，并没有遇到当机情况。那我只能说是您的RP高、运气好了。


两者比较

 

个人认为，xml与regex相比，有如下特点：

  • 通用性：xml具有通用性，不单单能解析饭否消息，其它符合规则的html文本，同样能够较少地改动代码，即可解析；而正则表达式则具有专用性，不能放之四海而皆准。当饭否的界面、框架有微调时，估计使用正则表达式解析的工具首先倒下。
  • 可读性：有人说perl是只写语言，regex尤甚。这是在说perl或regex代码在编写时性之所至，酣畅淋漓，执行也很高效。只是，如果代码格式混乱且无注释文档的话，隔数日、数月再读，仿佛读天书一般。而使用xml库来解析的python语言，则由于代码格式整齐，库函数见名知意，因而具有较强的可读性。这样说，总体是这样。不过我们可以尽可能把代码（即使是perl或regex的）写的整齐已读，尤其是考虑到perl支持/x选项。
  • 效率：良好编译的正则式，其执行效率应该优于xml解析。但是，使用xml能够节省编程时间；使用正则式牺牲一部分的编程时间，理论上能提高一点点效率。有兴趣的读者可以编写一段程序，循环个成千上万次，比较一下平均时间。

写到这里，对照金庸先生在《鹿鼎记》第五章：“金戈运启驱除会，玉匣书留想象间”两种武功的比较，颇有意味：
“大慈大悲千叶手”招式太多，记起来麻烦。而“八卦游龙掌”只有八八六十四式，但反复变化，尽可敌得住千叶手。那么哪一门功夫厉害些？这两门都是上乘掌法，说不上哪一门功夫厉害。谁的功夫深，用得巧妙，谁就胜了。

以本文来看，regex就相当于是大慈大悲千叶手了，需要留意的细节太多；xml方式呢，就相当于只有八八六十四式的“八卦游龙掌”。两种工具都很有用。

呼吁官方提供更多功能

离题了。这里顺便发发牢骚而已，与xml、regex无关。我不止一次地在饭否和本人blog中抱怨，使用上面这足粗笨的方法下载、解析，是最无奈的应用。最便捷的方式，应该是官方提供批量导出程序，只要执行一条数据库查询导出即可实现我们辛辛苦苦半天才能以变通的方式实现的功能。或许是饭否官方的人员都在忙着增强和美化海内吧，饭否自生自长，长时间没有更新，任凭jiwai.de、zuosa等推出一项又一项的新功能。 

扩展

本文的思路，对twitter同样适用。但是twitter越来越慢了。有一段时间好像还不支持查看历史页面。


相关阅读

验证码：BANG1F79A9FAD20225BEA7FE397AXIANGUO e8da37692b5b030cbefb9956e3bdb9cc

]]> http://iregex.org/blog/fanfou-message-extractor-regex-vs-xml.html/feed 6 饭否私信格式分析 http://iregex.org/blog/fanfou-private-message-format-analysis.html http://iregex.org/blog/fanfou-private-message-format-analysis.html#comments Sat, 31 May 2008 04:07:38 +0000 rex http://iregex.org/?p=13 URL

饭否私信分为两种，一种是我收到的私信，一种是我发出的私信。

  • 我收到的私信：http://fanfou.com/privatemsg/p.(1-N)
  • 我发出的私信：http://fanfou.com/privatemsg/sent/p.(1-N)

上面的地址中不含饭否ID；需要cookie验证。

结束标志

通过cookie验证后，可以使用数字获得对应页码的私信内容。什么时候是结束呢？假如您的收件箱有1000条私信，每页显示20条，那么当你您输入http://fanfou.com/privatemsg/p.51时，就得不到任何有效的内容了。作为程序，它是寻找如下标志：

1
<ol class="wa">\s*</ol>

好友列表

在页面代码中，每页都有一个“向XXX发送私信”的combox列表，条目以昵称+ID组成。如果你的好友很多的话（500+），每条好友（昵称+ID）需要20字节（估算）的话，20*500=10K，大约需要多抓取10K的字节量。

收件箱饭否私信的结构

收到的私信分为两种，一种是有回复信息的（回复原文:…），一种是没有回复的。先从简单的入手，看没有回复的。
所有的私信都在<ol class=”wa”>…</ol>之内，以<li></li>分隔

例如下面这一条，就是一则很规范的私信（与发件人相关的信息都使以正则式表示）：

1
2
3
4
5
6
7
8
9
<li>
    <a href="/[^"]+" title="[^"]+" class="avatar"><img src="[^"]+" alt="[^"]+" /></a>
    来自<a href="[^"]+">[^"]+</a>：
    <span class="content">没法比较啊,你得说个具体的值,比如100条以下的算少,1000条以上的算多……</span>
    <span class="stamp time" title="2008-05-30 17:25">约 15 小时前</span>
    <span class="op">
        <a href="/privatemsg.reply/583520">回复</a>
        <a href="/privatemsg.del/583520" class="post_act">删除</a></span>
</li>

其中，需要记录的信息有：

  • 发件人名字；
  • 发件人ID；
  • 私信内容；
  • 时间；
  • 私信ID；（便于作删除、回复处理）。

根据以上需求，将上面的私信代码作处理：

1
2
3
4
5
6
7
8
9
10
<li>
    <a href="/([^"]+)" title="([^"]+)" class="avatar"><img src="[^"]+" alt="[^"]+" /></a>
    来自<a href="[^"]+">[^"]+</a>：
    <span class="content">([^<]+)</span>
    <span class="stamp time" title="([^"]+)">[^<]+</span>
    <span class="op">
        <a href="/privatemsg.reply/(\d+)">回复</a>
        <a href="/privatemsg.del/\d+" class="post_act">删除</a>
    </span>
</li>

从而得到：

1
2
3
4
5
$1=fanfou ID;
$2=fanfou name;
$3=private msg;
$4=msg time;
$5=msg ID;

再看一下包含“回复原文”的私信的结构(部分内容已作正则处理)：

1
2
3
4
5
6
7
8
9
10
11
<li>
    <a href="/([^"]+)" title="([^"]+)" class="avatar"><img src="[^"]+" alt="[^"]+" /></a>
    来自<a href="[^"]+">[^"]+</a>：
    <span class="content">([^<]+)</span>
    <span class="stamp time" title="([^"]+)">[^<]+</span>
    <span class="op">
        <a href="/privatemsg.reply/(\d+)">回复</a>
        <a href="/privatemsg.del/\d+" class="post_act">删除</a>
    </span>
    <p class="pm-parent">回复原文: 有兴趣就有动力</p>
</li>

与前者相比，只是多了<p class=”pm-parent”>.*?</p>这一段。这是不足为虑的。只要整体加上?这个强有力的正则符号，就能与上面的代码片段归纳到一起。两者结合合的代码如下：

1
2
3
4
5
6
7
8
9
10
<li>
    <a href="/([^"]+)" title="([^"]+)" class="avatar"><img src="[^"]+" alt="[^"]+" /></a>
    来自<a href="[^"]+">[^"]+</a>：
    <span class="content">([^<]+)</span>
    <span class="stamp time" title="([^"]+)">[^<]+</span>
    <span class="op">
        <a href="/privatemsg.reply/(\d+)">回复</a>
        <a href="/privatemsg.del/\d+" class="post_act">删除</a></span>
    (?:<p class="pm-parent">([^<]+)</p>)?
</li>

得到的变量为：

1
2
3
4
5
6
$1=fanfou ID;
$2=fanfou name;
$3=private msg;
$4=msg time;
$5=msg ID;
$6=parent msg;#回复原文。

发件箱饭否私信的结构

抄代码：

1
2
3
4
5
6
7
<li>
    <a href="/([^"]+)" title="([^"]+)" class="avatar"><img src="[^"]+" alt="[^"]+" /></a>
    发给<a href="[^"]+">[^"]+</a>：
    <span class="content">海内的像片是真的。</span>
    <span class="stamp time" title="2008-05-28 20:24">2008-05-28 20:24</span>
    <span class="op"><a href="/privatemsg.del/576827" class="post_act">删除</a></span>
</li>

这与“我收到的私信”的结构完全一致，只是将原来的“来自”改为“发给”而已。

不出意外，带有“回复原文”的“我收到的私信”的结构是这样的：

1
2
3
4
5
6
7
8
<li>
    <a href="/([^"]+)" title="([^"]+)" class="avatar"><img src="[^"]+" alt="[^"]+" /></a>
    发给<a href="[^"]+">[^"]+</a>：
    <span class="content">在自述部分显示的那个网上。</span>
    <span class="stamp time" title="2008-05-29 17:00">2008-05-29 17:00</span>
    <span class="op"><a href="/privatemsg.del/579918" class="post_act">删除</a></span>
    <p class="pm-parent">回复原文: 我也要试一试。</p>
</li>

我们从饭否私信代码上得到的信息就这些。遗憾的是，饭否私信中，关于“回复原文”是以明文内容形式出现，而不是以原私信ID的形式出现。后期处理时通过搜索功能解决此问题并非不能，只是如果饭否官方能够再将此功能完善的话，会省整理者不少力气。

饭否的私信源码分析完毕。至于如何读写cookie，如何写代码，如何以数据库的形式来管理下载的数据，是第二阶段的事情了。待我一一实现。

]]> http://iregex.org/blog/fanfou-private-message-format-analysis.html/feed 1