我爱正则表达式 » python

搞定Mac下的郑码输入法

rex — Sun, 07 Nov 2010 14:43:05 +0000

最近用上了Mac, 苦于没有一份好用的郑码输入法. 于是发挥不怕折腾的精神, 自己制作一份码表, 记在这里.

郑码

估计没多少人使用郑码吧, 这是一个非常小众的输入法方案, 与五笔类似, 据说更”规则”. 没有用过五笔, 不好评价. 个人比较喜欢, 一直在用. 无论如何, 拼音输入法是无福消受的.

在Ubuntu下可以使用 ibus, 但是在Mac下就没有这么幸运了. Fit是不错的输入法, 但是只有内置的拼音和五笔, 暂不支持自定义码表; QIM是收费软件, 貌似可以自定义码表, 但它缺少文档, 找了半天没发现多少有用信息.

搜索一番, 找到一个OpenVanilla, 香草输入法. 免费, 开放, 支持自定义码表. 地址在这里 . 另外从郑码爱好者家园上看到一个类似的解决方案, 只不过不太完美(例如, 无法忍受的词频混乱问题). 地址在这里 .

做一份郑码码表

词汇列表: 使用的是搜狗实验室的语料文本. 地址在这里 , 格式为 “词A 词频词性1 词性2 … 词性N”, 取自己有用的词汇以及对应词频信息即可. 该文件只有两字词至多字词, 没有单个汉字的字频信息.

字频列表: 在 lingua.mtsu.edu 上找到了字频列表, 令人喜出望外的是, 它还带有单字的(多音字)拼音/声调. 这为我打造一份带有拼音辅助的码表方案提供了极大的便利. 其实拼音只作为形码的辅助而使用, 只有打不出的字才反查拼音, 无需单字或词汇的简拼信息. 又因为它是辅助, 因此将所有的拼音信息放在做好的列表的末尾即可.

有了上述的两个文件, 就可以准备做码表了. 不过, 还需要单字的构词码码表, 以及约定俗成的快速码表(例如, 对于”北京”一词, 郑码有两种打法, 一是简单的ts, 一是正规的trsj). 单字构词码表之前我已经准备出来了, 后者我从网上搜索到的郑码光盘中找到了大字集的码表.

制作的过程不难, 不过细节不少. 不赘述. 过程中当然少不了正则表达式的帮忙.

最终做出来的是五码郑码. 非常好用. 每次启动香草时要花一秒钟左右的时间, 但是一旦运行起来, 就感觉不到了. 毕竟, 最终的词汇列表为19万条之巨.

香草的最大的优势在于开放和免费. 比起qim或fit来, 它作为一个输入法, 支持的特性/自定义功能实在有限. 连自定义切换中英文也不可以, 更不用说动态调整词频和增删词条了. 我写了一个bash function, 用来搜索现有的词条; 写了一个bash脚本, 用来删除词条; 写了一个python程序, 用来动态添加新词.

最后这个添加新词的python程序还是比较好玩的. 支持从命令行中或文件中读取词汇列表, 批量添加到词库中. 添加过程中它自己生成格式正确的郑码编码; 添加完毕之后还会杀死香草, 以便重新加载新词库.

程序push到github了. 在这里.

Update

2010-11-08查看了一下香草的其它输入法码表，搞定了标点符号。

一个简单的中文分词程序

rex — Sun, 26 Sep 2010 14:41:12 +0000

kds:“前驻法大使吴建民指出，应该理**国”,想了一下，原来两个星号是“性爱”两字，生活在一个机械屏蔽时代的中国还真有喜感。——via

想必您也看到了推特上关于“理＊＊国”的笑话了。我正好想学一下中文分词方面的知识，这是第一篇。

分词原理与实现

英语等以空白字符作为分隔符的语言，分词不是问题。中文分词，需要处理的细节太多。单就“真歧义”这一问题（简言之，如果没有上下文，连活生生的人也无法确定如何断句的歧义句）的处理方法而言，前辈们就已写出洋洋洒洒许多文字。不过这属于进阶题目。我想先实现一个最简单的分词程序。

以我的理解，最简单的分词程序，应该是先将中文文本切成最小的单位－－汉字－－再从词典里找词，将这些字按照最左最长原则（与正则精神暗合），合并为以词为单位的集合。这样的应该是最快的，只按照给定的数据划分合并即可，不必考虑语法元素的权重（词性：名动形数量代等等，语法：主谓宾定状补），以及上下文的出现次数。

关于源文本的切分，就参照《统计汉字／英文单词数》一文的思路，使用正则表达式r"(?x) (?: [\w-]+ | [\x80-\xff]{3} )")来匹配即可。

关于词典，我使用的是CC-CEDICT的词典，原因有三：没有版权问题；速度较快；Chrome也在用它（发现了吧：在Chrome上双击中文句子，会自动选择中文词汇而不是单字或整行进行反选高亮）。

接下来是如何分词。经过思考，我发现搜索树的原理可以拿来就用。原理请见此文：Trie in Python。具体方法是，将词库逐字读入内存，建立搜索树；然后对目标文本进行逐字分析，如果该字之后还可搜索，则继续搜索；否则停止，作为一个词汇单位处理。

这样的算法理论上比较快（未进行benchmark），原因有三：使用Trie结构，本质上是哈希表，空间换时间，是O(0)级的搜索；词库只有800K，可以轻易载入，内存空间没占多少；算法最慢的部分是载入Trie的阶段，之后速度就不再受影响。

不过，谈到它的扩充性，目前只能在words.txt中手动添加新词，而不能实现机器学习。

源码

完整的程序（包括我处理过的词库列表）放在github上了。有兴趣的可以把玩一下。这里列出主程序：

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
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
#author: rex
#blog: http://iregex.org
#filename nlp.py
#created: 2010-09-26 19:15

import re
import sys

regex=re.compile(r"(?x) (?: [\w-]+ | [\x80-\xff]{3} )")

def init_wordslist(fn="./words.txt"):
f=open(fn)
lines=sorted(f.readlines())
f.close()
return lines

def words_2_trie(wordslist):
d={}
for word in wordslist:
ref=d
chars=regex.findall(word)
for char in chars:
ref[char]=ref.has_key(char) and ref[char] or {}
ref=ref[char]
ref['']=1
return d

def search_in_trie(chars, trie):
ref=trie
index=0
for char in chars:
if ref.has_key(char):
print char,
ref=ref[char]
index+=1
else:
if index==0:
index=1
print char,
print '*',
try:
chars=chars[index:]
search_in_trie(chars, trie)
except:
pass
break
def main():
#init
words=init_wordslist()
trie=words_2_trie(words)
#read content
fn=sys.argv[1]
string=open(fn).read()
chars=regex.findall(string)

#do the job
search_in_trie(chars, trie)

if __name__=='__main__':
main()

本机测试

测试的文本如下：

1
2
3
4
5
6
7
8
9
10
11
12
只听得一个女子低低应了一声。绿竹翁道：“姑姑请看，这部琴谱可有些古怪。”那
女子又嗯了一声，琴音响起，调了调弦，停了一会，似是在将断了的琴弦换去，又调了调
弦，便奏了起来。初时所奏和绿竹翁相同，到后来越转越高，那琴韵竟然履险如夷，举重
若轻，毫不费力的便转了上去。令狐冲又惊又喜，依稀记得便是那天晚上所听到曲洋所奏
的琴韵。这一曲时而慷慨激昂，时而温柔雅致，令狐冲虽不明乐理，但觉这位婆婆所奏，
和曲洋所奏的曲调虽同，意趣却大有差别。这婆婆所奏的曲调平和中正，令人听着只觉音
乐之美，却无曲洋所奏热血如沸的激奋。奏了良久，琴韵渐缓，似乎乐音在不住远去，倒
像奏琴之人走出了数十丈之遥，又走到数里之外，细微几不可再闻。

理性爱国
性爱体验
我爱正则表达式

请留意末尾三行。

再看一下程序处理的结果：（＊表示词汇间的分隔）

1
只 * 听得 * 一个 * 女子 * 低低 * 应 * 了 * 一声 * 。 * 绿 * 竹 * 翁 * 道 * ： * “ * 姑姑 * 请看 * ， * 这 * 部 * 琴 * 谱 * 可有 * 些 * 古怪 * 。 * ” * 那 * 女子 * 又 * 嗯 * 了 * 一声 * ， * 琴 * 音响 * 起 * ， * 调 * 了 * 调 * 弦 * ， * 停 * 了 * 一会 * ， * 似是 * 在 * 将 * 断 * 了 * 的 * 琴弦 * 换 * 去 * ， * 又 * 调 * 了 * 调 * 弦 * ， * 便 * 奏 * 了 * 起来 * 。 * 初 * 时 * 所 * 奏 * 和 * 绿 * 竹 * 翁 * 相同 * ， * 到 * 后来 * 越 * 转 * 越 * 高 * ， * 那 * 琴 * 韵 * 竟然 * 履险如夷 * ， * 举重 * 若 * 轻 * ， * 毫不费力 * 的 * 便 * 转 * 了 * 上去 * 。 * 令狐 * 冲 * 又 * 惊 * 又 * 喜 * ， * 依稀 * 记得 * 便是 * 那天 * 晚上 * 所 * 听到 * 曲 * 洋 * 所 * 奏 * 的 * 琴 * 韵 * 。 * 这一 * 曲 * 时而 * 慷慨 * 激昂 * ， * 时而 * 温柔 * 雅致 * ， * 令狐 * 冲 * 虽 * 不明 * 乐理 * ， * 但 * 觉 * 这位 * 婆婆 * 所 * 奏 * ， * 和 * 曲 * 洋 * 所 * 奏 * 的 * 曲调 * 虽 * 同 * ， * 意趣 * 却 * 大有 * 差别 * 。 * 这 * 婆婆 * 所 * 奏 * 的 * 曲调 * 平和 * 中正 * ， * 令人 * 听 * 着 * 只 * 觉 * 音乐之 * 美 * ， * 却 * 无 * 曲 * 洋 * 所 * 奏 * 热血 * 如 * 沸 * 的 * 激 * 奋 * 。 * 奏 * 了 * 良久 * ， * 琴 * 韵 * 渐 * 缓 * ， * 似乎 * 乐音 * 在 * 不住 * 远 * 去 * ， * 倒像 * 奏 * 琴 * 之 * 人 * 走出 * 了 * 数十 * 丈 * 之 * 遥 * ， * 又 * 走 * 到 * 数 * 里 * 之外 * ， * 细微 * 几 * 不可再 * 闻 * 。 * 理性 * 爱国 * 性爱 * 体验 * 我 * 爱 * 正则 * 表达式

更新

2010-10-03更新:发现本程序的一个bug。已改进算法，更精确，更快速。程序详见GitHub，链接如前。

请看新程序的分词结果：

只 * 听 * 得 * 一 * 个 * 女子 * 低 * 低 * 应 * 了 * 一声 * 。 * 绿 * 竹 * 翁 * 道 * ： * “ * 姑姑 * 请看 * ， * 这 * 部 * 琴谱 * 可 * 有些 * 古怪 * 。 * ” * 那 * 女子 * 又 * 嗯 * 了 * 一声 * ， * 琴 * 音响 * 起 * ， * 调 * 了 * 调 * 弦 * ， * 停 * 了 * 一会 * ， * 似 * 是 * 在 * 将 * 断 * 了 * 的 * 琴弦 * 换 * 去 * ， * 又 * 调 * 了 * 调 * 弦 * ， * 便 * 奏 * 了 * 起来 * 。 * 初 * 时 * 所 * 奏 * 和 * 绿 * 竹 * 翁 * 相同 * ， * 到 * 后来 * 越 * 转 * 越 * 高 * ， * 那 * 琴 * 韵 * 竟然 * 履 * 险 * 如 * 夷 * ， * 举重 * 若 * 轻 * ， * 毫不 * 费力 * 的 * 便 * 转 * 了 * 上去 * 。 * 令狐 * 冲 * 又 * 惊 * 又 * 喜 * ， * 依稀 * 记得 * 便是 * 那天 * 晚上 * 所 * 听到 * 曲 * 洋 * 所 * 奏 * 的 * 琴 * 韵 * 。 * 这 * 一 * 曲 * 时而 * 慷慨 * 激昂 * ， * 时而 * 温柔 * 雅致 * ， * 令狐 * 冲 * 虽 * 不明 * 乐理 * ， * 但 * 觉 * 这位 * 婆婆 * 所 * 奏 * ， * 和 * 曲 * 洋 * 所 * 奏 * 的 * 曲调 * 虽 * 同 * ， * 意趣 * 却 * 大有 * 差别 * 。 * 这 * 婆婆 * 所 * 奏 * 的 * 曲调 * 平和 * 中正 * ， * 令人 * 听 * 着 * 只 * 觉 * 音乐 * 之 * 美 * ， * 却 * 无 * 曲 * 洋 * 所 * 奏 * 热血 * 如 * 沸 * 的 * 激 * 奋 * 。 * 奏 * 了 * 良久 * ， * 琴 * 韵 * 渐 * 缓 * ， * 似乎 * 乐音 * 在 * 不住 * 远 * 去 * ， * 倒像 * 奏 * 琴 * 之 * 人 * 走出 * 了 * 数 * 十 * 丈 * 之 * 遥 * ， * 又 * 走 * 到 * 数 * 里 * 之外 * ， * 细微 * 几 * 不可 * 再 * 闻 * 。 *

理性 * 爱国 *

性爱 * 体验 *

我 * 爱 * 正则 * 表达式 *

轻 * 音乐 *

统计汉字／英文单词数

rex — Sat, 25 Sep 2010 11:25:38 +0000

一个简单的程序，统计文本文档中的单词和汉字数，逆序排列（出现频率高的排在最前面）。python实现。

思路

使用正则式 "(?x) (?: [\w-]+ | [\x80-\xff]{3} )"获得utf-8文档中的英文单词和汉字的列表。

使用dictionary来记录每个单词／汉字出现的频率，如果出现过则＋1，如果没出现则置1。

将dictionary按照value排序，输出。

源码

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
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
#author: rex
#blog: http://iregex.org
#filename counter.py
#created: Mon Sep 20 21:00:52 2010
#desc: convert .py file to html with VIM.

import sys
import re
from operator import itemgetter

def readfile(f):
with file(f,"r") as pFile:
return pFile.read()

def divide(c, regex):
#the regex below is only valid for utf8 coding
return regex.findall(c)

def update_dict(di,li):
for i in li:
if di.has_key(i):
di[i]+=1
else:
di[i]=1
return di

def main():

#receive files from bash
files=sys.argv[1:]

#regex compile only once
regex=re.compile("(?x) (?: [\w-]+ | [\x80-\xff]{3} )")

dict={}

#get all words from files
for f in files:
words=divide(readfile(f), regex)
dict=update_dict(dict, words)

#sort dictionary by value
#dict is now a list.
dict=sorted(dict.items(), key=itemgetter(1), reverse=True)

#output to standard-output
for i in dict:
print i[0], i[1]

if __name__=='__main__':
main()

Tips

由于使用了files=sys.argv[1:] 来接收参数，因此./counter.py file1 file2 ...可以将参数指定的文件的词频累加计算输出。

可以自定义该程序。例如，

使用
1
2
regex=re.compile("(?x) ( [\w-]+ | [\x80-\xff]{3} )")
words=[w for w in regex.split(line) if w]

这样得到的列表是包含分隔符在内的单词列表，方便于以后对全文分词再做操作。

以行为单位处理文件，而不是将整个文件读入内存，在处理大文件时可以节约内存。

可以使用这样的正则表达式先对整个文件预处理一下，去掉可能的html tags: content=re.sub(r"<[^>]+","",content)，这样的结果对于某些文档更精确。

anti spam杂谈

rex — Sun, 15 Aug 2010 02:03:50 +0000

本文是一篇随笔，将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 — Fri, 06 Aug 2010 07:02:46 +0000

昨天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['"])(?:\\['"]|[^'"])*?(?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 05:06:40 +0000

读者“神の呼出”留言询问如何格式化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

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 14:58:54 +0000

关于 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 环境下测试通过。

Python 中文正则笔记

rex — Sun, 27 Jun 2010 03:50:41 +0000

总结在 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 15:04:15 +0000

笔记三则，贴在这里。

首字母大小写无关模式

有一段时间，我在写正则表达式来匹配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 正则替换代码。

由正则式反推文本:REExtractor

rex — Tue, 02 Feb 2010 09:12:35 +0000

发现一款简单有趣的正则表达式应用：REExtractor，作用是输入正则表达式，输出符合正则式描述的文本。作者给的介绍是
Generate all possibilities of Regular Expression，即生成正则表达式的所有可能性。不过，理论上可以做到，执行时却有限制。

一些限制

平台是GAE，语言是python，因此用的是python正则。或需代理才能访问使用。
支持的元字符或缩写：(), [],{m,n},{n},|,\w,\d。如果需要用到这些字符的字面值，请使用反斜线转义之。其中这里的\w等同于[a-zA-Z0-9]，为62个字符之一，而不是通常意义上的包括下划线在内的[_a-zA_Z0-9]，63字符之一。但是可以用[_\w]来代替，没问题的。
不支持的元字符：.(点号),^,$,\b,\D,\W,\1…（后向引用）, (?=…), (?!…), (?<=…), (?等。

如果出现.点号，则直接输出。
如果使用^, $, \b, \1, (?=…), (?!…), (?<=…), (?，程序无视之。

如果使用\D或\b或[^]，则程序会报错。原因是范围太宽。

不支持可能性在1000条以上结果的正则表达式。例如，\w{2}，因为它的可能性是62×62。但是你可以使用\w\d，因为它的可能性是62×10。

它能做什么

好吧，虽然限制多多，但是你仍然可以拿它来做一些有趣的应用。下面略举两例。

生成一些简单的邮箱地址。试一下这条正则式：[abc]{3}\d@1(26|63).com ，它生成540条邮箱地址。
生成一些人名。试一下这条正则式：张[小大勇赞强战海][虎猫龙彪平]。它生成35条人名。是的，它支持中文，并且每个中文字都可以当成一个字符来应用。如果你家要添一个宝宝，可以将一些可能的字排列一下，看看哪些组合比较赏心、顺口，再从中选择一个。

平心而论，上面的这些小应用，当然可以直接编程实现，限制更少，更灵活，更强大。但是有必要每次都开编译器么？尝试一下这款小程序，也挺有趣的。而且，上一节中提及的一些限制，其实也是蛮有道理的。毕竟从正则式反推文本，用不到大多数的零宽断言（不过\1这种反向引用应该挺常用的，却不支持）。当作一个小玩具就好。