我爱正则表达式

统计最近用过的linux命令

rex — Tue, 31 Aug 2010 12:32:59 +0800

统计最近用过的linux命令。没什么具体用途，练习bash而已。

流程：

从 history 命令中得到最近1000条命令。

删除每行的行号。

记录每一行中的命令。行首的第一个英文单词，以及管道后面的第一个英文单词，视为命令名称。

将得到的命令列表排序。

统计每个命令的出现次数，先以次数降序排列，再以命令名称升序排列。

以下是本人的ubuntu命令显示：

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

157 ls
134 cd
89 pcregrep
76 cat
56 xargs
52 python
49 vim
47 sudo
46 git
44 exit
37 rename
28 echo
27 sed
27 tstp
26 adt
26 grep
19 curl
18 rm
16 history
16 wget
12 ps
10 kill
10 make
10 perl
8 ll
8 mv
8 scp
8 sfo
7 ctags
7 tst
6 awk
6 gvim
6 mkdir
6 sort
4 chmod
4 man
4 uniq
3 cjb
3 md5sum
3 tt
3 vmxp
3 which
2 chown
2 ctag
2 docky
2 ex
2 ks
2 pyton
2 set
2 tar
1 bc
1 cdcd
1 cp
1 cpanm
1 date
1 efr
1 firefox
1 gawk
1 gi
1 less
1 lua
1 PWD
1 re
1 sleep
1 tpo
1 unzip
1 vi
1 vm
1 xarg

anti spam杂谈

rex — Sun, 15 Aug 2010 10:03:50 +0800

本文是一篇随笔，将email的anti spam技术和论坛的防灌水结合在一起讨论。从技术层面出发。不涉及其它。

据说德国有这样一句谚语：没有泡沫的啤酒不是好啤酒。推而广知，可以得到：没人灌水的论坛不是好论坛，没有垃圾邮件的邮件系统不是好系统（至少是不知名的系统／电邮地址），没有病毒骚扰的OS不是好的OS，等等。但是，只有泡沫的啤酒也不是什么好啤酒吧？关键是将不需要的内容控制在可以允许的范围内。单就开论坛、维护垃圾邮件的角度出发，审核技术还是很有用，很有必要的。否则，其地盘很快就会淹没在垃圾广告的汪洋大海之中。自己的论坛，自己发广告是为了维持网站开销，但是不请自来的广告是无法容忍的。

Spam

垃圾邮件有两个特点：

大量。一封两封垃圾邮件，个人用户可能比较在意，但是对于服务器来说，邮件数以百万计。在这样大的分母下，如果偶然有一两封垃圾邮件被判为合法邮件，或者合法邮件被误判为垃圾，实属正常。

不需要。需要与否，取决于用户的主观判断。大家都认为 porn 和 drug 内容是spam，但是也不排除有人将这类邮件标为 ham 的。

Anti-Spam

常用的反垃圾邮件有以下几种方法：

静态关键词列表。如果邮件头（标题，收发件人，电邮地址，正文）含某些关键词（例如Viagra），就将邮件标为Spam 或 Ham。这是最简单的方式，为各大邮件厂商所采用，包括Gmail。它最大的优点是快。缺点多多，一是需要维护（增／改／删关键词），二是准确率不高（含黑名单中关键词的邮件未必全是Spam，反之亦然），三是不能识别含有干扰因素的邮件。例如，V1agra，发*漂，含这种关键词的邮件，人眼立即能识别它是垃圾邮件，但是静态法就傻了。

正则表达式规则表。与静态关键词列表相反，它速度稍慢，但是极其强大和灵活。对于邮件头的扫描，效果尤佳：邮件头是有规律可循的，尤其是对于大量的垃圾邮件而言，不可能不在邮件头中留下蛛丝马迹。
但是这种方法也有其短板。与上述方法类似，它也需要专人来维护，而且无论从配置难度到维护成本，都远高于前者。对于邮件的正文，正则表达式的扫描速度比较缓慢，尤其是对于精心设计了干扰因素的垃圾邮件。有相当大的一部分邮件，人眼看上去确实也是垃圾邮件，但是使用正则表达式也不好写规则。一个新的规则写手，可能要在准确率与查杀总量的折哀上花费很长一段时间才能掌握其规律。

贝叶斯概率法。若已知某些字词经常出现在垃圾邮件中，却很少出现在合法邮件中，当一封邮件含有这些字词时，那么link它是垃圾邮件的可能性就很大。参考此文。贝叶斯过滤技术。
它最大的优点是，只要有足够健壮的算法，足够的样本空间，其准确率是非常高的。同时，它主要依赖于机器学习，而不需要后期大量的人工干预。

国内有的网站，其内容过滤系统极其简单粗暴，只要出现单个汉字“日”，“操”，“干”等等字眼，就当作垃圾邮件／评论对待，而不分析具体上下文，实在令人又好气又好笑。又有，《百家姓》的常见姓氏用字本身不是垃圾字眼或违禁词汇，如果将其加入静态列表，就会导致连萝卜也无法搜索。其实，用一点点正则表达式（环视）或贝叶斯的技术（条件概率），就能提高过滤质量，皆大欢喜。当然，如果要扫描亿万级的网页，速度的要求肯定要优先于准确度，某些情况下只能做到大致靠谱罢了。然而，频频出错的系统，即使快一点点又有何用（成语：南辕北辙）？不过，从来都是宁枉勿纵的。

由于静态法的特点，注定了列表只能向管理员开放，而对普通游客讳莫如深。这导致了另一种现象：该贴无法显示，是因为含有某关键词。至于哪些词是关键词，不好意思，不能告诉你，怕这个列表一旦公开，想发类似内容的人就能轻易绕过。那就有劳管理员们从严自省，并用心地揣摩圣意。

动静结合，人、机结合，系统才能越用越新。@chunzi说得很形象：反垃圾邮件的过程，不是拼耐力的马拉松赛跑，而是适者生存的进化。总是魔已先高一丈，道才一尺尺增高，并最终压住魔。同时有新的魔即将出现。

一些工具

如果你说自己的邮箱里其实没多少垃圾邮件，或者即使有也已经自动被转入垃圾箱了，那么有两种可能。一是你所用的邮箱系统本身的反垃圾邮件系统做得不错（有太多太多各式各样的明显的垃圾邮件在进入你的邮箱之前，已经被服务器端给block了）。二是你的邮址没有被爬虫抓到或算出来。

Spamassassin是一套不错的反垃圾邮件系统。免费，与Apache紧密结合，强大的正则式支持。国内有一个组织专门动态维护一个中文的规则表，在这里，可以参考。Spamassassin其实也有贝叶斯模块，只是它以正则知名罢了。

WordPress 有个 Akismet 插件是用来block 博客上的垃圾评论的。这个设置起来比较傻瓜（只需要申请一个API）即可，效果比较智能，完全不用用户再手工添加任何规则。对于出错的判断，用户有义务提交给Akismet官方，方便它学习新的变种。应该说，用户提交的漏判或误判，是必不可少的语料库。没有用户提交，Akismet就会一根筋地按照既定的思路继续犯同样的错误。

个人应用

国人开发的Discuz是一款不错的论坛程序。不过，它没有较好的反垃圾模块，我一直在颇厌其烦地删除spam和spammer。看了一下Ak的官网，几乎国外知名的论坛程序都有Ak的插件了。我研究了dz的数据结构，使用python写了一个脚本，定时搜索新贴子，将其提交到Ak做判断。如果判为垃圾，则屏蔽贴子，并对该会员实施减分操作。刚开始试用，效果还可以。其实可以做成原生的php插件，集成到dz中的。

流程很直接：

定时搜索最新贴子；

对于每一个新贴子:

提交给Akismet作测试。

如果不是垃圾，忽视之。

如果是垃圾，将该贴转为仅管理员可见。同时将该用户扣分。

总合一下应该执行的操作，执行SQL, Commit。

生成报表，发邮件给管理员。

Ak的开发者页面在这里 Akismet API Documentation。我用了其中的Python 模块将其封装为一个class，只需要init和check即可：

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
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
#author: rex
#blog: http://iregex.org
#filename comment.py
#created: 2010-08-14 15:58

from akismet import Akismet

class Comment():
def __init__(self):
self.api=Akismet()

if self.api is None or not self.api.verify_key():
print 'No Valid Akismet API'
exit(1)

def init(self, comment, user='', ip='', email=''):
self.user=user.encode("utf-8")
self.comment=comment.encode("utf-8")
self.ip=ip
self.email=email

def check(self):
return self.api.comment_check(self.comment,
{
'comment_author': self.user,
'comment_author_email':self.email,
'user_ip':self.ip,
'user_agent':"Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.2.8) Gecko/20100723 Ubuntu/10.04 (lucid) Firefox/3.6.8",
},
)

这是程序的主要部分

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
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
#author: rex
#blog: http:#iregex.org
#filename dzas.py
#created: 2010-08-14 15:20

#anti spam for discuz! bbs.

from comment import Comment as C
from eml import Email

#########################################################
#global settings
send_email_log =1

dbhost = 'yourhost.website.com';
dbuser = 'db_user';
dbpw = 'yourpassword';
dbname = 'dbname';
dbpre='cdb_'

#punish : punish for the user if he/she publish spam
punish_score=2

#now is 2 hours; you may change
sql={
'last_n_hr':'''select `%sposts`.pid, `%sposts`.author, `%sposts`.message, `%sposts`.useip, `%smembers`.email, authorid from `%sposts`, `%smembers` where dateline>UNIX_TIMESTAMP(now())-2*3600 and `%sposts`.author=`%smembers`.username order by pid desc;''' % (dbpre,dbpre,dbpre,dbpre,dbpre,dbpre,dbpre,dbpre,dbpre,),
'hide':'update %sposts set `status`= 1 where pid in (%s);',
'punish':'update %smembers set credits=credits-%s where uid=%s;',
'find_hided':"SELECT * FROM `%sposts` WHERE `status`=1;"%(dbpre),
}

import MySQLdb

def init_db():
db=MySQLdb.connect(host=dbhost, user=dbuser, passwd=dbpw,db=dbname, charset='utf8')
return db

def hide_spam(db, spam):
c=db.cursor()
sql_str=sql['hide'] % (dbpre,','.join(spam))
c.execute(sql_str)
db.commit()

def punish(db,score):
c=db.cursor()

for u in score.keys():
s=score[u]
sql_str=sql['punish'] % (dbpre,s*punish_score,u)
c.execute(sql_str)
db.commit()

def get_msg(db):
c=db.cursor()
c.execute(sql['last_n_hr'])
records= c.fetchall()
result=[]
for r in records:
result.append(
{
'pid':r[0],
'user':r[1],
'msg':r[2],
'ip':r[3],
'email':r[4],
'uid':r[5]
})

return result

#send log to admin. change the global variable
#send_email_log = 1 or 0 to enable/disable
def report(spam, score):

sub="%s spams caputured" % len(spam)
body="spammers including: %s\n" % ', '.join( set([m['user'] for m in spam] ))
body+="spam pids including: %s\n" % ', '.join( [ str(m['pid']) for m in spam] )

body+="useful sql: %s\n\n" % sql['find_hided']
body+="spam preview: \n%s" % "\n".join( m['msg'].splitlines()[0] for m in spam)
Email(sub.encode("utf-8"),body.encode("utf-8"))

#the core part

def anti_spam(db, msgs):
c=C()
spam=[]
score={}.fromkeys([m['uid'] for m in msgs], 0)
for m in msgs:
c.init(m['msg'], m['user'], m['ip'], m['email'])
if c.check():
score[m['uid']]+=1
spam.append(m)

for s in score.keys():
if score[s]==0:
del score[s]

if score and spam:
hide_spam(db, [str(m['pid']) for m in spam])
punish(db, score)

if send_email_log:
report(spam, score)

def main():
db=init_db()
msg=get_msg(db)
anti_spam(db, msg)

if __name__=='__main__':
main()

正则凡客

rex — Tue, 10 Aug 2010 20:00:51 +0800

按需替换，精准搜索；
有时贪婪，有时懒惰。
喜欢正则，不喜欢回溯；
喜欢用正则解决问题，也知道并非所有问题都能用正则解决。
喜欢在论坛上讨论疑点，也喜欢在博客上分享心得。
自学而未成才，不是什么大牛，我是一名正则凡客。

复杂的正则表达式应该如何构造

rex — Fri, 06 Aug 2010 15:02:46 +0800

昨天Snopo问我如何写一段正则表达式，来提取sql的条件语句。解答之余，想写一篇文章介绍一下经验。文题本来是《如何构造复杂的正则表达式》，但是觉得有些歧义，就感觉正则式本来很简单，我在教人如何将它小事化大一样。正好相反，我的本意是说，即使复杂的正则式也不怕，找出合适的方法，将其构造出来。

避重就轻

Snopo给出的文本是这样的：or and name='zhangsan' and id=001 or age>20 or area='%renmin%' and like，问，如何提取其中正确的SQL查询语句。

简要分析可知，中间部分是合乎要求的，只是两端的有若干个like, or, and。构造能够解析合乎SQL语法的查询语句的正则表达式，应该是比较复杂的。可是，对于具体的问题，也可以更简单。上述的不良构的SQL语句，应该是使用程序自动生成的，它的两端会有一些不符合题意的文本。只要将这些文本去除就可以了。

于是，我写出了正则表达式：s/^(?:(?:or|and|like)\s*)+|\s*(?:(?:or|and|like)\s*)+$//mi;，这样就把多行字串首尾的like, or, and以及可能的空白字符全部去掉了，剩下的内容即为所求。

分而治之

答案发过去之后，Snopo显然不是很满意这种“偷懒”的办法。他继续问道，能否写出正则式，用来匹配合符SQL语法要求的条件查询语句？（只考虑where部分即可，不必写完整的select。）

的确，从快速解决问题的角度来说，只要能够行之有效地解决，用什么办法都可以；不过从学习知识的角度来说，不避重就轻，而是刨根问底，才是正途。既如此，就看一下如何使用正则，将该SQL查询语句解决掉。

最简单的查询语句，应该是真假判断，即 where 1; where True; where false，等等。这样的语句使用正则式，直接/(?:-?\d+|True|False)/i。

稍复杂些的单条语句，可以是左右比较，即

1
name like 'zhang%', 或 age>25 ，或 work in ('it', 'hr', 'R&D')

。将其简单化，结构就变为A OP B。其中A代表变量，OP代表比较操作符，B代表值。

A: 最简单的A，应该是\w+。考虑到实际情况，变量包含点号或脱字符，例如`table.salary`，可以记为/[\w.`]+/。这是比较笼统的细化。如果要求比较苛刻，还可以做到让脱字符同时在左右两边出现（条件判断）。

OP: Where 常用的几种关系比较为：=, <>, >, <, >=, <=, Between, Like, in。使用简单的正则描述之，成为：/(?:[<>=]{1,2}|Between|Like|In)/i。

B: B 的情况又可分为3种：变量，数字，字符串，列表。为简单起见，这里就不考虑算术表达式了。

变量的话，直接延用A的定义即可。不赘述。

数字：使用/\d+/来定义。不考虑小数和负数了。

字符串：包括单引号字串和双引号字串。中间可以包括被转义的引号。我写了一个符合这一要求的引号字串正则表达式，形如：/(['"])(?:\\['"]|[^\\1])*?\1/。不过，由于它只是庞大机器的一个零件，这样写的风险是极其大的。首先，它使用了反向引用；其次，该反向引用使用了全局的反向引用编号。我写了自动生成全局编号的函数，来解决这一问题。不过，这里谈细节是不是太深入了。应该先谈框架，再说细节才对。不应该一入手就陷进细节的汪洋大海。

列表：列表是形如(1, 3 , 4) 或 ("it", "hr", "r&d")之类的东东，它由简单变量以逗号相连，两边加上括号组成。列表的单项以I表示，它代表数字|字符串。此时，列表就变为：/$I(?:,I)*?$/。它表示，左括号，一个I，一系列由逗号、I组成的其它列表项（0个或多个），右括号。简单起见没有考虑空白字符。

至此，可以总结出单条语句的正则框架：S =~ /A OP B/i。S在此代表单条语句。

更为复杂的是多条语句，可以由单条语句组成，中间使用 and 或 or 连接。合理地构造单条语句，将其稳定地编制为多条语句，任务就完成了。

沿用上面的示例，以S代表单条语句，那么复合语句C就是 C =~ S(?:(?:or|and) S)*?/。至此，一个初具规模的条件语句解析器就诞生了。下面以python为例，一步一步实现出来。

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
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
#author: rex
#blog: http://iregex.org
#filename test.py
#created: 2010-08-06 17:12

#generage quoted string;
#including ' and " string
#allow \' and \" inside
index=0
def gen_quote_str():

global index
index+=1
char=chr(96+index)
return r"""(?P<quote_%s>['"])(?:\\['"]|[^'"])*?(?P=quote_%s)"""% (char, char)

#simple variable
def a():
return r'[\w.`]+'

#operators
def op():
return r'(?:[<>=]{1,2}|Between|Like|In)'

#list item within (,)
#eg: 'a', 23, a.b, "asdfasdf\"aasdf"
def item():
return r"(?:%s|%s)" % (a(), gen_quote_str())

#a complite list, like
#eg: (23, 24, 44), ("regex", "is", "good")
def items():
return r"""$ \s*
%s
(?:,\s* %s)* \s*
$""" % (item(), item())

#simple comparison
#eg: a=15 , b>23
def s():
return r"""%s \s* %s \s* (?:\w+| %s | %s )""" % (a(), op(), gen_quote_str(), items())

#complex comparison
# name like 'zhang%' and age>23 and work in ("hr", "it", 'r&d')
def c():
return r"""
(?ix) %s
(?:\s*
(?:and|or)\s*
%s \s*
)*
""" % (s(), s())

print "A:\t", a()
print "OP:\t", op()
print "ITEM:\t", item()
print "ITEMS:\t", items()
print "S:\t", s()
print "C:\t", c()

该代码在我的机器上(Ubuntu 10.04, Python 2.6.5)运行的结果是：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
A: [\w.`]+
OP: (?:[<>=]{1,2}|Between|Like|In)
ITEM: (?:[\w.`]+|(?P<quote_a>['"])(?:\\['"]|[^'"])*?(?P=quote_a))
ITEMS: $ \s*
(?:[\w.`]+|(?P<quote_b>['"])(?:\\['"]|[^'"])*?(?P=quote_b))
(?:,\s* (?:[\w.`]+|(?P<quote_c>['"])(?:\\['"]|[^'"])*?(?P=quote_c)))* \s*
$
S: [\w.`]+ \s* (?:[<>=]{1,2}|Between|Like|In) \s* (?:\w+| (?P<quote_d>['"])(?:\\['"]|[^'"])*?(?P=quote_d) | $ \s*
(?:[\w.`]+|(?P<quote_e>['"])(?:\\['"]|[^'"])*?(?P=quote_e))
(?:,\s* (?:[\w.`]+|(?P<quote_f>['"])(?:\\['"]|[^'"])*?(?P=quote_f)))* \s*
$ )
C:
(?ix) [\w.`]+ \s* (?:[<>=]{1,2}|Between|Like|In) \s* (?:\w+| (?P<quote_g>['"])(?:\\['"]|[^'"])*?(?P=quote_g) | $ \s*
(?:[\w.`]+|(?P<quote_h>['"])(?:\\['"]|[^'"])*?(?P=quote_h))
(?:,\s* (?:[\w.`]+|(?P<quote_i>['"])(?:\\['"]|[^'"])*?(?P=quote_i)))* \s*
$ )
(?:\s*
(?:and|or)\s*
[\w.`]+ \s* (?:[<>=]{1,2}|Between|Like|In) \s* (?:\w+| (?P<quote_j>['"])(?:\\['"]|[^'"])*?(?P=quote_j) | $ \s*
(?:[\w.`]+|(?P<quote_k>['"])(?:\\['"]|[^'"])*?(?P=quote_k))
(?:,\s* (?:[\w.`]+|(?P<quote_l>['"])(?:\\['"]|[^'"])*?(?P=quote_l)))* \s*
$ ) \s*
)*

请看匹配效果图：

算术表达式

我记得刚才好像提到“为简单起见，这里就不考虑算术表达式了”。不过，解析算术表达式是个非常有趣的话题，只要是算法书，都会提及（中缀表达式转前缀表达式，诸如此类）。当然它也可以使用正则表达式来描述。

其主要思路是：

1
2
3
expr -> expr + term | expr - term | term
term -> term * factor | term / factor | factor
factor -> digit | ( expr )

以及代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
#author: rex
#blog: http://iregex.org
#filename math.py
#created: 2010-08-07 00:44

integer=r"\d+"

factor=r"%s (?:\. %s)?" % (integer, integer)

term= "%s(?: \s* [*/] \s* %s)* " % (factor, factor)

expr= "(?x) %s(?: \s* [+-] \s* %s)* " % (term, term)

print expr

看一下它的输出和匹配效果图：

小贴士

如果不用复杂的正则式就能解决问题，一定不要用。

如果必须写比较复杂的正则式，请参考以下原则。

从大处着眼，先理解待解析的文本的整体结构是什么样子，划分为小部件；

从细处着手，试图实现每一个小部件，力求每一部分都是完整、坚固的，且放在全局也不会冲突。

合理组装这些部件。

分而治之的好处：只有某个模块出错，其它部分没错时，可以迅速定位错误，消除BUG。

谨慎使用捕获括号，除非你知道自己在做什么，知道它会有什么副作用，以及是否有可行的解决措施。对于短小的正则式来说，一两个多余的括号是无伤大雅的；但是对于复杂的正则式来说，一对多余的括号可能就是致命的错误。

尽量使用free-space模式。此时你可以自由地添加注释和空白字符，以便提高正则表达式的可读性。

格式化HTML标签缩进

rex — Wed, 04 Aug 2010 13:06:40 +0800

读者“神の呼出”留言询问如何格式化HTML的标签缩进，并给出了他的思路和解法，是从纯粹的正则出发。例如，寻找配对的标签要用到后向引用，标签嵌套则使用递归。不过，这两个特性虽然很有用，却不宜滥用。本文试图从另一个角度出发，简化思路，降低对正则的依赖，以便提高速度。

问题描述

总目标：格式化HTML文本，按标签的层级输出。

标签是平衡的，例如<div></div>。

标签也有可能不是以配对的形式出现的，例如<img ... />。

标签可能嵌套出现的，例如：
1
2
3
<div>
<div></div>
</div>

所有的文本可能是以单行形式给出，没有换行符、水平制表符等空白字符。

输出时，每出现一组新的标签，缩进一个层级。

最内层的标签应处于同级。

所有的文字应与其父标签同级。

独立元素实现同级缩进。

解决思路

我主要说一下思路，并给出Python版的实现。其中用到的正则，都是简单正则，可以方便地翻译为其它语言。

由于源文本是单行文本（默认情况），需要在合适的地方插入换行符。我的思路是，在不是位于行首的左尖括号处加入换行符。要使用多行模式，以便让^能匹配字串内的行首。使用的正则式是(?<!^)\s*(?=<)。注意，它顺便去掉了尖括号左侧的可能的任意个空白字符。实际运行时，它不但处理单行，还处理多行。

同理，在不是位于行尾的右尖括号的右侧插入换行符。正则式为(?<!^)\s*(?=<)。同理。

现在，以文本行为单位处理每一行文本。

设置层级变量level，初始值为0。

如果层级向右缩进，则level++；如果向左伸出，则level–。

如果该行包含"/>"，则这是一个独立的缩进单位，层级不变，直接输出level个层级符号，以及该行文本即可。

否则，如果该行以"</"开头，则表明是一个层级的结束，应该先level–，再输出该行内容。此顺序很重要。

否则，如果该行以"<"开头，则表明这是一个层级的开始，应该先level++，再输出该行内容。顺序同样重要。

其余情况，就是普通文本，直接继承上个层级的缩进量，再输出该行文本即可。

程序至此为止。当然，如果想处理更加复杂的情况，可以酌情增减语句。例如，我所处理的文本，有的是一个标签太长，因此分行写的，例如：

1
2
3
4
<!DOCTYPE
html
PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

对于这样的情况，我只好给出纯粹的正则解法，虽然速度不快，但是不重复，不遗漏：

1
2
3
4
5
#combine < \n..> lines
x=re.search(r"(<[^<>]+)\s*\n\s*",content)
while x:
content=content.replace(x.group(0),x.group(1)+" ")
x=re.search(r"(<[^<>]+)\s*\n\s*",content)

这种情况，我想不出正则以外的解法。

Python代码

实现只是小道。如果理解了上述思路，很容易转为其它语言的代码。JS, PHP都可以。请读者自已实现。有问题请留言。

该python代码的使用方式是： ./format_html.py source.html> dest.html

完整代码：

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
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
#author: rex
#blog: http://iregex.org
#filename format_html.py
#created: 2010-08-04
import re,sys

indent="\t"
f=open(sys.argv[1])
content=f.read()
f.close()
content=content.strip()

#combine < \n..> lines
x=re.search(r"(<[^<>]+)\s*\n\s*",content)
while x:
content=content.replace(x.group(0),x.group(1)+" ")
x=re.search(r"(<[^<>]+)\s*\n\s*",content)

content=re.sub(r"(?m)(?<!^)\s*(?=<)","\n", content)
content=re.sub(r"(?<=>)\s*(?=\S)","\n", content);
lines=content.splitlines()

level=0
for l in lines:
if "/>" in l:
print "%s%s"%(indent*level,l)
elif l[:2]=='</' :
level -=1
print "%s%s"%(indent*level,l)
elif l[:1]=='<':
print "%s%s"%(indent*level,l)
level +=1
else:
print "%s%s"%(indent*level,l)

Trie in Python

rex — Sun, 01 Aug 2010 22:58:54 +0800

关于 Trie 的介绍，请读上文Trie，此不赘述。本文主要分析 Trie 实现原理，并给出 Python 的实现。

构造检索树

先正更上文不精确之处。上文说，

具体说来，就是提取出备选项文本的公共部分，构造“检索树”…

其实 Trie 并不是提取所有的“公共部分”，而是只提取“前缀”而已。例如，对于正则式/abbcc|abcc/，它生成的结果是(?-xism:ab(?:bcc|cc))，而非abb?cc，可见它并没有智能到足够程度，可应用之而不可迷信之。具体原因，可以通过读源码以及本文分析而理解。

新建一个 Trie 对象之后，每向它添加一个字串，它都做如下操作：

整体的数据结构是 Hash 表，亦即Python中的Dictionary。

Hash表的每一个元素指向它自身；以所输入的子串的每个字母为Key，如果它自身为空，则指向一个新建的匿名Hash；

最后一个元素的Key为空字串‘’，value为1。这也是判断每个分支是否结束的标志。

请看一下对于字串 foobar分析后所生成的数据结构：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
{
'f' => {
'o' => {
'o' => {
'b' => {
'a' => {
'r' => {
'' => 1
}
}
}
}
}
}
}

很美观，对不对。奇妙的是，对于第一条字串，它生成的结构是这样的；对于新插入的第二条，第三条……第N条字串，它不是另起炉炉灶，而是萧规曹随，见缝插针，充分利用前面已经成生的数据结构。这要归功于Hash/Dictionary这种数据结构的特点。看一下针对于foobar foobah fooxar foozap fooza 完全插入后的效果：

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
'f' => {
'o' => {
'o' => {
'b' => {
'a' => {
'h' => {
'' => 1
},
'r' => {
'' => 1
}
}
},
'x' => {
'a' => {
'r' => {
'' => 1
}
}
},
'z' => {
'a' => {
'' => 1,
'p' => {
'' => 1
}
}
}
}
}
}
}

这个结构图很直观地解释了为什么是提取前缀而非后缀中缀什么的。

构造一个检索树，已经不是一个问题。现在来看看如何将它转换为正则表达式。

检索树的正则表现

原文源码比较精炼，用了许多Perl特有的语法且无注释。我简要解释一下作者思路。

如果当前节点的 key 为空，且当前只有一个键，则该分支结束，返回空值。这也是前文伏笔的照应：为什么要加上$ref->{''}=1;。

对于不为空的节点，一一分析之。

只要当前节点不为空，一直递归调用本函数，将当前key+下个节点的递归结果push到数组@alt中备用。

否则只将 key push到 @cc中。

@cc是用来保存单个字母的，而@alt则是用来保存多个字母的备选项的。

将@cc中的元素格式化为[abc]的样子。当然，如果只有一个元素就不必了。

将@alt中的元素格式化为(?:abc|xyz)的样子，一个元素则免。

在适当的地方添加问号，表示备选。

读懂了源码，自己实现起来就不是问题了。我在读此代码时，使用了纸笔抄写、观测print、Data::Dumper输出等方式来辅助理解。事实证明卓有成效。

移植到Python

从Perl到Python，其实就像从英语到法语的转换一样，只是将拼写方式，细微语法修整一下即可，算不得伤筋动骨的大手术。我是用它来验证理解、熟悉语法细节的。代码如下。只要from trie import Trie就能使用了。

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
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
#author: rex
#blog: http://iregex.org
#filename tr.py
#created: 2010-08-01 20:24

class Trie():
"""Regexp::Trie in python"""
def __init__(self):
self.data={}

def add(self, word):
ref=self.data
for char in word:
ref[char]=ref.has_key(char) and ref[char] or {}
ref=ref[char]
ref['']=1

def dump(self):
return self.data

def _regexp(self, pData):
data=pData
if data.has_key("") and len(data.keys())==1:
return None

alt=[]
cc=[]
q=0
for char in sorted(data.keys()):
if isinstance(data[char],dict):
try:
recurse=self._regexp(data[char])
alt.append(char+recurse)
except:
cc.append(char)
else:
q=1
cconly=len(alt) and 0 or 1 #if len, 0; else:0

if len(cc)>0:
if len(cc)==1:
alt.append(cc[0])
else:
alt.append('['+''.join(cc)+']')

if len(alt)==1:
result=alt[0]
else:
result="(?:"+"|".join(alt)+")"

if q:
if cconly:
result+="?"
else:
result="(?:%s)?" % result
return result
def regexp(self):
return "(?-xism:%s)" % self._regexp(self.dump())

a=Trie()

for w in ['foobar', 'foobah', 'fooxar', 'foozap', 'fooza']:
a.add(w)
print a.regexp()

Ubuntu 10.04, Python 2.6.5 环境下测试通过。

Trie

rex — Sun, 01 Aug 2010 08:51:16 +0800

从《Effective Perl》上学习到一个module：Regexp::Trie。它属于正则优化类的module，具体说来，就是提取出备选项文本的公共部分，构造“检索树”，以便最大程度上减少回溯，提升效率。

试用了一下。对于简单的例子，它的效果很惊艳；对于复杂的例子，这个优化器的“机器人”的性格就显示出来了，感觉不如手工写得更高效，更有针对性。见例子：

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

#!/usr/bin/perl
#author: rex
#blog: http://iregex.org
#filename a.pl
#created: 2010-08-01

use Regexp::Trie;

my @simple=qw/foobar foobah fooxar foozap fooza/;
my @complex=qw/AuthenticViagra BestDealsOnViagra BestMaleTablets GenuineOnlineViagra GreatViagraShop OriginalViagra TopViagraShop VIAGRA ViagraBestOnlineShop ViagraBrandReseller ViagraPills onlineshop/;
#the simple one
my $t_s=Regexp::Trie->new;

foreach (@simple){
$t_s->add($_);
}

#the complex one
my $t_c=Regexp::Trie->new;
foreach (@complex){
$t_c->add($_);
}

print "simple regex trie: ", $t_s->regexp, "\n";
print "complex regex trie: ", $t_c->regexp, "\n";

其输出结果为：

1 2	simple regex trie: (?-xism:foo(?:ba[hr]\|xar\|zap?)) complex regex trie: (?-xism:(?:AuthenticViagra\|Best(?:DealsOnViagra\|MaleTablets)\|G(?:enuineOnlineViagra\|reatViagraShop)\|OriginalViagra\|TopViagraShop\|V(?:IAGRA\|iagra(?:B(?:estOnlineShop\|randReseller)\|Pills))\|onlineshop))

对于第2个例子，可以看出来，Trie是基于单个字符来优化的，而不是基于单词。虽然如此，它还是会极大地减少程序员的手工劳动。毕竟，未经优化的多选结构的效率之差不言而喻的，只要经过Trie的优化，其效率就会有质的飞跃；而手工的调教，只是在该飞跃的基础上再有一点点提升而已。对正则表达式比较头痛的程序员，更是可以无视自己的优化，直接使用该module而已。不过，使用Perl的程序员，应该不会对正则表达式头痛吧？

Perl 5.10 之后的版本，已经内置了类似于Trie的优化机制，因此没有手动优化的必要了。不过，我还是好奇于它的实现：

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

package Regexp::Trie;
use 5.008001;
use strict;
use warnings;

our $VERSION = sprintf "%d.%02d", q$Revision: 0.2 $ =~ /(\d+)/g;

# use overload q("") => sub { shift->regexp };

sub new{ bless {} => shift }
sub add{
my $self = shift;
my $str = shift;
my $ref = $self;
for my $char (split //, $str){
$ref->{$char} ||= {};
$ref = $ref->{$char};
}
$ref->{''} = 1; # { '' => 1 } as terminator
$self;
}
sub _regexp{
my $self = shift;
return if $self->{''} and scalar keys %$self == 1; # terminator
my (@alt, @cc);
my $q = 0;
for my $char (sort keys %$self){
my $qchar = quotemeta $char;
if (ref $self->{$char}){
if (defined (my $recurse = _regexp($self->{$char}))){
push @alt, $qchar . $recurse;
}else{
push @cc, $qchar;
}
}else{
$q = 1;
}
}
my $cconly = !@alt;
@cc and push @alt, @cc == 1 ? $cc[0] : '['. join('', @cc). ']';
my $result = @alt == 1 ? $alt[0] : '(?:' . join('|', @alt) . ')';
$q and $result = $cconly ? "$result?" : "(?:$result)?";
return $result;
}
sub regexp{ my $str = shift->_regexp; qr/$str/ }

1;

大致读了一下，让我想起之前我写过的一篇《关于从普通文本提取正则表达式的再思考》。不过，我的是业余与Trie的专业的差距，呵呵。这两天学习一下这段代码。若有值得分享的心得，再贴出来。

Python 中文正则笔记

rex — Sun, 27 Jun 2010 11:50:41 +0800

总结在 python 语言里使用正则表达式匹配中文的经验。关键词：中文，cjk，utf8，unicode，python。

从字符串的角度来说，中文不如英文整齐、规范，这是不可避免的现实。本文结合网上资料以及个人经验，以 python 语言为例，稍作总结。欢迎补充或挑错。

一点经验

可以使用 repr()函数查看字串的原始格式。这对于写正则表达式有所帮助。

Python 的 re模块有两个相似的函数：re.match(), re.search 。两个函数的匹配过程完全一致，只是起点不同。match只从字串的开始位置进行匹配，如果失败，它就此放弃；而search则会锲而不舍地完全遍历整个字串中所有可能的位置，直到成功地找到一个匹配，或者搜索完字串，以失败告终。如果你了解match的特性（在某些情况下比较快），大可以自由用它；如果不太清楚，search通常是你需要的那个函数。

从一堆文本中，找出所有可能的匹配，以列表的形式返回，这种情况用findall()这个函数。例子见后面的代码。

utf8下，每个汉字占据3个字符位置，正则式为[\x80-\xff]{3}，这个都知道了吧。

unicode下，汉字的格式如\uXXXX，只要找到对应的字符集的范围，就能匹配相应的字串，方便从多语言文本中挑出所需要的某种语言的文本。不过，对于像日文这样的粘着语，既有中文字符，又有平假名片假名，或许结果会有所偏差。

两种字符类可以并列在一起使用，例如，平假名、片假名、中文的放在一起，u"[\u4e00-\u9fa5\u3040-\u309f\u30a0-\u30ff]+"，来自定义所需要匹配的文本。

匹配中文时，正则表达式和目标字串的格式必须相同。这一点至关重要。或者都用默认的utf8，此时你不用额外做什么；如果是unicode，就需要在正则式之前加上u""格式。

可以这样定义unicode字符串：string=u"我爱正则表达式"。如果字串不是unicode的，可以使用unicode()函数转换之。如果你知道源字串的编码，可以使用newstr=unicode(oldstring, original_coding_name)的方式转换，例如 linux 下常用unicode(string, "utf8")，windows 下或许会用cp936吧，没测试。

例程序

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
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
#author: rex
#blog: http://iregex.org
#filename py_utf8_unicode.py
#created: 2010-06-27 09:11

import re
def findPart(regex, text, name):
res=re.findall(regex, text)
if res:
print "There are %d %s parts:\n"% (len(res), name)
for r in res:
print "\t",r
print

#sample is utf8 by default.
sample='''en: Regular expression is a powerful tool for manipulating text.
zh: 正则表达式是一种很有用的处理文本的工具。
jp: 正規表現は非常に役に立つツールテキストを操作することです。
jp-char: あアいイうウえエおオ
kr:정규 표현식은 매우 유용한 도구 텍스트를 조작하는 것입니다.
puc: 。？！、，；：“ ”‘ ’——……·－·《》〈〉！￥％＆＊＃
'''
#let's look its raw representation under the hood:
print "the raw utf8 string is:\n", repr(sample)
print

#find the non-ascii chars:
findPart(r"[\x80-\xff]+",sample,"non-ascii")

#convert the utf8 to unicode
usample=unicode(sample,'utf8')

#let's look its raw representation under the hood:
print "the raw unicode string is:\n", repr(usample)
print

#get each language parts:
findPart(u"[\u4e00-\u9fa5]+", usample, "unicode chinese")
findPart(u"[\uac00-\ud7ff]+", usample, "unicode korean")
findPart(u"[\u30a0-\u30ff]+", usample, "unicode japanese katakana")
findPart(u"[\u3040-\u309f]+", usample, "unicode japanese hiragana")
findPart(u"[\u3000-\u303f\ufb00-\ufffd]+", usample, "unicode cjk Punctuation")

其输出结果为：

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
the raw utf8 string is:
'en: Regular expression is a powerful tool for manipulating text.\nzh: \xe6\xad\xa3\xe5\x88\x99\xe8\xa1\xa8\xe8\xbe\xbe\xe5\xbc\x8f\xe6\x98\xaf\xe4\xb8\x80\xe7\xa7\x8d\xe5\xbe\x88\xe6\x9c\x89\xe7\x94\xa8\xe7\x9a\x84\xe5\xa4\x84\xe7\x90\x86\xe6\x96\x87\xe6\x9c\xac\xe7\x9a\x84\xe5\xb7\xa5\xe5\x85\xb7\xe3\x80\x82\njp: \xe6\xad\xa3\xe8\xa6\x8f\xe8\xa1\xa8\xe7\x8f\xbe\xe3\x81\xaf\xe9\x9d\x9e\xe5\xb8\xb8\xe3\x81\xab\xe5\xbd\xb9\xe3\x81\xab\xe7\xab\x8b\xe3\x81\xa4\xe3\x83\x84\xe3\x83\xbc\xe3\x83\xab\xe3\x83\x86\xe3\x82\xad\xe3\x82\xb9\xe3\x83\x88\xe3\x82\x92\xe6\x93\x8d\xe4\xbd\x9c\xe3\x81\x99\xe3\x82\x8b\xe3\x81\x93\xe3\x81\xa8\xe3\x81\xa7\xe3\x81\x99\xe3\x80\x82\njp-char: \xe3\x81\x82\xe3\x82\xa2\xe3\x81\x84\xe3\x82\xa4\xe3\x81\x86\xe3\x82\xa6\xe3\x81\x88\xe3\x82\xa8\xe3\x81\x8a\xe3\x82\xaa\nkr:\xec\xa0\x95\xea\xb7\x9c \xed\x91\x9c\xed\x98\x84\xec\x8b\x9d\xec\x9d\x80 \xeb\xa7\xa4\xec\x9a\xb0 \xec\x9c\xa0\xec\x9a\xa9\xed\x95\x9c \xeb\x8f\x84\xea\xb5\xac \xed\x85\x8d\xec\x8a\xa4\xed\x8a\xb8\xeb\xa5\xbc \xec\xa1\xb0\xec\x9e\x91\xed\x95\x98\xeb\x8a\x94 \xea\xb2\x83\xec\x9e\x85\xeb\x8b\x88\xeb\x8b\xa4.\npuc: \xe3\x80\x82\xef\xbc\x9f\xef\xbc\x81\xe3\x80\x81\xef\xbc\x8c\xef\xbc\x9b\xef\xbc\x9a\xe2\x80\x9c \xe2\x80\x9d\xe2\x80\x98 \xe2\x80\x99\xe2\x80\x94\xe2\x80\x94\xe2\x80\xa6\xe2\x80\xa6\xc2\xb7\xef\xbc\x8d\xc2\xb7\xe3\x80\x8a\xe3\x80\x8b\xe3\x80\x88\xe3\x80\x89\xef\xbc\x81\xef\xbf\xa5\xef\xbc\x85\xef\xbc\x86\xef\xbc\x8a\xef\xbc\x83\n'

There are 14 non-ascii parts:

正则表达式是一种很有用的处理文本的工具。
正規表現は非常に役に立つツールテキストを操作することです。
あアいイうウえエおオ
정규
표현식은
매우
유용한
도구
텍스트를
조작하는
것입니다
。？！、，；：“
”‘
’——……·－·《》〈〉！￥％＆＊＃

the raw unicode string is:
u'en: Regular expression is a powerful tool for manipulating text.\nzh: \u6b63\u5219\u8868\u8fbe\u5f0f\u662f\u4e00\u79cd\u5f88\u6709\u7528\u7684\u5904\u7406\u6587\u672c\u7684\u5de5\u5177\u3002\njp: \u6b63\u898f\u8868\u73fe\u306f\u975e\u5e38\u306b\u5f79\u306b\u7acb\u3064\u30c4\u30fc\u30eb\u30c6\u30ad\u30b9\u30c8\u3092\u64cd\u4f5c\u3059\u308b\u3053\u3068\u3067\u3059\u3002\njp-char: \u3042\u30a2\u3044\u30a4\u3046\u30a6\u3048\u30a8\u304a\u30aa\nkr:\uc815\uaddc \ud45c\ud604\uc2dd\uc740 \ub9e4\uc6b0 \uc720\uc6a9\ud55c \ub3c4\uad6c \ud14d\uc2a4\ud2b8\ub97c \uc870\uc791\ud558\ub294 \uac83\uc785\ub2c8\ub2e4.\npuc: \u3002\uff1f\uff01\u3001\uff0c\uff1b\uff1a\u201c \u201d\u2018 \u2019\u2014\u2014\u2026\u2026\xb7\uff0d\xb7\u300a\u300b\u3008\u3009\uff01\uffe5\uff05\uff06\uff0a\uff03\n'

There are 6 unicode chinese parts:

正则表达式是一种很有用的处理文本的工具
正規表現
非常
役
立
操作

There are 8 unicode korean parts:

정규
표현식은
매우
유용한
도구
텍스트를
조작하는
것입니다

There are 6 unicode japanese katakana parts:

ツールテキスト
ア
イ
ウ
エ
オ

There are 11 unicode japanese hiragana parts:

は
に
に
つ
を
することです
あ
い
う
え
お

There are 5 unicode cjk Punctuation parts:

。
。
。？！、，；：
－
《》〈〉！￥％＆＊＃

正则笔记

rex — Mon, 21 Jun 2010 23:04:15 +0800

笔记三则，贴在这里。

首字母大小写无关模式

有一段时间，我在写正则表达式来匹配Drug关键字时，经常写出 /viagra|cialis|anti-ed/ 这样的表达式。为了让它更美观，我会给关键词排序；为了提升速度，我会使用 /[Vv]iagra/ 而非/viagra/i ，只让必要的部分进行大小写通配模式。确切地说，我是需要对每个单词的首字母进行大小写无关的匹配。

我写了这样的一个函数，专门用来批量转换。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#convert regex to sorted list, then provide both lower/upper case for the first letter of each word
#luf means lower upper first

sub luf{
# split the regex with the delimiter |
my @arr=sort(split(/\|/,shift));

# provide both the upper and lower case for the
# first leffer of each word
foreach (@arr){s/\b([a-zA-Z])/[\l$1\u$1]/g;}

# join the keyword to a regex again
join('|',@arr);
}

print luf "sex pill|viagra|cialis|anti-ed";
# the output is:[aA]nti-[eE]d|[cC]ialis|[sS]ex [pP]ill|[vV]iagra

控制全局匹配下次开始的位置

记得jyf曾经问过我，如何控制匹配开始的位置。嗯，现在我可以回答这个问题了。Perl 提供了 pos 函数，可以在 /g 全局匹配中调整下次匹配开始的位置。举例如下：

1
2
3
4
5
$_="abcdefg";
while(/../g)
{
print $&;
}

其输出结果是每两个字母，即ab, cd, ef

可以使用 pos($_)来重新定位下一次匹配开始的位置，如：

1
2
3
4
5
6
$_="abcdefg";
while(/../g)
{
pos($_)--; #pos($_)++;
print $&;
}

输出结果：

1
2
pos($_)--: ab, bc, cd, de, ef, fg.
pos($_)++: ab, de.

可以阅读 Perl 文档中关于 pos的章节获取详细信息。

散列与正则表达式替换

《effective-perl-2e》第三章有这样一个例子（见下面的代码），将特殊符号转义。

1
2
my %ent = { '&' => 'amp', '<' => 'lt', '>' => 'gt' };
$html =~ s/([&<>])/&$ent{$1};/g;

这个例子非常非常巧妙。它灵活地运用了散列这种数据结构，将待替换的部分作为 key ，将与其对应的替换内容作为 value 。这样只要有匹配就会捕获，然后将捕获的部分作为 key ，反查到 value 并运用到替换中，体现了高级语言的效率。

不过，这样的 Perl 代码，能否移植到 Python 中呢？ Python 同样支持正则，支持散列（Python 中叫做 Dictionary），但是似乎不支持在替换过程中插入太多花哨的东西（替换行内变量内插）。

查阅 Python 的文档，（在 shell 下执行 python ，然后 import re，然后 help(re)），：

1
2
3
4
5
6
7
sub(pattern, repl, string, count=0)
Return the string obtained by replacing the leftmost
non-overlapping occurrences of the pattern in string by the
replacement repl. repl can be either a string or a callable;
if a string, backslash escapes in it are processed. If it is
a callable, it's passed the match object and must return
a replacement string to be used.

原来 python 和 php 一样，是支持在替换的过程中使用 callable 回调函数的。该函数的默认参数是一个匹配对象变量。这样一来，问题就简单了：

1
2
3
4
5
6
7
8
9
ent={'<':"lt",
'>':"gt",
'&':"amp",
}

def rep(mo):
return ent[mo.group(1)]

html=re.sub(r"([&<>])",rep, html)

python 替换函数 callback 的关键点在于其参数是一个匹配对象变量。只要明白了这一点，查一下手册，看看该种对象都有哪些属性，一一拿来使用，就能写出灵活高效的 python 正则替换代码。

Superor老师的正则表达式视频教程

rex — Sun, 20 Jun 2010 09:35:06 +0800

浏览CU时发现Superor老师的《探索Perl的世界(更新到40集)-Perl 教学视频》（国人，中文），其中有5集是讲正则表达式的。观看之后觉得不错，贴在这里。

之前贴过余晟老师的正则表达式视频，由于各种不可抗力，所上传到各大空间的，也都渐渐不再能访问。我最早是从老友牛腩粉那里得到的，地址在此，可以留言，碰碰运气。

Superor老师的视频，其实不限于正则表达式，而是系统地讲解 Perl 的教程。我是断章取义，将正则表达式部分摘过来了。Superor老师也说过了，他在学习Perl时，准备了不少书，但是不是系统地看完，而是用到哪一部分，就细读这一部分的全部内容。学正则表达式也可如此。

视频是在线的，效果不错，虽然会插播广告。

第20集：第八章正则表达式

http://www.boobooke.com/v/bbk3748

第21集：第八章正则表达式

http://www.boobooke.com/v/bbk3749

第22集：第八章正则表达式

http://www.boobooke.com/v/bbk3750

第23集：第八章正则表达式

http://www.boobooke.com/v/bbk3751

第24集：第八章正则表达式

http://www.boobooke.com/v/bbk3752