依云's Blog

序

swapview 起源于我很早之前看到的一个 shell 脚本。当时正在学习 Haskell，所以就拿 Haskell 给实现了一遍。为了对比，又拿 Python 给实现了一遍。而如今，我又在学习另一门新的语言——Rust，也拿 swapview 来练习了。相比仅仅输出字符串的「Hello World」程序，swapview 无疑更实际一些：

• 文件系统操作：包括列目录、读取文件内容
• 数据解析：包括简单的字符串处理和解析，还有格式化输出
• 数据处理：求和啊排序什么的
• 流程控制：循环啊判断啊分支什么的都有
• 错误处理：要忽略文件读取错误的

因此，swapview 成为了依云版的「Hello World」:-)

感谢所有给 swapview 提交代码的朋友们！

本文只是借 swapview 这个程序，一窥众编程语言的某些特征。很显然，编程语言们各有所长，在不同的任务下会有不同的表现。而且 swapview 各个版本出自不同的人之手，代码质量也会有所差异。

闪耀！那些令人眼前一亮的语言们

从运行效率上来看，C 如预期的一样是最快的。但令人惊讶的是，由我这个 Rust 初学者写的 Rust 程序竟然紧随其后，超越了 C++。

而原以为会跟在 Rust 之后的 C++，却输给了作为脚本语言存在的 Lua 语言的高效实现 LuaJIT（与 Rust 版本相当）。而且非 JIT 版本的 Lua 5.1 和 5.2 也都挺快的。Lua 这语言自带的功能非常少，语法也简单，但是效率确实高，让人又爱又恨的。

失望！那些没预期中的高效的语言们

没想到 Python 2 也挺快的，很接近 Go 了。PyPy 大概是因为启动比较慢的原因而排在了后面。Python 3 有使用两个版本的代码，Python3_bytes 把文件读取改为使用 bytes，仅在需要的时候才解码成 str。仅此之差，运行速度快了10%。可见 Python 的 Unicode 处理十分耗时，难怪 Python 3 在各种测试中都比 Python 2 要慢上一截。至于 PyPy3，怎么跑到那么靠后的地方去了呢……

Go 很快。至少比 Python 快。但也仅此而已了，不仅比 C++ 慢，甚至连 Lua（非 JIT 版）都不如。Go 语言版本虽然不是我写的，但我看过代码，感觉很原始。至少比 Lua 原始。看起来 Go 只不过是带接口和并发支持的 C 而已。而且，作为静态类型的编译型语言，却我却有一种很不放心的感觉。大约是因为我改动时发现传给 fmt.Printf 的参数类型和数目错了都不会得到警告或者错误的原因。而且我从来没见过 Go 编译时出现警告，对于还没入门的初学者写的、改过的程序，这样子不科学啊。早期我倒是见过 Go 报错了，但那只不过是编译器还不完善的表现而已。

传闻 NodeJS 很快。但至少它在 swapview 这种脚本中没能体现出来。正常版本比 Python 3 还要慢一点。而使用异步啊并行什么的版本还要慢上差不多三分之一，不知道怎么搞的。

编译型的 Chicken、OCaml、Haskell 都排在了一众脚本语言后边，虽然很可能是对语言本身不熟导致写出来的程序比较慢，但还是挺令人失望的。经过高手优化的 Haskell2 版本效率接近于 Python 3，但也到此为止了（因为不想使用 cabal 安装依赖，所以 Haskell2 没有参与这场对决）。我曾见过有人把 Haskell 代码优化到比 C 还快，但我宁愿去看汇编也不要去读那种代码……

Lisp 系（Chicken、Racket、SBCL（标注为 CommonLisp 的项）、Guile）也都挺慢的。不知道 LispWorks 之类的会不会快一大截呢。

预料之中的以及结果截图

Ruby 比 Python 略慢一点。

Java、Elixir 比较靠后。没办法，它们启动慢。也许以后我会出不考虑启动时间的版本。

以下是本文发表前的测试结果截图。其中 Erlang 版本因为有问题被信号所杀所以被扔在了最后。

测试使用的是benchmark子目录中的 Rust 程序，使用cargo build --release命令即可构建。另外也可以使用 farseerfc 的 Python 脚本。

代码量

Elixir 代码量挺少的。Python、Ruby 也挺不错。Java 版本竟然跟 Haskell 一样。不管是 JavaScript 还是 CoffeeScript 都比较长，比 Java 还长。Rust 比 Python 长不少，但也比 Go 短不少。而 Go 比起 C、C++ 要短一些。最长的，除了我不了解的 Pascal，竟然还有因为程序出错还没有测试的 Erlang！如果不算按行读取的 line_server.erl 的放大，只有不到一百行，倒还不算多。

                  Elixir:   50
                   Julia:   51
           Python3_bytes:   53
                  Python:   56
                    Ruby:   56
                  Racket:   58
                    Bash:   63
                   OCaml:   65
          CommonLisp_old:   67
          CommonLisp_opt:   67
           Bash_parallel:   69
             C++14_boost:   69
                   Guile:   70
                 Haskell:   73
                 Chicken:   75
                    Java:   75
                  NodeJS:   76
                    Vala:   78
                Haskell2:   81
                       D:   86
                    Rust:   88
                   C++14:   89
                  CSharp:   91
                     Lua:   91
            NodeJS_async:   93
            CoffeeScript:   93
   CoffeeScript_parallel:   95
                     PHP:   97
           Rust_parallel:   98
                      Go:  103
                   C++11:  128
                   C++98:  141
                       C:  149
              FreePascal:  185
                  Erlang:  232

编译速度

这个比较非常粗糙，比如联网下载依赖也被算进去了。不过可以肯定，不算下载依赖部分的话，Rust 是最慢的！其次是 Haskell。标榜编译速度非常快的 Go 并不是最快的，和 C++ 不相上下（当然不知道代码复杂之后会如何了）。

0.36 C
0.60 FreePascal
0.80 OCaml
0.83 CoffeeScript_parallel
1.48 CSharp
1.67 Vala
1.68 Erlang
2.13 NodeJS_async
2.27 C++14
2.49 Go
2.53 CoffeeScript
2.90 C++11
3.01 C++98
3.23 Java
3.52 Racket
3.98 NodeJS
6.05 CommonLisp_opt
7.07 D
9.01 C++14_boost
10.41 Haskell
13.07 Rust
14.74 Chicken
15.37 Rust_parallel

结语

这个项目最初只是练习而已。后来不同语言的版本有点多，于是才演变成众编程语言的竞技。也就随意地测试了一下在给定需求下不同语言的表现而已。其实比较有意思的部分，一是使用正在学习的编程语言写作程序的新奇感、新知、新的领悟（这也是我的测试程序使用 Rust 编写的原因），二是对比不同编程语言的风格和对同样需求的处理方式。

各位读者对 swapview 有任何补充和改进，欢迎贡献代码哦～项目地址：https://github.com/lilydjwg/swapview。

更新区

2015年1月9日更新：又收到了不少版本和改进，以下是最新的测试结果。很不幸地，现在已经跑得很快的 Erlang 在测试中又没反应被杀掉了。并行版的 Rust 的结果很不稳定，这次跑得好快！C++ 的除了 C++98 版的之外都到 Rust 前边去了。PHP 竟然比 LuaJIT 还要快！D 怎么到 PyPy 后边去了。

2015年1月10日更新：C++ 版本继续改进，好多都超越 C 了，Rust 1.0.0alpha 的并列版本又快又稳定，Erlang 版本终于跑完了全部测试而没有出事，LLVM 版 D 快了好多。

2015年1月18日更新：继续更新。又添加了若干语言，不过期待中的 Nim、Zimbu 以及传统脚本语言 Perl、Tcl 依旧缺席中。另外，正文也进行了更新，重新计算了代码量，添加了编译速度的粗略比较。

alembic 这个升级/降级的工具，看上去挺好的，编写好一系列版本脚本之后，能够自动地把数据库给升级或者降级到指定版本。它也使用类似 git 的一串十六进制数来表示各个版本，也支持分支，不过呢，比 git 的易用性差太远了。

我今天有个需求，给一些列添加外键。因为懒得单独新写一些脚本，所以我直接改了相关脚本，手动去数据库执行了 SQL。本以为这样子就好了，后来发现新添加外键所引用的表的创建顺序不对，应该在所有引用到它的表之前创建才对。

可是 alembic 没有 git rebase -i 命令啊，不能简单地调整各种版本的顺序。我尝试着手工编辑了一下，结果弄出来两个 head，一个 branchpoint，但是我就是没能看出来是哪里分叉了……于是想到把各个版本的关系给画出来。这种图 GraphViz 最适合了，而简单地解析 alembic history 的输出，用 awk 就好了：

#!/usr/bin/awk -f

BEGIN {
  print "digraph alembic {";
  shape = "box";
}

/^Rev:/ {
  switch($3) {
    case "(branchpoint)":
      shape = "hexagon";
      break;
    case "(head)":
      shape = "ellipse";
      break;
    default:
      shape = "box";
  }
}

/^Path:/ {
  finding_title = 1;
}

/^    \S/ && finding_title {
  sub(/^\s+|\s+$/, "");
  title = $0;
  finding_title = 0;
}

/^    Revision ID:/ {
  rev = $NF;
}

/^    Revises:/ {
  printf("  r%s -> { r%s };\n", rev, $NF);
  printf("  r%s[label=\"%s: %s\",shape=%s];\n", rev, rev, title, shape);
}

END {
  print "}";
}

head（以及第一个之前的 None 版本）会使用椭圆，分叉点（alembic 说的）会使用六边形，而其它版本是矩形的。这样就可以很方便地看出来是哪里分叉啦：

alembic history | alembic_graph | dot -Txlib

结果发现，我的数据库版本们根本就没有分叉嘛……没办法 revert 回去，把关系图导出 SVG 然后放 Inkscape 里边画边改，总算是把顺序给调整对了=w=

Tcl 的 expect 工具是一个十分有用的自动化工具，经常被用来喂 ssh 密码什么的。不过配置 ssh Control Master^{英文介绍, 中文翻译}之后，我发现第一次连接之后退出，expect 脚本不肯退出了，而且Ctrl-C什么的都不管用，除非我杀掉实际连接到远程主机的 ssh 控制进程。很显然，这是因为 ssh fork 出来的 ssh 进程依旧保持着伪终端的打开状态，expect 依旧在等待来自其上的输出。

研究之后，我发现虽然我可以给我的 expect 脚本加上命令行参数的处理之类的功能，但是interact之后必须等待伪终端关闭没有办法绕过。罢了，本来对 Tcl 就不熟，拿 Python 重写一个吧。

Python 也有个类似的库，叫 pexpect，不过上次我看它的时候还只支持 Python 2，而且使用起来似乎有点问题。所以干脆自制一个满足自己需求的好了。

程序不长，一百多行，但也比预期的长了不少。主要都是些终端和文件描述符的处理。哦还有信号。

我以是否存在子进程来作为判断是否结束interact的标志，而不管是不是还有进程在用这个伪终端。在收到SIGCHLD信号时使用waitid系统调用可以清理任意一已终止的子进程，使用WNOHANG标志在有子进程但是没有已退出者时不要等待、直接返回。于是，在有子进程退出时，反复调用waitid直到它报错就说明已经没有子进程存在啦。

另一个需要处理的信号是SIGWINCH，就是终端大小改变时以此终端为控制终端的前台进程会收到的那个信号。当脚本所在的终端大小改变时，需要重新设置脚本创建的伪终端的大小。不知道为什么，pexpect 竟然没有自己处理这个。

代码照旧在 GitHub 上。以下是使用示例：

#!/usr/bin/env python3

import sys

import expect

def main(host):
  p = expect.Expect()
  p.spawn(['ssh', host])
  p.expect_line('# ')
  p.send('. ./tide\n')
  p.send('TERM=screen-256color exec zsh -l\n')
  p.interact()

if __name__ == '__main__':
  host = 'phone'
  if len(sys.argv) == 2:
    host += sys.argv[1]
  main(host)

这是之前有问题的 expect 脚本：

#!/usr/bin/expect -f

set host [if {$argc eq 0} {lindex phone} {lindex phone$argv}]
spawn -noecho ssh $host
expect "*# "
send ". ./tide\n"
send "TERM=screen-256color exec zsh -l\n"
interact

这是我的 ssh control master 相关配置：

ControlPath ~/.ssh/master-%r@%h:%p
ControlMaster auto
ControlPersist yes

在这里有人给出了自己的解法，但是我不喜，所以有了本文。注意，本文中的 shell 代码均为 zsh。如果你在用 Windows，那建议还是不要玩了，那个对付这种事情太难用了。

可惜知道这个题晚了两天，没能进前X名 :-(

0. Fuck your brain

机器上没有 brainfuck 编译器，于是 Google「brainfuck online」，得到这个。贴进去运行即可。

1. Multiply

一个值是 42。另一个要观察数列。直接把数列贴到数列百科全书即可。然后乘起来。

2. Keyboard

这个也很容易，不是把 Dvorak 键盘当成 Qwerty，那就是把 Qwerty 当成 Dvorak 了。对照着 Dvorak 的键位输入下边那串字符串，得到一 C 源码。编译、运行之即可。

3. QR Code

扫码，得到：

[abcdefghijklmnopqrstuvwxyz] <=> [pvwdgazxubqfsnrhocitlkeymj]

是个字符映射关系。Python 有现成的函数来处理这个。也是有正反两种可能，都试试就可以了。

>>> T = str.maketrans('pvwdgazxubqfsnrhocitlkeymj', 'abcdefghijklmnopqrstuvwxyz')
>>> s = 'Wxgcg txgcg ui p ixgff, txgcg ui p epm. I gyhgwt mrl lig txg ixgff wrsspnd tr irfkg txui hcrvfgs, nre, hfgpig tcm liunz txg crt13 ra "ixgff" t
r gntgc ngyt fgkgf.'
>>> s.translate(T)
'Where there is a shell, there is a way. I expect you use the shell command to solve this problem, now, please try using the rot13 of "shell" to enter next level.'

按照提示执行命令：

rot13 <<< shell

Arch 上，rot13 命令位于 bsd-games 包。或者在 Vim 里把光标移动到「shell」单词上按g?aw也能得到结果。

题目开始有趣起来了～

4. cat

这个题目更有趣了。源码里一堆乱七八糟的数据。先把它们弄到一个单独的 Vim 缓冲区，然后找到所有的五字符回文字符串：

%!grep -oP '(.)(.)(.)\2\1'

不是所有回文都被接受。仔细观察示例可以发现，中间一定是个小写字母，左边一定是一字母一数字。但是过滤后还是有太多结果。限制左边的字母为大写字母之后可以得结果。删掉不符合条件的，然后把中间的字符连起来即可。

v/\v^([A-Z][0-9]|[0-9][A-Z])\l/d

5. variables

初看，提示莫名其妙。后来注意到图片链接到了有意思的地方。访问得到另一个数字「32722」。显然是要用这个数字放在 URL 上继续访问了。直接拿 shell 访问：

$ n=1024
$ while true; do n=$(curl -sS http://fun.coolshell.cn/n/$n); echo $n; done

访问上百次之后出现一句话，给出了下一关的地址。

6. tree

这关要求从一棵二叉树的中序和后序遍历中还原其最深的路径。不知道怎么做，直接 Google「reconstruct a binary tree from in-order and post-order」，看来有不少人都在做类似的东西啊。我看的是 LeetCode 上的这篇文章。有代码，但我懒得写程序把树画出来或者是找最深的了。反正这树也不大，懂得了方法，直接在 dia 里手工构建出来了。当然，我只构建了最深的那部分。SVG 导出图片。

然后就是拿密码解那个字符串了。要注意的是，不要自己去解 base64，不然 openssl 报错的……

7. N Queens

八皇后问题的变种。我直接使用了 Rosetta Code 上的代码。当然要小改一下，直接输出结果而不是打印出图案：

main = mapM_ print $ queens 9

然后找到符合那个 SHA1 值的解就可以了：

$ ./queens | tr -d ',[]' | while read code; do [[ $(sha1sum <<<zWp8LGn01wxJ7$code | awk '{print $1}') == e48d316ed573d3273931e19f9ac9f9e6039a4242 ]] && echo $code; done

8. Excel Column

26 进制转十进制：

>>> def debase26(x):
...   return sum(26 ** i * (ord(d) - ord('A') + 1) for i, d in enumerate(x[::-1]))
...
>>> debase26('COOLSHELL') // base26('SHELL')
85165

结果得到的页面说要转回 26 进制。好吧：（可惜没能在一行内搞定）

>>> def base64(x):
...   L = []
...   while True:
...     x, d = divmod(x, 26)
...     if d == 0: break
...     L.append(d)
...   return ''.join(chr(x + ord('A') - 1) for x in L[::-1])
...
>>> base64(85165)
'DUYO'

9. Fraternal Organisation

这个我没能解出来 QAQ 这两个图片看起来有些莫名其妙。我没注意到图片的名字和鼠标放上去的小提示。最后是看前边那个链接里的答案才知道原来还有个「猪圈密码」-_-|||

PS: 最近博客访问和评论速度都挺慢的，请见谅。

缘起

在一群文件里搜索特定的文本，第一个想到的工具是经典的 grep。自从知道 ag——The silver searcher 之后，我就只在命令行管道里用 grep 啦。

ag 的优势：

• 命令短
• 和 ack 以及 git grep 一样，默认会忽略掉你通常不想看的文本（二进制文件、被版本控制系统忽略掉的文件）
• C 编写的，比 ack 更快！

作者挺在乎程序的执行效率。这也很重要，因为文件多啊，几十上百兆的源码找起来可费时了。

不过在我这里，ag 取代掉的既不是 grep 也不是 ack。因为我之前用的是 cgvg，和 ack 一样也是 Perl 写的，但不一样的是，它包含两个命令：一个（cg）用来搜索，另一个（vg）用来在编辑器里打开！

不知道为什么其它工具的作者都没有想到这一点。匹配的地方找到了，大部分情况都需要用编辑器打开看看，也许再改改吧？cgvg 免去了复制路径到编辑器里并跳转到特定位置这一烦琐的步骤。

所以换用 ag 之后，我自然也希望能够很便利地使用编辑器查看匹配的地方了。为此，我做了三个工具。好吧，其实有一个是在 cgvg 时代就已经有了的。

搜索

实践一下。假设我要寻找 Vim 源码中涉及到p_enc变量的地方。使用 agg 命令来搜索并使用翻页器 less 显示结果（截图时没有显示出 less 的存在）：

agg 脚本更改了 ag 的显示样式，每一项开头都有一个序号，就和 cg 命令一样。同样地，agg 也把这个结果保存在主目录下的一个文件，以供 agv 命令使用。

注意，agg 并不能用来按文件名搜索。这种情况还是用 ag -g pattern。

使用编辑器打开

agv 命令不给定参数，会显示上一次搜索的结果。如果给出一个编号，就会将结果在AGV_EDITOR环境变量指定的编辑器里打开，并跳转到对应的地方。和 vg 不同的是，agg/agv 为每一个终端维护了一个结果列表，这样就可以在不同的终端里搜索不同的内容而不会相互干扰了。

比如我们要去第 14 号结果所在的地方，只要执行agv 14，然后就到了：

我这里是在已有的 gVim 里打开的哦。因为我设置的AGV_EDITOR的值是vv $file:$line:$col。这是一句包含占位符的 shell 命令。$file、$line和$col分别是结果所在的文件、行号、列号。而vv，则是我写的另一个工具，用来在已经打开的 gVim 里打开文件，并且跳转到特定的地方。

vv 需要 Python easygui 库，以及 gVim（或者 Vim）的 +clientserver 支持。vv 不仅支持上述格式的参数，作为一名 Pythonista 所编写的工具，它也支持从 Python 报错时打印的 Traceback 的行中提取文件名和行号。比如：

vv 'File "/usr/lib/python3.4/sre_parse.py", line 358, in _parse_sub'

这里，不一定要复制一整行。包含必要的信息（文件名和行号）就可以了。

当然，手动复制粘贴比较累。所以配合我的 zsh 全局别名：

alias -g XS='"$(xsel)"'

我只需要选中那一行，然后执行

vv XS

就可以了。zsh 会帮我把XS展开成我刚刚选择的文本。

ag.vim

ag.vim 是一个 ack.vim 的修改版，用于在 Vim 中调用 ag，就像 ack.vim 在 Vim 中调用 ack、grep.vim 在 Vim 中调用 grep 一样。

因为经常搜索在当前光标下的内容，我写了这么一条自定义命令：

command Agg exe 'Ag -Q ' . expand('<cword>')

仓库地址

https://github.com/lilydjwg/search-and-view

需要 Python 3.4+，一个参数用来选择测试搜索服务还是 GAE 服务。测试 GAE 服务的话需要先修改开头的两个变量。从标准输入读取 IP 地址或者 IP 段（形如 192.168.0.0/16）列表，每行一个。可用 IP 输出到标准输出。实时测试结果输出到标准错误。50 线程并发。

#!/usr/bin/env python3

import sys
from ipaddress import IPv4Network
import http.client as client
from concurrent.futures import ThreadPoolExecutor
import argparse
import ssl
import socket

# 先按自己的情况修改以下几行
APP_ID = 'your_id_here'
APP_PATH = '/fetch.py'

context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
context.verify_mode = ssl.CERT_REQUIRED
context.load_verify_locations('/etc/ssl/certs/ca-certificates.crt')

class HTTPSConnection(client.HTTPSConnection):
  def __init__(self, *args, hostname=None, **kwargs):
    self._hostname = hostname
    super().__init__(*args, **kwargs)

  def connect(self):
    super(client.HTTPSConnection, self).connect()

    if self._tunnel_host:
      server_hostname = self._tunnel_host
    else:
      server_hostname = self._hostname or self.host
      sni_hostname = server_hostname if ssl.HAS_SNI else None

    self.sock = self._context.wrap_socket(self.sock,
                                          server_hostname=sni_hostname)
    if not self._context.check_hostname and self._check_hostname:
      try:
        ssl.match_hostname(self.sock.getpeercert(), server_hostname)
      except Exception:
        self.sock.shutdown(socket.SHUT_RDWR)
        self.sock.close()
        raise

def check_ip_p(ip, func):
  if func(ip):
    print(ip, flush=True)

def check_for_gae(ip):
  return _check(APP_ID + '.appspot.com', APP_PATH, ip)

def check_for_search(ip):
  return _check('www.google.com', '/', ip)

def _check(host, path, ip):
  for chance in range(1,-1,-1):
    try:
      conn = HTTPSConnection(
        ip, timeout = 5,
        context = context,
        hostname = host,
      )
      conn.request('GET', path, headers = {
        'Host': host,
      })
      response = conn.getresponse()
      if response.status < 400:
        print('GOOD:', ip, file=sys.stderr)
      else:
        raise Exception('HTTP Error %s %s' % (
          response.status, response.reason))
      return True
    except KeyboardInterrupt:
      raise
    except Exception as e:
      if isinstance(e, ssl.CertificateError):
        print('WARN: %s is not Google\'s!' % ip, file=sys.stderr)
        chance = 0
      if chance == 0:
        print('BAD :', ip, e, file=sys.stderr)
        return False
      else:
        print('RE  :', ip, e, file=sys.stderr)

def main():
  parser = argparse.ArgumentParser(description='Check Google IPs')
  parser.add_argument('service', choices=['search', 'gae'],
                      help='service to check')
  args = parser.parse_args()
  func = globals()['check_for_' + args.service]

  count = 0
  with ThreadPoolExecutor(max_workers=50) as executor:
    for l in sys.stdin:
      l = l.strip()
      if '/' in l:
        for ip in IPv4Network(l).hosts():
          executor.submit(check_ip_p, str(ip), func)
          count += 1
      else:
        executor.submit(check_ip_p, l, func)
        count += 1
  print('%d IP checked.' % count)

if __name__ == '__main__':
  main()

脚本下载地址。

2014年9月3日重要更新：由于失误，之前的脚本没有检查 SSL/TLS 证书，所以将错误的 IP 认为是可用的。现已更新。

听说 Ruby 支持分数字面量呢——

irb(main):001:0> 1/3r
=> (1/3)
irb(main):002:0> 1/3r+1/2r
=> (5/6)

可是在 Python 里只能这样子：

>>> from fractions import Fraction as R
>>> R(1, 3)
Fraction(1, 3)
>>> R(1, 3) + R(1, 2)
Fraction(5, 6)

学习《用 `accio` 代替 `import`：深入理解自举和 Python 语法》改改 Python 解释器，让它也支持分数字面量，应该会很有趣呢 =w=

去翻了一下 Grammar/Grammar 文件，有些失望。那里只有语法定义，没有词法定义呢。以为词法定义在另一个地方，所以找了找，无果。只有 C 代码。想到复数的 j 字尾，直接拿 ag 搜带引号的 "j" 和 'j'，最终确认它在 Parser/tokenizer.c 里。也就是说，Python 的词法分析是自己实现的。

在那个四千多行的tok_get函数里，有一部分代码在尝试解析一个数，也就是语法里的 NUMBER。照着解析复数的办法，把 d 后缀和 r 后缀也加进去：

diff -r bf65e7db066d Parser/tokenizer.c
--- a/Parser/tokenizer.c    Mon Apr 14 22:27:27 2014 -0400
+++ b/Parser/tokenizer.c    Fri May 30 20:12:07 2014 +0800
@@ -1528,6 +1528,10 @@
                 goto fraction;
             if (c == 'j' || c == 'J')
                 goto imaginary;
+            if (c == 'd' || c == 'D')
+                goto decimal;
+            if (c == 'r' || c == 'R')
+                goto rational;
             if (c == 'x' || c == 'X') {

                 /* Hex */
@@ -1621,6 +1625,12 @@
                     /* Imaginary part */
         imaginary:
                     c = tok_nextc(tok);
+                else if (c == 'd' || c == 'D')
+        decimal:
+                    c = tok_nextc(tok);
+                else if (c == 'r' || c == 'R')
+        rational:
+                    c = tok_nextc(tok);
             }
         }
         tok_backup(tok, c);

d 后缀是我给十进制数——就是会计里会用到的精确的十进制小数——准备的。

然后可以编译出来试试。这个 configure 命令是从 Arch 官方编译脚本里找的。

./configure --enable-shared --with-threads --with-computed-gotos --enable-ipv6 --with-valgrind --with-system-expat --with-dbmliborder=gdbm:ndbm --with-system-ffi --with-system-libmpdec --without-ensurepip
make

因为我不执行安装步骤，而又用了共享库，所以要这样子执行：

LD_LIBRARY_PATH=. ./python

试试看：

>>> 4d
ValueError: could not convert string to float: 4d

有效果，不报语法错了呢。

现在报ValueError，因为我还没告诉 Python 如何解析我新加的字面量表示呢。解析代码位于Python/ast.c的parsenumber函数。最终的补丁如下：

diff -r bf65e7db066d Python/ast.c
--- a/Python/ast.c  Mon Apr 14 22:27:27 2014 -0400
+++ b/Python/ast.c  Fri May 30 20:12:07 2014 +0800
@@ -3650,12 +3650,29 @@
     long x;
     double dx;
     Py_complex compl;
-    int imflag;
+    char typeflag;
+    PyObject *mod, *type, *ret;

     assert(s != NULL);
     errno = 0;
     end = s + strlen(s) - 1;
-    imflag = *end == 'j' || *end == 'J';
+    switch(*end){
+        case 'j':
+        case 'J':
+            typeflag = 'j';
+            break;
+        case 'd':
+        case 'D':
+            typeflag = 'd';
+            break;
+        case 'r':
+        case 'R':
+            typeflag = 'r';
+            break;
+        default:
+            typeflag = 'i';
+    }
+
     if (s[0] == '0') {
         x = (long) PyOS_strtoul(s, (char **)&end, 0);
         if (x < 0 && errno == 0) {
@@ -3670,13 +3687,43 @@
         return PyLong_FromLong(x);
     }
     /* XXX Huge floats may silently fail */
-    if (imflag) {
+    if (typeflag == 'j') {
         compl.real = 0.;
         compl.imag = PyOS_string_to_double(s, (char **)&end, NULL);
         if (compl.imag == -1.0 && PyErr_Occurred())
             return NULL;
         return PyComplex_FromCComplex(compl);
     }
+    else if (typeflag == 'd') {
+      mod = PyImport_ImportModule("decimal");
+      if (mod == NULL)
+          return NULL;
+
+      type = PyObject_GetAttrString(mod, "Decimal");
+      if (type == NULL) {
+          Py_DECREF(mod);
+          return NULL;
+      }
+      ret = PyObject_CallFunction(type, "s#", s, strlen(s)-1);
+      Py_DECREF(type);
+      Py_DECREF(mod);
+      return ret;
+    }
+    else if (typeflag == 'r') {
+      mod = PyImport_ImportModule("fractions");
+      if (mod == NULL)
+          return NULL;
+
+      type = PyObject_GetAttrString(mod, "Fraction");
+      if (type == NULL) {
+          Py_DECREF(mod);
+          return NULL;
+      }
+      ret = PyObject_CallFunction(type, "s#", s, strlen(s)-1);
+      Py_DECREF(type);
+      Py_DECREF(mod);
+      return ret;
+    }
     else
     {
         dx = PyOS_string_to_double(s, NULL, NULL);

因为只是玩玩，所以不太认真，没仔细做错误处理；因为decimal和fractions模块是从外部文件导入的，所以可能被覆盖掉，从而导致报错，并且这错误是无法通过异常处理捕获的。

不出问题的话，再次make之后，就可以开始玩了。不过在此之前，再多做几个补丁，让 Python 把分数和十进制数显示得简洁好看一点：

diff -r bf65e7db066d Lib/decimal.py
--- a/Lib/decimal.py    Mon Apr 14 22:27:27 2014 -0400
+++ b/Lib/decimal.py    Fri May 30 20:12:07 2014 +0800
@@ -1015,7 +1015,7 @@
     def __repr__(self):
         """Represents the number as an instance of Decimal."""
         # Invariant:  eval(repr(d)) == d
-        return "Decimal('%s')" % str(self)
+        return str(self) + 'd'

     def __str__(self, eng=False, context=None):
         """Return string representation of the number in scientific notation.
diff -r bf65e7db066d Lib/fractions.py
--- a/Lib/fractions.py  Mon Apr 14 22:27:27 2014 -0400
+++ b/Lib/fractions.py  Fri May 30 20:12:07 2014 +0800
@@ -280,7 +280,7 @@

     def __repr__(self):
         """repr(self)"""
-        return ('Fraction(%s, %s)' % (self._numerator, self._denominator))
+        return str(self) + 'r'

     def __str__(self):
         """str(self)"""
diff -r bf65e7db066d Modules/_decimal/_decimal.c
--- a/Modules/_decimal/_decimal.c   Mon Apr 14 22:27:27 2014 -0400
+++ b/Modules/_decimal/_decimal.c   Fri May 30 20:12:07 2014 +0800
@@ -3092,18 +3092,10 @@
 static PyObject *
 dec_repr(PyObject *dec)
 {
-    PyObject *res, *context;
-    char *cp;
-
-    CURRENT_CONTEXT(context);
-    cp = mpd_to_sci(MPD(dec), CtxCaps(context));
-    if (cp == NULL) {
-        PyErr_NoMemory();
-        return NULL;
-    }
-
-    res = PyUnicode_FromFormat("Decimal('%s')", cp);
-    mpd_free(cp);
+    PyObject *res, *str;
+    str = dec_str(dec);
+    res = PyUnicode_FromFormat("%Ud", str);
+    Py_DECREF(str);
     return res;
 }

下面是最终成果啦：

>>> 0.1 + 0.2 == 0.3
False
>>> 0.1d + 0.2d == 0.3d
True
>>> 1/3r + 1/2r
5/6r
>>> 0.4/1.2r
0.33333333333333337
>>> 0.4r/1.2r
1/3r

可以看到，与复数类似，分数字面量其实包含了一次除法。所以如果分子写浮点数的话，最终结果是会被转成浮点数的呢。这个和 Ruby 的行为是一样的 =w=

这东西挺好用的，可惜我只寻到一多年以前的 Python 2 版本的，作者是 AutumnCat，不认识。但注释里提到的修改者 bones7456 是鼎鼎大名的骨头兄，现其博客已经长草……

一直以来，我都是通过子进程调用来使用的，因为我写的代码是 Python 3 版，比如这个寻找文本里的 IP 地址并标记的 ipmarkup 脚本。配合 Python 3.2 加入的 functools.lru_cache，效率还不错的样子。但近期有大量 IP 需要查询，才感到每个 IP 都开个子进程的方式实在太慢。遂将其修改为 Python 3 版，并加入了些 Python 后来才流行的 idiom。

脚本还是扔到 winterpy 仓库里了。GPLv2 授权的。

2014年8月2日更新：增加了在线更新的功能，从此不需要 Wine 就能更新数据库啦 :-) 更新方法来自微菜。更新命令如下：

python3 -m QQWry update

子类里访问父类的同名属性，而又不想直接引用父类的名字，因为说不定什么时候会去修改它，所以数据还是只保留一份的好。其实呢，还有更好的理由不去直接引用父类的名字，参见 Python’s super() considered super! | Deep Thoughts by Raymond Hettinger。

这时候就该 super() 登场啦——

class A:
  def m(self):
    print('A')

class B(A):
  def m(self):
    print('B')
    super().m()

B().m()

当然 Python 2 里 super() 是一定要参数的，所以得这么写：

class B(A):
  def m(self):
    print('B')
    super(B, self).m()

需要提到自己的名字。这个名字也是动态查找的，在这种情况下替换第三方库中的类会出问题。

super() 很好地解决了访问父类中的方法的问题。那么，如果要访问父类的父类（准确地说，是方法解析顺序（MRO）中位于第三的类）的属性呢？

比如，B 类是继承 A 的，它重写了 A 的 m 方法。现在我们需要一个 C 类，它需要 B 类的一些方法，但是不要 B 的 m 方法，而改用 A 的。怎么间接地引用到 A 的 m 方法呢？使用self.__class__肯定是不行的，因为 C 还可能被进一步继承。

从文档中我注意到，super 的实现是通过插入一个名为 __class__ 的名字来实现的（super 会从调用栈里去查找这个 __class__ 名字）。所以，就像文档里暗示的，其实可以直接在定义方法时访问 __class__ 名字，它总是该方法被定义的类。继续我们的单字母类：

class C(B):
  def m(self):
    print('C')
    # see the difference!
    print(__class__.__mro__)
    print(self.__class__.__mro__)
    __class__.__mro__[2].m(self)

class D(C):
  def m(self):
    print('D')
    super().m()

o = D()
o.m()

会得到：

D
C
(<class 't.C'>, <class 't.B'>, <class 't.A'>, <class 'object'>)
(<class 't.D'>, <class 't.C'>, <class 't.B'>, <class 't.A'>, <class 'object'>)
A

不过，PyPy 并不支持这个 __class__ 名字。

代码很简单，功能也很简单 =w=

#!/usr/bin/env python3

import sys

try:
  from PyQt4 import QtWebKit
  from PyQt4.QtCore import QUrl
  from PyQt4.QtGui import QApplication, QPrinter
except ImportError:
  from PySide import QtWebKit
  from PySide.QtCore import QUrl
  from PySide.QtGui import QApplication, QPrinter

app = QApplication(sys.argv)

def done(status):
  p = QPrinter()
  p.setOutputFormat(QPrinter.PdfFormat)
  p.setOutputFileName('a.pdf')
  view.print(p)
  app.exit()

view = QtWebKit.QWebView()
view.load(QUrl('http://lilydjwg.is-programmer.com/'))
view.loadFinished[bool].connect(done)
# PySide does not have QApplication.exec
app.exec_()

注意：虽然没有图形界面，但是还是需要 X 连接……