世界 Python 爱好者的顶级盛会 —— PyCon 大会将首次在中国举办！本次大会由（Python 软件基金会下的）PyCon.Org 正式授权 GTUG、TopGeek、CPyUG 等社区联合举办，由 Python 作者 Guido van Rossum 及其所在的 Google 公司提供关键支持。

本次大会云集了国内外最为杰出的 Python 开发者，国内 Python 领域的领军人物几乎悉数到场、作为 Python 重镇的各大知名公司几乎无一缺席，所有嘉宾都承诺将自己压箱底的 Python 绝活呈现给大家！我也会在大会上进行题为《Python，通向未来之路》的纯技术演讲，欢迎捧场。

会议为期两天（12 月 3 日至 4 日），票价 60￥，全部用于会议期间的就餐费用，其余大会所有费用及礼品主要由 Google 等公司承担赞助。作为国内最大的赞助者之一，我们也同样很荣幸能够服务于广大中国 Python 爱好者。

 

境界零：混沌态、浆糊状（小白、新兵）

刚刚毕业、初出茅庐，有丰富把妹经验，无任何项目经验。

典型台词：“哇塞，薯熟你居然能写出这样这样酷的程序啊”。

此时身为薯熟的你切不可信以为真，因为任何简单的程序对他们来说 ……

                 其实都是写不出来的。

技能：hello world!

经验：0 年

角色：新手村游荡者（虽然 ID 很酷，但改变不了时常被怪虐的事实）

境界一：CODE SMELL（IT 民工）

对于一些不太残忍的需求，竟已经能够完成了！了不起。

技能：面向对象、无脑肉搏

经验：1 年

角色：肉盾、坦克、血牛

公司终于可以放心地把一些 “没那么关键” 的项目扔给他了。

但遗憾的是，公司绝大部分的编码工作其实都 “没那么关键”。 这很容易理解，因为 “管理层“ 是不写代码的，高手则忙着折腾那几行关键代码。

                 兄弟！剩下的就全靠你啦。

在这个配合良好的团队中，身处一线承担 90% 的炮火，此时他们最需要的技能是 “吸引攻击” ……

“你每天编几个小时程序？能不能承受得起？”

“每天 77 小时，承受得起。”

                 —— 大家都露出了 YD 的笑容。

典型台词：“面向过程什么的最讨厌了”。

其他常用语：“瀑布模型什么的最讨厌了”。

高手很快从他们这些代码中闻到了坏味道，至于是 “不够面向” 或者 “不够工程” 导致的， 还是他们根本就没空清理代码，这是一个迷。

当然说句公道话，我们知道程序上线后能死撑多久，是和味道无关的。

赶时间随便凑起来的代码基本是稳定的，被自己恶心到于是下决心认真经营的那些代码一般会随机崩溃。

                 显然这只和人品相关。

境界二：SUCKS（TEAM LEADER、架构师、高手）

对于一些不太残忍的需求，竟已经能够华丽丽地完成了！了不起。

对仍在 “新手村论坛” 上转悠的那些童鞋们，你简直就是神一样的存在。 别犹豫了，不是新手的坏家伙毕竟是少数，你的确就是神一样的存在。

“虽然我那几千行没有一行是实际做事情的，但是，架构很重要” 你说道，“你懂的”。

次日 ……

“虽然我那几千行是面向复用和好味道设计的，但是，重构很重要” 你说道，“所以我重写了”。

技能：设计模式、软件工程、ppt

经验：2 年

角色：TEAM LEADER

典型台词：“我们的目标是，木有一行重复代码”。

正如预想的那样，很不幸，战斗顺利演变为缠绵悱侧的恶斗。 大伙抬起头遥望天边如血的残阳，麻的，又要甲板。

是的，项目延期，再次地。

大家已经数不清曾经已经延期了多少项目。 但好像，项目保质保量按时完成的情况，就如同新闻联播中的传说，似乎从来没有出现过。

似乎 LEADER 再次给出了乐观得不行的预期，虽然工期是三个月，但是我们都知道没有三年是搞不掂这事的 —— 但更迫在眉睫的是公司会在三年内上市（虽然公司今年夏天才开张）。

如果不够乐观，这种不给力的感觉，届时老板会毫不犹豫地把这个部门裁掉，然后找一堆更便宜，并且更加乐观得不行的家伙把你们替换掉。

要知道网上无所不能，并且对现实工资非常不满的程序员遍地都是。面对这个残酷的现实，你必须乐观起来才行！

……

经过数年的延期，终于赶在公司上市前把项目搞定了，谢天谢地。 在万分危急的最后一刻，LEADER 再次 “重构” 了整个系统，团队终于逃出生天。

然而在一个阴暗的角落，是主程冷峻的目光，注视着高手们的代码。

“SUCKS！” 从他的牙缝中迸出几个字，轻蔑在他的嘴角蔓延。

境界三：MAGIC（主程）

技能：精通各种 MAGIC 和 HACK

经验：3 年

角色：法师

典型台词：“IE 的这个 BUG 只要用 IE 另外的一个 BUG 就可以解决了”。

你曾经不小心看到了主程的源码，这个文件充斥着大量注释为（也是唯一的一种注释）“HACK” 的代码，剩下的则全都是 MAGIC。 从此你就很后悔因为好奇打开了这个文件。

后来主程去了纳尼亚，你的朋友小明就奉命继续维护他的代码，这从一开始就是一个错误，其中一个 BUG 花了他将近两年的时间 —— 仍然没有搞定。 所以后来小明也去了纳尼亚。

幸运的是你接手了小明的工作，你试图说服公司，与其在主程的程序里调试，重新实现一遍要快得多。

公司冷酷的答复是，不行。这是公司宝贵的精神财富，是照耀所有员工不断前进的动力。 况且这些代码还 HARDCODE 了各种 8086 指令，来加速最新的 ARM，这让我们的竞争对手不寒而栗。

心灰意冷的你于是决定看破红尘，但是无名禅师的一番话让你幡然醒悟。于是你回到公司按主程的程序原样抄写了一遍

                 —— BUG 消失了。

境界四：迷

技能：UNKNOW

经验：UNKNOW

角色：UNKNOW

传说在每一个挨踢公司里都有一个扫地大妈，会在某天经过你的身边，扫一眼代码淡淡地说 “小心，栈溢出了”……

无意中翻到了 06 年时笔记本的桌面，那时博客的副标题还是很给力的。留念下。

今天，你得道了吗？得道更健康 。。。

PS. 那时网易博客左上角还有 163 徽标，他们现在应该是想通了，与其被 crack 掉还不如自宫 

关于 cpython 线程能否充分用到 cpu 多核，相信很多人都做过这个测试。每个线程都起一个空循环，如果能把 cpu 多核全部占满，则说明已经用到多核。

这个实验很久以前做过，结果当然是只有一个 cpu 核心 100% 满载，其他核心无负荷。关于这个问题，似乎早有定论，由于 GIL 的存在 python 多线程是无法充分使用多核的。

最近又就此做了下测试，忽然发现机器上的双核都用完了。而且在 cpython2.5.5、cpython2.6.4、cpython2.7、unladen swallow q3、pypy-jit1.3 上普遍如此。

AMD Athlon(tm) Dual Core Processor 5000B
#37-Ubuntu SMP Fri Jun 11 08:03:28 UTC 2010

关于这件事，我在 python-cn 论坛上发了个贴。不多时，zoomq 说的洗具发生了，在其他机器上也得到了相同的结果。

由 Zoom Quiet 提交
Intel(R) Core(TM)2 Duo CPU P8600 @ 2.40GHz
ubuntu 10.04 i686

由 GKermit 提交
i5 430M 2.26Hz, 1066 MHz FSB
ubuntu 10.04

这意味着至少在一些情况下 python 线程是可以使用多核的。

最新测试结果表明，这是幻觉来的 。。。

在这种简单情况下，只能用到单核。并且单线程完成的循环数要高于多线程的总循环数，性能更好。

幻觉，一切都是幻觉。空循环只是个特例，大家洗洗睡吧 ……

其实这篇文章应该叫 “在 64位 linux 上使用 32位程序”。事实上在开源世界，代码都是可以跨平台编译的，这种愿望并不很强烈。而 pypy-jit 是一个例外。

这里提供一种在 64位平台上运行 pypy-jit 的思路。chroot 是一种比较简单的方法，不太熟悉 chroot 的朋友可以按照这篇文章进行部署。

首先使用 debootstrap 建立 ia32 root。这里使用了 163 lucid 的仓库。

这需要一定时间。然后复制一些需要的文件到 ia32 root，这里也复制了一些用户文件，这样你就可以在 32位系统上使用当前主机上的帐号了。

在 32 位系统上挂接一些需要的目录，然后 chroot 到 32位系统，进行更新。

你现在已经以 root 身份进入了 32位系统，安装 pypy 需要的 libexpat1 包。然后下载一个 pypy-jit 的预编译包放到 opt 目录下。

现在退出 32位系统。

为方便在 64位主机上直接调用这个 32位的 pypy-jit 程序下面进行一些配置。

编辑 schroot.conf 的内容如下。

建立 32位 pypy-jit 的 “快捷方式”。

编辑文件内容如下。

尝试执行 pypy-jit 。

种种迹象表明 pypy 很快将获得进入生产领域的足够能力，对常规公司而言确实如此。而很多充满信心的技术人员则在生产环境中使用 pypy 这一族技术已经很久了。我相信 pypy-jit 登陆 64位平台已可预期，在不远的将来。而在此之前，即便是 64位的服务器，我们也已经迫不及待地准备在项目中尝试 pypy-jit 了。

参考资料 Ubuntu AMD64 Howto

在这里 http://code.google.com/p/winevil/

脚本是 python 的，带有星际2 补丁。

前段时间和朋友提到 javascript，可惜没有 foreach。朋友当时便有点诧异。我补充说 for…in 其实还是有的，只是不可预期而已。

使用 for…in 遍历数组的方法。

目前一切都还正常。但试着加上一行代码，就会有变化。

看上去给 array 加上一个 xxx 明显是一件极其 silly 的事情。但是想一下很久之前 IE 中的 array 是没有 push 方法的，那时我们经常会用这种方法给 IE 加上 push。

这样看来顺理成章，for…in 不能用了。

如果再考虑到低版本的 IE 不支持 push，早期 “安全” 的 javascript 就会像这个样子。

没有经历过那个时代的朋友乍一看到，不禁会问，这，这是什么情况？

—— 这确实是太糟糕了。

异曲同工之妙，string 也是可以 for…in 遍历的。

杯具的是，给 string 加 strip 之类的方法也是很常见的。这样才是最 “面向对象” 的扩展方式，不是吗？

当然最抱歉的写法应该是 “ Object.prototype.xxx = XXX ” 了。

使用 javascript 小心 IE。这个大家都清楚，自不必多说。如果 javascript 中引用了第三方代码，或会被别人用到，for…in 最好不用。prototype 也尽量少用。

我以前说过，对于成熟的 library / framework 开发者来说，接口过多和接口太少，其实就是一码事。

特性越多，功能越少，“ for…in vs prototype ” 这是一个典型例子。

安装

使用健康的 DNS

接触 vi 也有十多年了。这里也试着聊下 vi 编辑器快速上手的方法，对刚开始准备使用 vi 的朋友可能会有点帮助，高手就不用看了。

方法很简单，去用，就很快会了。当然 vi 的操作确实比较繁多，不知怎么下手。我这里提炼出一些常用的，一丁点内容，保守用两天来熟悉。不用怀疑，对于所有编辑任务确实已经够用了。既然这样，读完后，马上就开始用，去用，就很快会了。

vi 主要是两种模式，按 Esc 键进入指令模式（常见有人会狂按 Esc 直至电脑喇叭发出哔哔声以确认进入指令模式），按 i 键（insert）进入输入模式（可以输入东西编辑文件了）。

开始时默认进入的是指令模式：

用 h（左）j（上）k（下）l（右）移动光标。Ctrl+f 向下翻页，Ctrl+b 向上翻页。

i 键插入当前光标位置，或 a 键在光标后插入。同时进入输入模式，进行编辑，按 Esc 键再返回命令模式。

x 删除当前字符，dd（按两次 d）删除（剪切）当前行。

u（undo）撤销。

保存文件：

在指令模式中（最不用动脑筋的办法是乱按一通 Esc 可以保证从编辑模式进入指令模式）按“:”键（冒号）可以进入 vi 的末行模式，退出末行模式回到命令模式只要按退格键删除“:”字符即可。

输入 :wq（回车）即是保存退出。:w 保存不退出。:q! 退出不保存。

以上内容，花一天熟悉。浏览文件，做点简单编辑已经足够了。注意不要用小键盘，比如上下左右这些，否则就很难学会 vi 了。在 vi 里手不会离开大键盘，用不了多久这些指令就会条件反射，编辑效率比较高。

下面是相对不太常用的：

o 在当前行后插入一行，O 在当前行前插入一行。和 i、a 一样，同时进入输入模式。

数字键 0 跳到行首，$ 跳到行尾。

Shift+j 将当前行和下一行合并成一行。

Ndd 剪切 N 行（N 是一个数字）。

yy 复制当前行。Nyy 复制 N（N 是一个数字）行。按 p 键粘贴。

:N 跳到第 N 行。直接打 N 跳到当前行后的第 N 行。N 可以是负数。

在命令模式下输入 /word（回车）来在文件中搜索字符 word。按 n（next）跳到下一个搜索到的字符。

使用“:s/被替换字符/替换字符/g”这行命令来进行搜索替换。比如“:s/^M//g”是把 windows 文件的行尾 ^M 删除掉。其中“^M”的输入方法是按住 Ctrl+v，然后保持 Ctrl 并放掉 v 键，再按 M。

这就开始使用 vi 吧。

主题无关，这里聊些其他的。其实很多貌似常用的指令我都没有写，比如 X 删除，sS 替换等等，我觉得刚开始用记那么多负担太重。况且 s 我经常用打个 x 再打个 i 效果一样。

记这么点东西我觉得够了。用熟练了，再找资料学更多方便编辑的命令和配置方法。一口气吃不成胖子。我自己比较特别，用 vi 写代码是不用自动补齐和自动缩进的。拿自动缩进来说，不喜欢在文件里有我不知道的空格悬挂在那里。也不显示行号，甚至不用代码着色。这样代码稍微冗长一点，稍微混乱一点，读起来麻烦，视觉上马上就警惕了。帮助我避免写出烂代码（当然也有会觉得程序越长越复杂越牛逼的，人都有不同，各取所好吧）。所以 ssh 到其他管理员配置的服务器上，我有时会把那些对我没用，看着麻烦的配置都还原掉。因为对我来说没那么多复杂的东西，可视模式啊，分屏什么的，基本没用，所以也没写。文中的东西够我所有日常应用了，理论上，对我来说不需要 vim，给个 vi 就够了。

vi 是神器，即便 emacs 或者其他玩家，简单了解下也是要的。less 命令或者看 man 手册，甚至 python 的 help() 函数用的到处都是 vi 指令。

另外，遇到 vi 编辑中非正常退出的文件（被锁），ls -a 一下把 .swp 文件删了就可以了。差点忘了，编辑系统文件用 sudo vi，除非在 /root 下生成一堆 X 配置文件你觉得无所谓，那么用 gedit 之类的 gui 编辑器也无所谓。

正和朋友讲解 WSGI 。打了一大段没发出去 QQ 就崩溃了 (没打补丁)。我想对准备接触 WSGI 的初学者朋友都有会点用, 就记在这里吧。

WSGI 主要是读一下 PEP333 。其实把里面两段示范代码看了就明白了。我读了下示范代码和环境变量的要求, 就写了 (eurasia) WSGI server 事情就这么简单。

一个比较容易产生疑惑的地方是, 可能会把 (1) WSGI server 和 (2) 基于 WSGI 的 framework 混淆了。其实 WSGI 是分成 server 和 framework (即 application) 两部分 (当然还有 middleware)。严格说 WSGI 只是一个协议, 规范 server 和 framework 之间连接的接口。

(1) WSGI server 把服务器功能以 WSGI 接口暴露出来。比如 mod_wsgi 是一种 server, 把 apache 的功能以 WSGI 接口的形式提供出来。

(2) WSGI framework 就是我们经常提到的 Django 这种框架。不过需要注意的是, 很少有单纯的 WSGI framework , 基于 WSGI 的框架往往都自带 WSGI server。比如 Django、CherryPy 都自带 WSGI server 主要是测试用途, 发布时则使用生产环境的 WSGI server。而有些 WSGI 下的框架比如 pylons、bfg 等, 自己不实现 WSGI server。使用 paste 作为 WSGI server。

Paste 是流行的 WSGI server, 带有很多中间件。还有 flup 也是一个提供中间件的库。

搞清除 WSGI server 和 application, 中间件自然就清楚了。除了 session、cache 之类的应用, 前段时间看到一个 bfg 下的中间件专门用于给网站换肤的 (skin) 。中间件可以想到的用法还很多。

这里再补充一下, 像 django 这样的框架如何以 fastcgi 的方式跑在 apache 上的。这要用到 flup.fcgi 或者 fastcgi.py (eurasia 中也设计了一个 fastcgi.py 的实现) 这些工具, 它们就是把 fastcgi 协议转换成 WSGI 接口 (把 fastcgi 变成一个 WSGI server) 供框架接入。整个架构是这样的: django -> fcgi2wsgiserver -> mod_fcgi -> apache 。

虽然我不是 WSGI 的粉丝, 但是不可否认 WSGI 对 python web 的意义重大。有意自己设计 web 框架, 又不想做 socket 层和 http 报文解析的同学, 可以从 WSGI 开始设计自己的框架。在 python 圈子里有个共识, 自己随手搞个 web 框架跟喝口水一样自然, 非常方便。或许每个 python 玩家都会经历一个倒腾框架的阶段吧。

二千年传承的古武术秘密 (一)

在火器时代之前, 中国是天下第一步战强国。动则数十万人的战争中, 能活下来的人所凭借的东西到底是什么?
我研究在世上活命之道二十年, 不敢在擂台上说能打赢泰森, 小光头, 格雷西, 但是自有自己独到之处。如今就完全免费地和各位分享一下。

本文会分析中国几大传统拳种的源流。看看它们的来历和用途。将分为如下几个章节 [1]。

1. 战场之拳
2. 义士之拳
3. 暗杀之拳
4. 飞贼之拳
5. 擂台之拳

战场之拳

中国古代战争的特点就是人多, 多到什么地步呢? 我打个比喻, 一个足球场大概可以容纳5万人在那里密密麻麻地站着。一场较大规模的战争, 大概就是好几个足球场的人密密麻麻地挤在一起。这么多人挤在一起, 面临的最大危险是什么?

答案是个废话, 就是被踩死。五万人中只要有1000人突然发了神经乱走路。至少一瞬间就能踩死2000人。踩残废的则不计其数。什么泰森小光头遇到这 1000个发神经乱走路的人, 可能可以一阵摆拳打倒四五个, 但最后也只有死路一条。死得最快的是什么人? 是格雷西家族的人, 这个家族的人有个坏习惯, 就是一打架就往地上趴。只见一阵大脚丫过后, 顿时退货。
如果这发了神经乱走路的1000人, 不是一般人, 是骑着马拿着长矛的, 死的人就更多了。什么? 发了神经的不止1000人, 是另外50000个骑马拿长矛的人?!?!

所以各位喜欢看穿越小说的兄弟们, 千万不要以为自己练了点什么无限制啊, k1啊, 跑到古代就能吃香。真过去的话吃的估计都是烧的香。
在战场之中, 对武功的第一要求是

1. 重心低+平衡感 (马步稳) , 否则一滑倒则万事休矣
2. 保护要害。挨一刀一枪则省下娶老婆生孩子的费用了。

这里说的保护要害, 可千万不要以为是像拳击手一样两手护着太阳穴和下巴。在战场上你摆这个姿势就是找死。
首先分析你是个什么兵种, 你是长枪兵 (排在最前面送死的就是你这个兵种) 就摆个形意拳的三体式。前手防咽喉和胸, 后手防腹+下阴, 两手抓一支长枪, 用趟泥步前进。形意拳号称是岳飞传下来的武功。岳飞用的肯定不是什么泰拳黑市拳。动脑想想就明白了。

你是刀盾兵 (好不到哪里, 也是个送死的兵种啊! ) 就一手在前持盾, 一手在后持刀。摆个太极拳的白鹤亮翅的姿势。谁要是摆泰拳姿势死了不要怪我没指点啊!

你是弓箭兵 …… 安心射箭吧, 别想这么多了。士兵在该死的时候不死是一种耻辱。

如果你祖先积德, 分配了个骑兵, 也别太得意。你照样要练马步。那些喜欢蝴蝶步的兄弟还是在家和美女扑蝶嬉戏吧。

看到这里, 也许有些聪明的朋友已经明白了一个道理, 那就是“功夫实用不实用, 关键看你在哪里用”

当年巴西有个小男生, 学了日本的柔术。据他自己说“删除了一些不实用的技法, 创编了无敌的格雷西柔术”
格雷西柔术现在已经到处挨打了。说明这世界上那有什么无敌的东西? 那都是广告! 我们分析一下日本柔术和格雷西柔术的异同, 就不难发现格雷西删除的是什么技术。

日本柔术的针对对象, 是双手持武士刀的铠甲武士 (一般开始从小练刀, 反应不会比你差) 。面对这样的对手, 你用什么鞭腿, 什么下潜抱腿摔都是假的, 你若用鞭腿, 只见对方潇洒地大刀一挥, 只见一条腿如鞭一样飞上半空去了。
吾观察街斗多年, 未见有人敢对手持西瓜刀的对手使用高鞭腿, 便是这个道理。
但如果对手是个空手的人, 那便不可怕了, 拼着挨几拳, 也要把对方推倒凌辱一番。但这依然有危险, 你永远不知道他身上是不是藏着把小刀, 或者摸出把钥匙朝你脸上猛刺。
我观察了一下泰森的身板, 在要害未被刺中的前提下, 他大约能在挨5刀的情况下支持10分钟不死亡。超出10分钟则情形不乐观。
如果要害被刺中, 没啥说的, 当场毙命。
在街斗中, 吾未见面对匕首者双手护头跳跃作泰森状的。反对的人请上视频证明。

日本柔术和中国同类拳法 (太极拳) 的最大异同在哪里? 两者都有快速进身反关节夺刀的技术, 都有快速进身用“内劲”打透铠甲的技术, 都有借力跌人的技术。这几项都是战场上最实用的东西。
但日本柔术多出一个“寝技”, 其原因无他, 因为日本战争人少, 几百人对打就是大会战了。打着打着就稀疏起来, 可以放心用擒抱技术来抓俘虏, 除此以外, 还因为日本从来没发明过盾牌兵之类的兵种, 只要躲开了对方双手持的刀、枪, 近了身抱住对方的手臂就安全了。要是到了中国, 一盾牌 (铁山靠) 把你撞开, 顺手补一刀, 看你还来寝技?
但到了格雷西的时代, 就离战场越来越远, 在单对单徒手对抗中, 只剩下插眼踢裆等技术还能让对方忌惮一下, 格雷西柔术大刀一挥, 把插眼踢裆去掉了, 在不用武器的前提下, 寝技顿时失去了天敌, 迅速繁殖起来。我常常见一些热心的传统武术家在思考怎么对付格雷西柔术, 我每次都对他们说, 别想怎么对付了, 干脆就别对付。干吗去找郁闷呢?

战场之拳的第二要求是

1. 有去无回
有去无回不是指一种精神状态, 而是指你后面的人时刻在挤着你向前走。你一停步或者回头看一看就被50000人踩死。沉迷于侧踹, 鞭腿啊的兄弟抚心自问。你背后有人始终用全力推着你的时候你的鞭腿还剩下几成功力? 踢完人之后能不能站稳?

2. 贴身发力
我前面说的内劲打透铠甲, 估计已经有兄弟怀疑了。这也不怪你们, 谁叫你们没练过内劲呢? 我没练过也不相信有人深蹲900公斤。要真有人深蹲900公斤, 别说打透铠甲, 打透航母都可以啊!

在这里就公布一个不传之秘, 那就是日本人潜心研究中国拳法多年, 研究出来的内劲速成太监版。放到空手道馆, 至少要骗你几万块学费, 混到个什么师范才教你。
一般人出拳, 是先蹬地, 然后扭腰, 然后送肩, 然后出拳, 然后击中对手。
用内劲的人是先出拳, 然后迅速上前一步 (很重要) , 扭腰, 送肩, 同时击中对手, 就这么简单。只要用这个诀窍, 就算后面有一千人在拼命推你, 你也能连续不断打出重拳。能不能透甲, 就看你每天花几个小时练了。兄弟们, 拿出点练黑市拳流深蹲的精神出来!

外篇, 透甲打神秘吗?
答, 丝毫不神秘。练过散打跆拳道的都知道, 穿着硬式护甲被人一击KO的例子比比皆是。护甲充其量作用是避免流血性外伤罢了。你背靠墙站定不动, 在胸口垫一块木板, 我找个没练过任何功夫的大汉对木板猛击, 在座的兄弟估计没几个人能挨几下后还不吐血。何况我国古代铠甲一般以片状叠加的软甲为主。
透甲打只是一种更方便贴身的针对铠甲研发的发力方法而已。

总结一下, 在中国古战场上, 最实用的招数就是“站稳, 保护要害, 在对方武器以外的范围痛打对方。”
我国古代贪污成风, 士兵的武器基本都是偷工减料的。能拿到一套正常的武器/铠甲, 该士兵要含泪跪谢祖宗。这不是开玩笑的话, 是血 腥的事实。而即使是正常的武器, 砍了几个盔甲人以后也会损坏。作为一个老兵, 你不得不考虑后备武器, 那就是你的肉体, 这就是战场之拳的雏形。至于战场之拳的真正成型, 是在元代的禁武令之后。
元朝禁武器, 汉人藏武器者全家死。菜刀必须几户公用。申请备案。该菜刀出了血案伤了元人的话, 共用菜刀的这几户一起咔嚓咔嚓了。
宋军虽然积弱, 但毕竟曾用步兵对抗游牧民族几百年, 怎么可能没几分实力? 于是藏在民间两眼发红, 一边拜岳爷爷一边时刻准备还我河山的军人比比皆是。然而元朝的禁武令下, 你要是带着一批村民每天拿着武器练捅人砍人, 估计没几天你就挂在旗杆上示众了。
所以元朝的汉人武士们发明了一种看上去很像健身操的东西。“左手撑着, 向前一步, 右手向前伸一下, 回手摸一下自己后脑勺, 再摸一下前面……”“一手在喉咙位置, 一手在下阴位置, 用趟泥步往前走……”

太极拳里面有一招看起来很华而不实的招数“切地龙” (用日本人的说法就是“XX流秘奥义——地龙死闪) , 其真正用法就是近身后先举着盾牌顶着对方, 同时挡住对方视线, 然后保持盾牌举着, 身体下潜一刀子猛捅对方下阴。还有什么海底针 (水龙死闪) 大致上也是如此。揽雀尾则是用左手来抱着对方的长矛, 右手猛斩。
张三丰被元朝皇帝召见, 路上杀山贼若干, 他说他是夜梦神人授拳, 鬼 (元朝鬼子) 才相信。实际上答案很简单, 他就是传承战场之拳的人之一。但这要是明着和元朝皇帝说, 元朝皇帝绝不会表扬张三丰热爱科学实事求是, 而会命令御林军猛冲过来考验科学。

外篇: 戚家军剿匪法
有朋友提到, 在战场上最实用的是武器而不是拳法, 并且举出了戚继光为例子。
但事物并非一成不变的, 实际上在古战场上, 双方隔开距离对刺对砍, 实在是一种非常理想化的状况。实际的状况是什么呢? 是两军第一回合的对刺对砍之后, 你还没来得及刺第二枪, 砍第二刀, 就已经被后面的人挤得和敌人脸贴脸, 心连心了。这个时候如果你还没死, 那么最可靠的不再是手中的大刀长矛, 而是拳法, 肘法。只要能一拳把对手打晕2秒, 你就可能多活了两秒。
戚家军的鸳鸯阵是一种剿匪阵法, 适合对抗不能形成践踏性杀伤的小股的步兵倭寇势力。但是却不适合大规模军阵, 戚继光的战友余大猷中后期被调去守北边, 对付北方骑兵, 他就没再使用鸳鸯阵, 而是使用了其他更适合环境的阵法。
不审势则宽严皆误啊。

战场之拳中还有些叫“劈拳”的招数, 是单手从上到下砸对方的脸。这种拳法在手持刀柄的情况下威力特别强大。还有些叫大劈的招数, 则是一手高一手低地同时往下砸, 这一招的密码只需要手持长枪即可明白, 这是用枪尾凿击近身对手的技术啊。

以传承战场技术为目的的战场之拳在清代发生了很大变化, 其中相当一部发展为更适合用来单兵/小规模作战的“义士之拳”这点会在后文再述。

二千年传承的古武术秘密 (二)

闲言闲语, 在这个时代, 保守其实是没啥意义的, 我的师父们教我的时候不是怕教会徒弟打师父, 而是怕东西失传, 恨不得先都塞到我脑子里。但东西还是在我这一代失传了不少, 为什么? 因为这东西不值钱。
不值钱的东西就没人去学去练, 这是千古不易的真理。好比说我在第一贴里毫不保留地说了破甲打的发力方法。在古代我估计就会因此被同门追杀, 但是这样便宜地说出来, 留意的人又有几个?
其他人也就罢了, 但却要点名批评一下24, 这家伙最近一直挂着太极拳的名义到处招摇撞骗, 却连实战太极拳最基础的东西发劲都不会 (简直就像拳击手不会直拳一样) , 看见了真传一句话的东西, 却不去详细琢磨一下。中国功夫的名声, 就是败在这些终日大言炎炎, 沉迷于自我心理满足的人手里。

许多看帖人都在留意“古代打仗怎样才能赢” (其实养生一句都没提过战争的胜负问题) 。而自动忽略其他内容, 这就是功利心。这样的人适合当军师, 但不适合当士兵, 适合当票友, 却不适合当拳手。

下面我会专门用太极拳的一些秘奥义来讲解一下这一流派的战争之拳精髓。觉得不能理解或者声称自己没听说过的人也不用怀疑, 当小说看即可。

在说太极拳之前, 先说一下巴西的华丽格斗术: 卡波依拉
卡波依拉的动作主要为腿技, 其次是一些匪夷所思的翻滚跳跃技巧。这东西在现代人看来只是怪招, 看起来好看。改成街舞能泡MM。但这种拳法的来历是什么呢?
是几百年前, 殖民者入侵巴西, 将巴西男子列为奴隶, 持有武器者杀杀杀。大部分奴隶还要带着较长的手铐工作。连晚上睡觉都不能解下来。在这种情况下, 巴西人发明了一种华丽的“传统舞蹈”, 这种舞蹈实际上是专门利用手铐铁链为武器而研发的杀人拳。
卡波依拉的基础格斗式是身体不断左右变换 (尽量躲闪火枪) 两手保持距离交错在面前划过 (用铁链锁拿刺刀) 一旦抓住机会, 就用铁链锁住对方手臂或脖子, 然后通过身体的跳跃和旋转勒断目标, 这种包含体重和跳跃力的锁链技, 加上攻击角度诡异, 实在是奴隶们对抗火枪的最有效的方法。
看到这里, 我知道肯定有人把自己代入到殖民者的身份说: “这样能打得过火枪吗? 我如果拿火枪去打, 对方如何如何, 等等。”
但我也要反问, 当你就是那些奴隶的时候, 你去哪里拿火枪? 难道没火枪就安心当亡国奴了吗? 手上有啥你就用啥, 战争的胜负轮不到你关心, 但是关键在你努力了。

巴西有这样的技术, 中国也有。而且种类更多。
形意拳是以枪化拳, 太极拳则是刀盾兵留下来的拳法, 一刀一盾, 就是那阴阳鱼 (当然, 还有别的比喻)
所谓的借力打力, 在徒手打斗中没那么管用, 或者说, 使用难度太高, 但是配上了盾牌+刀, 就是最恐怖的技术。
当一个盾牌兵顶着四米长的长矛, 冲到敌人跟前, 他的任务就是把敌人的长矛阵破开, 让自己的兄弟们能冲上来。
在敌人的枪阵还没冲破的时候, 太极拳奥义“切地龙”“海底针”“跌叉”等技术的方法都是持盾矮身潜进, 避开上身的矛头, 用刀猛捅对方下身。而当近身以后, 则使用揽雀尾等技巧抱住对方的多枝长矛, 用刀猛砍。
揽雀尾的雀尾, 指的是孔雀的尾巴, 用来比喻许多长矛。当一个刀盾兵奋不顾身地抱住了对手好几根长矛的时候, 他的战友们就可以乘虚猛冲进去乱砍。
这也是揽雀尾被称为太极拳母拳的原因之一。当然, 揽雀尾也可以用来接腿摔, 用来反关节。但效果便打有折扣。
而当兄弟们都冲到身后, 把你挤得和敌人已经脸贴脸, 心连心的时候, 你已经没有距离举刀, 这种情况下, 你有几个选择

1. 用发力距离极短, 可以借背后力的发劲透甲打来打对方, 把对手打晕或者打退, 有了挥刀距离后补上一刀。
2. 用盾牌猛击对手。 (太极拳凡是用小臂发劲的技术大致都出于此)
3. 用刀柄自上而下猛砸对方的脸。
4. 丢了武器抱住对方脖子拧 (看着练太极拳的兄弟在那里玩太极石球, 不要奇怪, 等你的脑袋像石球一样在对方手里的时候就明白了)
5. 用盾牌挤对手, 趁对手用力对抗的时候盾牌上玩点虚实, 让对方失势跌倒 (牵动四两拨千斤) , 成功的话, 是让对手一大堆人一起跌倒 (踩死)
6. 用BT的柔韧性, 突然矮身用盾牌和肩膀撞击对方小腿 (七寸靠) , 让出上盘的空间给自己兄弟在背后砍/捅对方。
7. 用长劲将对方撞退, 然后突进砍杀。

除了刀拳合一的拳击术外, 太极拳有种种匪夷所思的小臂劲法, 例如堋、履、挤、按, 这些都是用盾牌打击或者挤压对手的训练法。还有採、挒这两种针对长矛或者对方手臂的控制技, 肘、靠两种近身打击技。

上述都是实用至极的标准军人技术。但军人和军人之间总有区别, 其中一些军人将自己的军体拳和道家的“返先天”奥义结合, 潜心体己, 发现了一些进阶的锻炼技巧。
注意, 是锻炼技巧。不是实战技, 我知道肯定有些回帖不看帖的人会在那里大喊: “这些东西战场上有用吗? ”我现在就提前回答: “这些就像长跑跳绳一样, 不是实战用的, 都是锻炼用的, 锻炼锻炼锻炼锻炼……”

和真正练太极拳的人搭手, 会有奇怪的发现, 就是无法从对方的手上感觉到对方的重心, 但对方却能抵抗住你的力量不后退。这个情况在某些练日本剑道的人身上也能找到。

答案其实在李仲轩前辈的门下另一条走狗徐浩峰 [2] 的书中已经披露, 那就是无名指锻炼法。 (全身及其他手指放松, 只有无名指紧张) , 无名指在日常生活中是废指, 很难动用到相关的力量, 但是它紧张的时候却能让力量传到手上。而且你感觉不到自己无名指的相关力量, 对方也感觉不到从你无名指上传出来的暗劲。
正确用刀挥砍的时候, 主要就是无名指带动刀的运行, 其他手指只是在砍中目标的时候紧张以保持刀的平稳, 所以很多练剑道的人无意中能练出这个效果, 专练柔道的兄弟反而练不出来。

而太极拳最重要的攻击力量虽然来源于无名指, 但是其核心却在大拇指上, 在持刀挥刀的时候, 身体因刀而失重, 全靠大拇指来维系刀的重量和平衡。内家拳的“人刀合一”秘法, 也在大拇指上。

我们平时坐公共汽车, 汽车一颠簸, 我们就要找个地方扶一下来维持平衡, 实际上扶一下那个力相对是很轻的, 为何就能让我们一百多两百斤的体重保持平衡了呢? 因为我们只是要找一下平衡感。找到了来源于两个大拇指的平衡感, 就进入了“不动之动”的境界。真正的 “四两” 拨千斤, 用的是四两重的大拇指, 拨自己的体重千斤。
养生自己发明了一个方法, 平时把大拇指握在其他四个手指里。行走时假装失重, 有时拇指从其他四个手指里寻找借力来平衡, 有时其他四个手指也从拇指上找借力来寻找平衡。

题外解释一下, 手背为阳, 手掌为阴, 把大拇指握在手掌里这种互相借力的方法, 暗语称为“阴中有阳, 阳中有阴”

关于原文:
养生自己发明了一个方法, 平时把大拇指握在其他四个手指里。行走时假装失重, 有时拇指从其他四个手指里寻找借力来平衡, 有时其他四个手指也从拇指上找借力来寻找平衡。
题外解释一下, 手背为阳, 手掌为阴, 把大拇指握在手掌里这种互相借力的方法, 暗语称为“阴中有阳, 阳中有阴”
作者的解释:
重心前倾走路, 感觉快失重的时候拇指一顶, 就像顶在别的物体上一样顺势把重心调整过来。
语言表达有其极限, 你可以试着坐公共汽车, 扶着扶手, 感受用手指轻轻借力来维持身体平衡的状态。平时练习, 就把拇指当作其他手指扶着的扶手。以此保持身体平衡。或者把其他四个手指当作拇指顶着来维持平衡的物体。

中国的武家, 为了避免被禁武的当局发现自己在练武, 纷纷借用道家学说来掩盖武功的练法, 所以你看一本古代的武功秘籍, 里面一大堆阴阳啊, 五行啊, 千万不要奇怪, 那些都是为了保证这本书被警察看到的时候不至于让书的持有人满门抄斩才这么写的。用时髦的话来说, 道家的隐语成了军用密码。例如“吕洞宾”“吕纯阳”, “吕祖”这些词指的都是男人的小鸡鸡。 (洞里的客人)
这些军用密码, 在上一代的武术家都还有很多能翻译, 但是到了我们这一代, 能翻译的人就越来越少了。还有些乱翻译的人 (好吧, 我是在说我自己) , 搞得秘笈出版界一片混乱。
读者们只需要明白, 当两个元朝/清朝初期的武术家在谈论“阴随以无厚入海”这种莫名其妙的话, 其实是在谈悄悄地背后用刀插入对方小鸡鸡附近的暗杀技术。就好了。

当统治渐渐稳定, 战场之拳再难有用武之地, 其中一部分战场之拳的传人沦为街头卖艺者, 向高难度的华丽动作发展, 一部分沦为拳手, 专业角斗供吃饱了撑的观众取乐 (或换个好听的说法说是参加奥运会为国争光) 。而其中一部分转变为义士之拳。

义士这个词, 在古代就是黑*色*会的意思。在元代, 是明教, 白莲教为主, 在清代是以天地会, 红花会等为主。这些秘密会社以反清复明为己任, 大多数时候潜伏在民间, 一般很少有大规模作战。打斗的对手一般也不是军人, 而是衙役, 捕头, 密探, 在这种情况下, 战场之拳就不那么实用了。其中有一些实战高手发明了更实用与当前这种情况的技术。

我年轻的时候, 遇到个练八卦掌的朋友, 这位朋友练了好几年的八卦掌, 但是还是打不过拳击手, 他十分苦恼。认为是他内力未到的原因, 实际上按他那种练法, 就算练十年, 也打不过练了十年的拳击手, 因为八卦掌这东西最早出现在商业社会的时候, 虽然是在一次职业擂台赛上, 但是八卦掌最早的诞生用途却绝非打擂台, 而是反清复明。
八卦掌的手法和身法让人眼花缭乱, 打击力却不尽如人意。有很多八卦掌的朋友因此苦恼, 都兼练铁砂掌之类的重手法, 但是铁砂掌配合到这样灵活的身手上却又没了威力。所以当世很多八卦掌名家都遇到两难的境地。
实际上八卦掌的可怕之处还是在兵器上, 空手的掌法也是掩人耳目罢了, 甚至连八卦掌这个名字也是掩人耳目。八卦掌的精华在其独门武器子午鸳鸯钺, 这东西可以锁勾, 可以划, 可以抠, 可以割。但这东西也只是和平年代用来表演的。子午鸳鸯钺的真正平民身份是——镰刀。
在夕阳下的小树林里, 一个双手持镰刀的农民, 突然用极其诡异的身法, 向着你的颈动脉, 股动脉, 脚筋, 腕动脉等地方连续不断地袭击, 你出一刀的时间他已经对你攻了五六刀。而当你反击的时候, 他又躲到了树后, 用匪夷所思的角度不断袭击你。八卦掌的“九宫步”, 说穿了就是在人群中, 树林里逃走或者躲闪反击的技术。在树林/无辜群众里的话, 什么形意拳, 什么太极拳, 都不是八卦掌的对手。
八卦掌其实是介乎暗杀拳和义士拳之间,
真正招牌的义士之拳就是“洪拳” (前身为太祖长拳, 后来者为国标武术长拳套路)
太祖长拳, 即托名宋太祖的黑*色*会拳法, 在元朝就有出现。
其特征如下:

1. 注重王八拳 (最符合人体本能的拳法, 但此王八拳非彼王八拳, 下面会详述)
2. 注重桥手 (小臂运用技巧)
3. 注重移动, 上一招向东打, 下一招可能就向南跑了

今晚累了, 明天看看有没有朋友能猜到为何会有这三个特征。

二千年传承的古武术秘密 (三)

小温侯所谓的言论自由, 我国自古就有, 不过定义稍有不同, 大多数人对言论自由的定义是 “我有批评你的言论自由, 但是你没有反驳我的言论自由。”

上个帖子里, 有人不就具体问题反驳或骂 (这点24倒是做得比他们好) , 却喋喋不休于“武人学文就是忽悠人”“我最反感有人一个人会很多门派功夫的”

金庸大侠说的好, 某些人一辈子就练一种拳法, 美其名曰“贵精不贵多”, 他们是否能做到“精”, 那是很可疑的, 至于“多”是肯定做不到的。所以只要有人说“贵精不贵多”, 他们就油然而生知己之感。
而养生刚好相反, 所学的拳法能不能做到精这个很难说, 但至少种类多是无可疑的。而且读书不少, 所以绝不是他们的知己。

养生认为太极拳为刀盾兵所创, 证据嘛……比太极拳是张三丰夜梦神人所授, 或者陈王庭在乡下种田时拍脑袋想出来的还是要充足一点的。
陈王庭创太极拳说, 来源于陈氏族谱。而养生的说法, 来源于春秋时期齐桓公的……错了, 那个应该是神虎术。那么就来源于李景林将军的秘传日记本好了, 李景林将军深明打仗之道。他日记里的记载应该比在座各位都有说服力吧? 看谁还敢质疑?

调侃就到这里好了, 前几天有兄弟其实已经答对了。义士之拳是利用杂物, 以少对多, 克制古代警察的一种拳法。

顺便回空格兄的话, 依靠鲸鱼和鲨鱼样子长得像, 是不能判断他们属于同族的, 但是却能够判断出这两种东西都是在海里生活的。因为他们的样子都符合海洋生物原则, 而不符合陆地生物原则。

我们先看看义士之拳必须符合什么原则

1. 身体平衡, 不容易在移动中摔倒。一旦倒地, 就会被一堆捕快扑上去施展巴柔紧紧擒住。而被擒住的话, 则比死还惨, 自己受尽酷刑不说, 还要连累亲戚好友一起死。
2. 反擒拿, 不能被人轻易用关节技抓住, 理由同上。
3. 在一群围着自己的对手中找到可逃生的空位, 并且冲出去。
4. 为活命不择手段。 (没错, 就是24如获至宝地发现的无限制格斗术)
5. 简单速成。
6. 所用武器便携。

义士拳五宝之一, 四平大马
大部分义士之拳里都有四平大马, 就算不是四平, 也是马步桩。李连杰演的精武门里批评马步桩, 说那样不适合起腿踢人, 所以是死马。那部片的动作指导估计是个李小龙迷+散打控, 哪里知道马步桩的妙处?

马步桩之妙, 第一在速成。
义士们平时要工作养家, 还要打扮成良民大大的样子, 自然不能像职业拳手那样买了各种器材, 公然夏练三伏冬练三九给官府看, 这样一来, 大多数时候也只有晚上睡觉前能关了灯练一阵子。在这种前提下, 四平大马就是最快的增加平衡力和腿力, 协调性的方法。

站四平大马也没啥标准和诀窍, 就是按标准站到四平状态, 站到四平就啥都懂了。诸如“两膝对称撑拔, 气沉丹田, 腰马合一。”等, 一句话概括起来都是四平状态, 说多了反而让人糊涂。
练拳有两种方法, 一种是明理后练拳, 一种是练拳后明理。前者精细, 后者强壮。各有各的好处。各有各的好处, 嘿嘿。

有人也许会说“四平大马这东西对膝盖有害啊, 是不科学的练法。”, 义士们对此则回答说, 眼前还活着最重要, 让科学见鬼去吧。
四平大马之妙, 还在于这是一种在移动时能时刻保持身体平衡的步法。拳击的步法在打中目标时固然威力强大, 但是在开始移动到攻击到目标之前, 身体都处于被他人一撞就会失重的状态。这种步法是不适合群战的。
当然, 义士之拳中也有高位步法, 所谓的高位步法也没什么特别, 就和田径运动员的短跑/跳远前的助跑差不多。但只要有人近身, 就会马上切换为马步。

二千年传承的古武术秘密 (四)

AMAN和风云生是两个不同的例子, 风云生认为传统拳法有其适应性, 所以坚持在研究传统拳法在现代擂台上的应用, 以及和西方技术的结合。AMAN则直接否定, 认为传统的发力方式在西方人厚实肌肉面前不起作用。
对于适应性, 我的看法是这样的。
一匹马和一匹毛驴结合, 生下的是骡子。虽然骡子可能比马和驴都更适应特定环境, 但是他们非马非驴。
形意拳和拳击结合, 它们的产物可以叫形意拳击或者风云道, 但是不能叫形意, 也不能叫拳击。形意拳和拳击各有其对应环境, 集合了一些精华的同时, 必然导致其他一些精华的失传。以传承为目标的, 则是形意, 以发扬形意拳其中某些技术或训练方法为目标的, 则是风云道。

AMAN所练的, 则是散打, 散打就是散打, 不是别的东西, 他说他练过形意拳, 但只要他用的教的研究的练的不是形意拳, 那就等于没学过。把两者扯到一起, 也只是骗骗外国人吧。
题外说一句, 85年左右我还是儿童的时候, 曾看过AMAN对张建国的散打比赛。因为某些缘故, 有深刻印象。一转眼二十多年, 物是人非, 真是让人感伤。

题外话说完了, 继续说义士之拳
义士之拳的第二宝, 是王八拳。
对于一般没受过职业训练的街战者来说, 为什么本能的用王八拳? 因为王八拳是一种杀伤范围大的拳法, 只要在手臂范围内, 都在扇形攻击覆盖下, 只有整体下潜躲闪才能躲得过。而会使用下潜躲闪的人一般都是受过职业训练的人 (会使用腰腿力) , 常人无非就是硬抗或者后仰躲闪。
王八拳能保证在自身训练时间较短, 而又面对大批平庸对手时, 有相对较高的命中率。而杀伤力问题则用武器来弥补。
《杀破狼》里吴京手持一把短刀来使用长拳。动作设计者是个明白人。但最适合长拳的武器不是短刀, 而是峨嵋刺, T字短拐等。一个王八拳摆过去, 对方低头闪过了后, 还能回手再摆一下或者顺势举起往下扎砸。一个回合能攻击好几次。如果配合马步移动还能造成一次出拳横扫几个目标。回步又横扫或者突捶其他目标等。
也许你这种横扫几个目标的拳法杀伤力不够大, 但却能起到“荡开阵脚”的地步。在横扫的过程中, 对手谁是最弱的, 马上就能分辨出来。

用三国演义中三英战吕布的局面来比喻一下, 三英战吕布描述的不是军阵, 而是小群殴, 吕布单对单未必能绝对搞定关羽张飞, 但是依靠赤兔马的移动和力量, 却能和他们两个打得不落下风。等到刘备上阵, 形成合围, 吕布移动就有了困难, 但刘备三人组中最弱的刘备还是成了吕布逃跑的突围点。
这个突围法, 是义士之拳的第三宝
冲撞
义士之拳中有很多冲捶类的拳法, 冲捶之后还有靠撞的小动作。
冲捶的原理和训练方法很简单, 就是上半身硬梆梆的, 把手和身体化为刚体, 利用下身的快速移动把这个刚体向对手捅去。这东西没什么技术含量, 就是简单速成, 无需悟性。
琉球人的空手道也是义士之拳的传承, 他们最喜欢召集一大堆学生把这样硬梆梆的一个正拳练上N久, 只有入室弟子花钱买了黑带才教身追手的破甲打。
这个故事告诉我们, 功夫有时不需要精深, 只需要够用就好。一名义士如果能用这样没有技术含量的技巧在人群中冲撞出一个缺口跑掉。就是捡回了自己的命, 捡回了组织的命。捡回了红花会千千万万弟兄的命。

这类不精深但是好用的拳还有很多精髓, 例如 “唯快不破”。
人的反应神经最快的时间一般在0.2秒左右。很多拳击手出拳都比0.2秒快, 那么对手怎么办呢? 还是可以破, 因为可以观察对手的身体变化, 尤其是肩部或者脚步, 可以判断出提前量。
而大部分普通人出一拳至少要 1 秒, 那些没时间进行职业训练的义士估计不会比普通人好到哪里。但是他们却能做到超越对手的神经反应能力, 避开对手对自己的身体预估来对对手进行打击。

待续, 看看有没有兄弟猜到义士之拳中的 “唯快不破”是如何解释和应用的。

唯快不破

在说这个技巧之前, 我先埋下伏笔。说一下别的东西。

李小龙的截拳道创立时期, 李小龙主要的交手对象为中国南方的武师而非外国拳法, 而李小龙的拳法架势非常特别。在这里估计没人不了解截拳道的架势, 就不重复了。
清末, 埋藏数百年的战场之拳太极形意等纷纷重出江湖。和八卦掌一起横扫北方武林。
王芗斋认为形意拳有不适合环境的地方, 于是对形意拳进行了一定的改革, 其独特架势为前手远远撑抱的矛盾桩。

上述拳法在当时虽不能说中国无敌, 但是却都是一方豪强。至少都是公开接受挑战的。而且挑战者众。证明其是有实战作用的。
但这几种拳法到今天则再也不能横扫一方, 为什么呢?

继续扯。

义士之拳故老相传中常说“某招可破某招, 某招可克制某招”。这些话, 练现代搏击的人自然都不屑一顾, 但是在一两百年前, 这些话是谁都不怀疑的真理。
原因就在唯快不破, 唯硬不破这八个字上。

上文说到人体反应一般最快就是0.2秒, 义士们在社会稳定的情况下, 纷纷退出江湖, 成为“技击家”, 作为技击家, 一般对手就是单体攻击为主, 虽然还有群战套路传下来, 但是较技时一般不用群战套路, 而是用门内秘传的“独门绝招”
需的说, 这个世界上没有什么绝招, 只有对方破不了的攻击。要对方破不了, 只有更快。

在肌肉能力有其极限的情况下, 最快频率攻击对方的守则如下

1. 动作尽可能小, 避免对手预读后躲避, 小动作也有两条出路, 一条出路是纯靠手法袭击对方面部脆弱器官, 身体不参与出力。另一条是手先动, 身体到2. 最后一刻才参与作功。
3. 发力距离尽可能短, 距离2米出手, 就算再快也要0.7秒才打的到对手, 距离10厘米出手就算不快也只要0.1秒。
4. 减少自己出拳时花费的思考和计划时间。

南方之拳术家相角, 则一二手, 多亦不过五六手, 势均力敌者, 不互中要害, 即相揪相扭, 同时力竭罢角, 或重整旗鼓, 相与复角, 曾未有角至若干手, 尚不分胜负者, 此其分别之点, 在北拳尚气劲, 南拳则不然, 纯以技巧胜, 功夫不到者无论已, 有工夫者, 其气劲不必惊人, 然出手必能创敌, 角时多不施展门户, 临时落马, 意到手随, 每有胜负之分, 非特旁观者, 不知所以致胜之道, 即被创之人, 亦多不明敌手来去之路。

二千年传承的古武术秘密 (五)

东西方的思维模式是完全不同的, 好比说某男失恋后迁怒, 杀了他的教授, 东方思维是: “如果他没失恋, 就不会杀人了。”西方思维是“幸亏那女的没嫁给某男, 不然也和教授一起被杀了。”
这两种思维都是对的, 也都不对。

思维模式的差异, 最终使东西方拳法开始走向不同的领域。如果按西方的思维看唯快不破, 那么就是猛练速度, 比对手更快到达目的地。按东方的思维就是减少距离, 比对方更快到达目的地。
我培训一批新下属时, 常用一个手段, 就是问对方认为自己的上限是每秒能打击多少次。有人回答1次, 有人回答3次, 有些经过锻炼对自己速度比较自信的人回答5 次。我便拿着秒表给他计时10秒, 让他尽全力高速鼓掌, 自己数次数。结果是很出人意表的, 一般普通人每秒鼓掌平均在7次以上, 部分人达到12次以上, 受训的人往往也被自己所数的次数所震撼。不相信是自己做出来的。

这个鼓掌的原理, 包含了许多纯技巧上的武学至理, 例如什么同动近取, 截拳中途, 本能出击, 贴身发力等。当然, 这些只是博大精深的武学中的一个局部。但人都有走极端的时候, 大约在清代中后期, 中国拳法在整体上就走向了这样的一个极端。
因为义士之拳普遍使用小兵器作战, 所以在这个情况下, 你只要手上拿一支小铁笔, 用鼓掌的速度对对方眼睛, 咽喉连续猛插, 一般没练过的对手就铁定得死。
而如果手上没有小铁笔怎么办呢? 也有办法, 就是将自己的手练得坚硬如铁。这也是现代内家拳的人往往不齿的“局部力、局部硬度。”以一对坚硬如铁的手, 用练成了本能的鹤啄, 虎爪, 手刀, 拍掌等手法, 每秒7~12下地对对手脸部发动多角度攻击, 如果配合马步突进, 实际攻击速度还能翻倍。而人体反应速度的上限是每秒反应5次 (做到这点的也是神人了) 。外加眼睛受到威胁时的本能躲闪反应时间, 理论上几乎是1秒内必分胜负。
当双方都完全依靠“拳招”来形成鼓掌式攻击本能时, 谁的招数 (攻击角度次序) 最能克制对方的攻击角度次序, 谁就能先击中对手, 一旦击中, 则绵绵不绝。 (如果手持武器, 则一击必杀) , 在这种情况下, 传说中的“拳招时代”就到来了。

当然, 每秒 7~12 下只是理论速度。实际上影响攻击有效性的因素很多。为了对抗这种 “闪电手”, 我国拳法家也发明了很多训练方法, 例如 “听劲” “粘手” “擒拿” “拔根” “控距” “地堂” 等。

清末, 隐藏多年的战场之拳突然重出江湖, 大杀三方。并不是战场之拳在街头打起来一定真的比这种义士之拳实用, 而是因为“杀人时代”过去了, “比武时代”开始到来。在徒手比武中, 因为前提是被对方轻攻击击中非要害部位不会死, 那么战场之拳就能大行其道。
战场之拳最擅长的就是用整劲使对方的锋锐 (长枪或鹤啄手, 砍刀或虎爪) 的攻击偏移, 使对方不能连击。例如形意拳的整劲硬打硬进, 八卦掌的闪击, 太极拳的缠绞。这些隐藏拳法的重出江湖, 为一味追求“唯快不破”的武林带来了一片新的气息。但也是真正的战场之拳, 义士之拳失传的开始。当战场之拳, 义士之拳用于和平年代的比武, 他们就像被阉割后的动物, 只能发出瞬间的光辉了。一旦有其他更适合和平年代比武的拳法出现, 这些旧时代的拳法就必然被淘汰或挂羊头卖狗肉。

而除此以外, 还有擅长距离控制的流派。例如大成拳和截拳道。
大成拳王芗斋公然声称“一切局部硬度的手法打法, 全不足取”, 他在当时也未尝一败, 主要原因还是他的对手主要是古拳法, 他所发明的矛盾桩也是一种专门破解唯快不破拳法的架势, 重心后倾, 前手远撑不让对方近身, 后手和脚等待机会给与打击。这样的架势适合对抗古拳法, 却不适合对抗现代拳法。

李小龙的截拳架势则是侧身对敌, 用低端截踢控制距离。等待机会给与重击。这样的架势适合对抗古拳法, 但也不适合对抗现代拳法。

所谓的“拳本无法, 有法也空”“以无法为有法”其中透露出来的信息, 就是“用最适合环境的打法去在这个环境里打”, 在散打擂台上, 最实用的拳法就是散打, 在泰拳擂台上, 最实用的拳法就是泰拳。
在这个和平年代, 最实用的拳法就是养生。如果以泡妞为目的, 最实用的拳法就是跆拳道 (不带I) , 如果想要保命, 则最实用的是消除自己的一切心理盲点, 让自己迅速进入环境, 进入角色。

空拳老陶的拳法可以说威力一般, 看老陶体型也很疏于锻炼, 但是我相信很多专心练习 XX 拳的人打不过他。原因无它, 因为他没有 “心理盲点”。这个心理盲点则是专注于 “XX拳” “XX擂台” 的人最致命的地方。
替老陶打了一下广告, 这家伙应该付我钱。

--
附注:
[1] 因为是论坛连载, 作者比较注重和读者回帖互动, 并调整内容。在结构上较为随意, 并没有完全按照提纲进行编写。
[2] 这里是学习借用网友 "太极拳24" 的说法, 没有贬损的意思。

本文说一下如何把 python 翻译成如假包换的 c 源码, 然后编译成一个 python module。据官方博客称性能接近或超过 c。用到了 pypy —— python 史上最大的玩具。

先写个 python 源码文件, 待会编译出来:

# hello.py 文件

def hello(a, b):
   print a, b
   return 'OK'

def target(drv, args):
   return hello, [str, str]

先测试通过:

>>> import hello
>>> result = hello.hello('hello', 'world!')
hello world!
>>> print result
OK

翻译成 c 并编译:

    $ pypy/translator/goal/translate.py --batch hello.py

生成的目标在, /tmp/usession-dist-USERNAME/testing_1/testing_1.so 。

    $ mv /tmp/usession-dist-USERNAME/testing_1/testing_1.so _hello.so

也可以写个自动化脚本编译完自动拷贝出去, 生成 testing_1.so 的目录位置在 driver.cbuider 对象里。可以参考 translate.py 写一个自己的编译平台 (哦, 一个玩笑)。

我们得到了 _hello.so 。里面有这么一个接口, 可以想见 python 调用起来很方便 (c 定义):

    PyObject *pypy_g_pyfn_hello(PyObject *l_a_0, PyObject *l_b_0);

至少在 pypy-1.1.0 里是这样的, 以后就不一定了。

测试。先写个 _hello.so 的 python wrapper:

# hello.py 文件, _hello.so 的 python wrapper
from ctypes import *
_hello = PyDLL('/PATH/TO/_hello.so')
_hello.RPython_StartupCode()
hello = _hello.pypy_g_pyfn_hello
hello.restype  = py_object
hello.argtypes = [py_object, py_object]

测试通过:

>>> import hello
>>> result = hello.hello('hello', 'world!')
hello world!
>>> print result
OK

这样, 我们就可以用 rpython 来写可编译执行的 python c module 了 (这是 c 后端, 据称在 cli 和 jvm 上能做的事情更多一些)。然后好处是, 你的模块可以同时兼容 python2、python3、pypy 了。进一步他是个 c lib (pypy 会导出 c 接口), 其实在任何语言平台上都是可以用的。

不过, 这显然不是标准的 pypy 应用, 事实上我们应该用 pypy 的 MixedModule 来写。不过可惜的是 MixedModule 编译到 python c module 的功能已经在 pypy-1.1.0 取消了。pypy 团队在事后就此事和广大 pypy 用户进行了讨论, 取消该功能是否是个好主意 (在已经取消的前提下)。官方觉得, 还是专注于把 jit 搞好吧, 其他炫的东西先放一放, 毕竟 jit 搞定了, 你就不再需要什么 python c module 了。总之, 你需要等很久, 无聊的话, 像这篇文章这样玩一下也不错 。

PS: 喜欢把 python 编译执行的朋友, 可以试一下 Cython 和 ShedSkin, 他们是专门为这个目标设计的。

昨天 8 月 23 日, 我们就如何把以后上海 python 聚会的组织得更好, 于科技会堂再次进行了线下讨论。我们觉得上海 python 技术聚会一直有在办, 以后可以更常态化, 并且做到更好、做到超赞。归纳一下, 我们谈到以下几点。

1. 我们需要好的场地。

好场地可以产生好氛围。上次聚会我提到像科技会堂、学校教室容易产生上课的效果, 而我们可能更喜欢放松、愉快的效果, 比如茶话会形式。场地影响到活动形式, 然后改变活动内容, 我们可能不再以会课、演讲形式为主, 而使用更轻松的活动方式。我们提到将来可以采用的场地和形式有咖啡馆、一茶一座、公园以及烧烤等。

与会人士纷纷表现出向往的神情。

支晓勇提到, 作为长三角 python 用户组, 不能局限于上海。下一次可以开展到苏州、南京、杭州等地方。组织方可以提供方便, 比如把上海或者其他地方的人打包运到杭州。根据案例算上交通、饮食每人共需花费 60￥, 费用自理。旅游 + 技术, 交流 + 休闲, 还能把 python 技术推广到长三角各个城市。

所有人表示支持, 高呼满塞。

这就产生一个衍生话题, 活动经费的问题。我认为像上次那样由组织者也就是支晓勇承担所有场地和设备的费用 (科学会堂场地租用是 700￥, 仅租用场地方投影 400￥ … 等等) 可行但不利于长期开展活动, 或许个人可以长期负担这项开支, 但是这也对活动产生限制, 比如我们就不能开展上面提到的旅游聚会, 我们总不至于让组织者个人来支付所有人的旅行的开销吧。同时我们认为为了举办活动而收取固定会费也是不可取的。

我们很快想到了解决办法, 在活动前的一段时间, 我们可以先在网上召唤出足够多可选的场地, 并给出每个场地产生的费用。比如咖啡馆, 每人只要买一杯 20￥ 的饮料即可蹭一下午, 烧烤亦然。公园场地、科学会堂则在网上对当此活动每人需要分摊的经费进行公示。我觉得如果谁有认识不错的场地提供方, 我非常推荐给他们拉下生意, 比如咖啡馆、酒吧之类, 只要他们愿意为我们提供实惠的价格和良好的服务, 这绝对是双赢的好事情!

大家在网上对列出的场地进行投票, 选出支持率最高的。

我认为在会的志愿者大家都是活动的参与者和决策者, 大家一起提供场地选项, 投票决定。只是志愿者要更热心一些。然后比如大家认为下一次活动可以在杭州举行, 那么我们就根据投票里面公示的地点、日程和费用, 包车, 并把杭州场地搞定。除了上海, 比如南京的同学在志愿者的努力下也应该可以一起打包前往。

2. 我们需要好的内容。

几个世纪以来, 漫长而又沉闷的演讲, 无尽的技术剖析, python 技术推广一直是我们的光荣传统。

我的观点是, python 技术和技术聚会也可以是一种生活, 我们可以不用刻意去搞一次技术交流, 因为这本来就是周末可以选择的一种休闲, 它带来愉悦, 这就像生活本身一样自然。我们享受生活。如果这不是生活, 就会是一种负担, 我们很难坚持做一件给自己带来压力和负担的事情。

我们谈到很多有意思的交流的方式, 比如 7 分钟演讲。演讲者可以随时被番茄轰炸下去。提出 7 分钟演讲的同学说, 他参加这类活动, 场面火爆, 天涯海角、绿树红花、千奇百怪、海阔天空、欢声笑语、鸟语花香。我们还可以像广州 python 聚会和 google 那样插播乐器演奏和才艺表演。并且鼓励参与者做一些有趣的技术演示, 提供看得到的好玩, 比如 pygame 、硬件 DIY 等。

加入诗歌朗诵、才艺表演, 把技术聚会变成周末娱乐, 回过头来发现本质上依然是技术交流, 依然是会课, 这不是更好的 python 推广吗。就好像本质上是填饱肚子, 除了让人如同嚼蜡, 我们还可以选择把菜做得相当艺术。

活动内容集思广益, 投票决定。决定活动形式和大家感兴趣的技术话题, 其中当然也包括较为严肃的会课, 提供入门或者某些专题技术的系统讲解。一些大家不太感兴趣的话题只要人数足够也提供专场活动。这也是大家所需要的。这并不矛盾, 社区里不同口味的技术人员应该可以自己组织起不同形式的活动, 甚至可以在同一场分成不同话题和形式的多个讨论区。

我提到技术沙龙应该还具有更多的功能。比如撮合项目, 可以是开源项目、公共项目也可以是商业项目, 让志同道合的人走到一起, 发现商机, 共同解决技术难题, 或者合作创业。而这又回到前面, 我们需要一个能让大家充分放松、令人愉悦的环境, 还有开放式的、扫除拘谨的活动形式。这样就不会像上课那样只有一个演讲者在那里讲, 所有人都可以方便地交流观点, 互相认识。

我们需要这么一个平台, 不是么?

开始的自我介绍就会比较重要, 可以让大家先介绍一下自己, 网名, 从事的工作和感兴趣的技术。每个人一旦开讲, 就会消除很多拘束, 大家迅速熟悉起来。

对于喜欢在技术交流上作商业广告的同学, 我并不排斥。只要对大家真的有用, 并且不要过了限度变成你的广告发布会, 我也不会强烈反对。

3. 接下来的活动

我们谈了下以后可以为 python 技术聚会长期开展能做的事情。我们纷纷表示为了正义的 python 事业有力出力, 没钱卖血。基本上, 我们可以贡献的是投影仪、摄像机等器械, 人力还有时间。希望更多的朋友能够加入进来, 人多力量大。

接下来可能会先找一下提议、投票等组织工具, 如果现有的不够用/不够好用, 反正这里都是程序员 ……

长三角地区, 如果你有熟悉的场地, 如果你有亲戚朋友或者自己在经营咖啡馆酒馆茶馆, 如果你比较熟悉旅行社, 如果你能够为 python 技术聚会提供任何帮助, 欢迎联系我们。

你可以发信联系支支同学 (他是上次活动的组织者, 他把全家都动员了)。

前言

尽管在国外有一些闲置的服务器, 但是却不敢拿来建网站。网站这种应用出境率太高, 即使像 fr_eebsd.org 这种良民, 被 GF\/\/ 也是很容易的事情。到时候不仅 $ 打水漂, 可恨连 VPN 都用不了, 上网只能戴套, 实在是划不来。

于是乎我决定利用 ADSL/HTTB 带宽建站。至于服务器, 实在不想和豆瓣的阿北一样用笔记本来做, 一方面耗电, 另一方面笔记本常有爆炸事件, 不敢在无人职守的情况下超长待机。故决定使用 NAS (网络存储服务器, 网盘) 来做。

这里性价比最高的是 Buffalo 的 Linkstation 网盘, 首选的是 LinkStation HD-H120LAN120G 这个型号, 居然拥有高达 400M 的 MIPS CPU 以及 64M 的巨量内存 (耗电 20W 左右)。当然非常不幸的是, LS 120G 全上海断货, 而且奸商奇货可居哄抬物价, 这令 Cr@cker 非常不爽。

最终这直接导致了我选用路由器这种 "难民级" 设备来建站, 鸟枪变炮。于是就有了这篇文章。

硬件篇

当然也会有少数人不理解, 路由器怎么可以拿来做网站呢? 是啊, 你一两百块钱买过来的这个小盒子尽管便宜, 却也是一台完整的高性能计算机了, 除了没有显示器和鼠标键盘。当然啦, 只要你愿意, 加个诸如摄像头或者声卡什么的外设还是可以的。

大部分的路由器的固件都是可以重新刷过的, 诸如 LinkSys、D-Link、Buffalo、Netgear、ASUS 这些品牌的路由器都在著名固件 "OpenWrt" 支持之列。这里有一份详细的 支持列表, 请先查阅。

经过研究, 我觉得 ASUS 系列的路由器较为实惠。首选 ASUS WL-HDD 这款 "网络硬盘盒", 他的特点是比起一般的路由器多一个 2.5 IDE 硬盘接口以及一个 USB 1.0 接口, 可以加装一块硬盘和 USB 盘用于存放网站数据。

其次是 ASUS WL-500b (可以升级到 WL-500g) 和 ASUS WL-500g 路由器, 他们使用和 WL-HDD 一样的硬件, 也带有一个 USB 1.0 接口。使之同样成为建站和网络打印服务器的首选。

WL-HDD/500b/500g 售价都在一两百元上下, WL-HDD 稍贵, 我在上海以 248￥ 拿到的货。他们的硬件配置都是 MIPS BCM4702 125MHz CPU、16MB SDR 32bit 内存和 4M 闪存 (耗电 10W)。

另一个版本 WL-500gP 稍贵, 拥有 200MHz CPU, 著名改*机网站 "数&位天堂" 就是构建于 ASUS-WL-500gP 之上。网站上有 WL 全系列硬件配置表, 若要选购以作改机之用, 可以参考。

(图片来源 "数位+天堂")

下面专为 ASUS 的 OLEG 固件开辟一节, 未在其他硬件上测试过, 其他路由器用户可快速掠过, 去到 OpenWrt 固件部分。

ASUS 专用固件 OLEG

固件 (Firmware, 韌體) 被保存在路由器闪存中, 通常是一个完整的 Linux 操作系统。将路由器原固件改成自定义固件, 可以实现在原有路由器功能上增删定制任意自己想要的功能, 就像是操作一台完整的电脑一样。

刷新固件, 常用于使路由器自动下载 BT、绕过 ISP (诸如网xx通、电yy信) 的多a用b户c共d享e限f制, 绕过 ISP 的 DNS 域a名b劫c持d等流_氓行为。这里就不详加讨论了, 请诸位自己找资料。

OLEG 是 "数位天*堂" 选用的固件, 是通过 ASUS 官方固件修改而来。门槛较低, 兼容性高, 这里推荐初级 ASUS 用户使用。下面是刷机步骤。

1. 造访 http://oleg.wl500g.info/ , 下载最新的固件 (WL-HDD 用户请下载 1.9.2.7-9 及以前的版本, 其后版本不支持 WL-HDD)。
2. 解压缩 WLxxx-1.9.2.x-x.zip 得到 trx 文件。
3. 访问自己的路由器地址 http://192.168.1.1 (WL-HDD 是 http://192.168.1.220, 推荐使用直接的网线连接而不是无线方式), 登录后找到 "System Setup" 的 "Firmware Upgrade" 项, 上传 trx 文件。
4. 稍候片刻, 等待机器自动重启。

(图片来源 "数位+天堂")

重启后会再次进入管理界面, 设置用户名。这样你就可以通过 telnet 来登入路由器了 (密码: admin)。哇噻, 我的到了一个 Linux Shell!

接下来接入 USB 盘或者插上 IDE 盘, 如果不喜欢命令行的 fdisk 工具, 可以先使用其他工具分区格式化再接入 ASUS WL 设备。然后执行 "fdisk -l", 下面是在我机器 (WL-HDD) 上的显示。

Disk /dev/ide/host0/bus0/target0/lun0/disc: 120.0 GB, 120034123776 bytes
255 heads, 63 sectors/track, 14593 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes

                                Device Boot    Start       End    Blocks   Id  System
/dev/ide/host0/bus0/target0/lun0/part1               1       14395   115627806   83  Linux
/dev/ide/host0/bus0/target0/lun0/part2           14396       14461      530145   82  Linux swap
/dev/ide/host0/bus0/target0/lun0/part3           14462       14527      530145   82  Linux swap
/dev/ide/host0/bus0/target0/lun0/part4           14528       14593      530145   82  Linux swap

接下来就是挂接硬盘 (当然, 如果对原装的 4M flash 有信心, 也可以不加硬盘撒):

# mount /dev/ide/host0/bus0/target0/lun0/part1 /opt
# swapon /dev/ide/host0/bus0/target0/lun0/part2
# swapon /dev/ide/host0/bus0/target0/lun0/part3
# swapon /dev/ide/host0/bus0/target0/lun0/part4

安装 ipkg (硬盘/U 盘已经加载置 /opt 目录):

# mkdir /opt/tmp
# mkdir /opt/tmp/ipkg
# wget http://ipkg.nslu2-linux.org/feeds/optware/oleg/cross/stable/ipkg-opt_0.99.163-9_mipsel.ipk
ipkg.sh install ipkg-opt_0.99.163-9_mipsel.ipk
# wget http://ipkg.nslu2-linux.org/feeds/optware/oleg/cross/stable/uclibc-opt_0.9.28-13_mipsel.ipk
# ipkg.sh install uclibc-opt_0.9.28-13_mipsel.ipk
# ipkg update

这样我们就可以像使用 debian apt-get 一样直接通过 "ipkg install xxx" 来安装已经编译好的二进制程序了。

在 http://ipkg.nslu2-linux.org/feeds/optware/oleg/cross/stable/ 位置拥有大量的 ipk 文件, 这些都是 ipkg 包, 实际上, 我们大可不必使用 ipkg 程序来安装这些软件。

ipk 文件实际上是 tgz 格式的, 解包后会得到 data.tar.gz 和 control.tar.gz 两个 tgz 文件 (tgz 套着 tgz? 貌似很奇怪的样子), 而 data.tar.gz 就是二进制程序结构。使用解包的 data.tar.gz 文件, 可以提供一种更为灵活的系统维护形式 (初级用户不推荐)。

好了, 简单的配置就这样了, 请玩家继续深入阅读 OLEG 的相关参考资料。

数.位天堂::ASUS 500 改机讨论区 WL-500g::系列改機基本步驟
Sprayfly::WL-HDD/500 Setup Guide

OpenWrt 固件

OpenWrt 固件通常是骇_机族的首选, 基本上你可以自由定制包括 Kernel 在内的所有东西, 这往往给人一种很爽的幻觉。除此之外, OpenWrt 还有一个叫做 DD-WRT 的表兄 (访问其主站需_破.墙_) 以及 DebianWRT 的堂兄, 也可以在 OpenWrt 上跑 Gentoo。

其中 DD-WRT 在管理上相当便捷, 玩家也是颇多的, 这里也推荐大家不妨尝试一下。而在路由器上跑 Debian, 就比较诡异了, 而跑 Gentoo 就更是说不出的诡异了。这里我的首选还是 OpenWrt, 因为我需要一个足够小, 占用资源足够少的固件, OpenWrt 定制起来非常方便, 自己编译吧。

当然 OpenWrt 已经有编译版了, 只是想用 OpenWrt 而对定制没有要求的同学可以偷懒了。

这里做得比较漂亮的是 Hive 版, 安装配置相当方便, 可以通过其站点 获取 资料。而 OpenWrt 官方也提供编译版 下载。

下面, 就让我们来建立一个 OpenWrt 固件。首先, 显然你已经有一台运行 Linux 的计算机 (什么, 你是 Windows 用户? 那你来看我的博客做什么?), 然后上到 OpenWrt 官网, 下载 源码 (当然也可以使用 SVN)。

OpenWrt 有两个分支, 较新的是 "Kamikaze(神风? 晕)" 版, 另一个是 "whiterussian(白俄罗斯)" 版 下载。这里选用较为稳定的 whiterussian RC6 版本。下面我们开始配置编译。

编译 OpenWrt

下面以我的 ASUS WL-HDD 设备为例, 来讲解 OpenWrt 的编译和配置。

$ wget http://downloads.OpenWrt.org/whiterussian/rc6/whiterussian_rc6.tar.bz2
$ tar -xjf whiterussian_rc6.tar.bz2
$ cd whiterussian_rc6.tar.bz2
$ make menuconfig

接下来会出现配置选单, 大部分的选项使用默认即可。可以酌情修改配置, 一般来说只要不是改得太过分, 生成的固件都是可用的。因为我是 ASUS WL-HDD 的盒子, 所以我主要是在系统中取消了 httpd 服务 (后面会提到我将使用 Eurasia3 应用服务器提供 web 服务), 并且将 IDE 硬盘的支持设置为 "内建 ([*] builtin)" 模式。

1. OpenWrt Package Selection --->
 Busybox Configuration --->
  Networking Utilities --->
   [ ] httpd

2. Kernel Configuration / Device Support --->
 [*] IDE Support, EXT3 filesystem support

USB 支持可以在系统安装好后使用模块加载 资料。

3. Target Root Filesystem --->
 [*] jffs2

这里决定了生成映像文件使用的文件格式, 其中 squashfs 是只读的, jffs2 是可写的, 我们通常选择 jffs2 格式, 以后可以直接读取编辑路由器的 flash 存储器。

配置完成后执行编译。

$ make V=99

当编译完成后, 你可以在 whiterussian_rc6/bin 目录下找到生成的 trx 映像。

比如 OpenWrt-brcm-2.4-jffs2-4M.trx 这个映像, "brcm" 是通用的路由器硬件, jffs2 是文件系统, 4M 是指适用 flash 存储器大小, ASUS WL-HDD/500 的 flash 都是 4M, 适用于这个映像。

Kamikaze 和 Whiterussian 不同, 它生成诸如这样的映像 OpenWrt-brcm47xx-2.6-squashfs-64K.trx, 在硬件型号上可以自由配置。特别诡异的是在 Kamikaze 下 64K 指 4M flash, 而 128K 是指 8M flash 以此类推。

终于, 我们拿到了 trx 映像文件。其中只有 menuconfig 这一步有点工作量。貌似把系统日志部分 (syslogd) 砍掉, 可能会导致路由器重启失败, 需要保留, 其他服务应该都是可以取消的。

至于程序库, 可以等以后手工编译添加进系统。诸如 libpthread、libreadline 这些库是以后运行 Stackless Python 需要的, 对于非常常用的可以编译到镜像里去。

至于OpenWrt SDK 和 Image Builder, 我们在下面的开发中其实并不会用到, 不必选择编译。

在编译过程中, 会去网上拿许多依赖的 package 源码文件。比起 Kamikaze 来, Whiterussian 要下载海量的资源, 如果你网速不够快, 那么可以直接去 OpenWrt 官网上拿 (不推荐, 除非网速真的很慢)。你需要修改 whiterussian_rc6/scripts/download.pl 这个脚本, 清空 "foreach my $mirror (@ARGV) { ... }" 代码块即可。

编译完成以后, 请保留 whiterussian_rc6 目录, 这是我们接下来做交叉编译 (Cross Compiling) 的平台。

使用 OpenWrt

将 OpenWrt trx 映像写入路由器, 你需要 whiterussian_rc6/scripts/flash.sh 这个工具。你也可以从 这里下载这个脚本。

现在将路由器调至回复模式, 计算机和路由器直接使用网线连接, 确信能够 ping 到。作好准备工作。

以我的 ASUS WL-HDD 为例, 连好网线以后, 按住 reset 按钮, 同时插上电源, 黄灯开始规律闪烁即进入 flash 回复模式。接下来确认 WL-HDD 在 192.168.1.1 这个位置 (当然如果你已经设置过 nvram, ip 以 nvram 为准), 如果 ip 不是 192.168.1.1, 你需要先修改 flash.sh 文件中关于 ip 的设定。

$ apt-get install tftp
$ chmod +x flash.sh
$ ./flash.sh OpenWrt-brcm-2.4-jffs2-4M.trx asus

完成 Firmware 上传之后, 程序会回到 shell 下, 等待黄灯熄灭 (即开始更新 Firmware), 再等到 WLAN 绿灯亮起, 此时 Firmware 已经写入机器, 并且机器已经完成重启。恭喜恭喜!

解下来我们可以使用 telnet 192.168.1.1 登录进路由器。进入 Linux Shell 以后, 你可以使用 nvram show/set 命令来显示和设置 nvram, 修改机器 IP 等数据, 重启机器使修改生效。例如:

nvram set lan_ipaddr=192.168.0.2
nvram commit

Whiterussian 启动时加载 IDE 硬盘存在 BUG, 你需要修改 /etc/modules.d/20-ide 文件, 调整内核模块的加载顺序如下:

ide-core
pdc202xx_old
ide-detect
ide-disk

重启以后, ide 硬盘就可以被识别出来了。如果编译进了 fdisk, 那么可以用 fdisk -l 来查看硬盘。

和 OLEG 不同, OpenWrt 不用经过配置就可以使用 /etc/init.d 初始化脚本目录, 在里面添加启动脚本挂载硬盘, 并删掉不喜欢的服务。

#!/bin/sh
# chmod +x /etc/init.d/S90Example
mount /dev/ide/host0/bus0/target0/lun0/part1 /mnt
swapon /dev/ide/host0/bus0/target0/lun0/part2
swapon /dev/ide/host0/bus0/target0/lun0/part3
swapon /dev/ide/host0/bus0/target0/lun0/part4
killall logger
killall syslogd
killall crond
killall klogd

下面使用 free 命令, 看看剩下多少内存留给我们接下来的应用 (果然是寸土寸金啊)。

              total         used         free       shared      buffers
  Mem:        14296         7580         6716            0           56
 Swap:      1572828            0      1572828
Total:      1587124         7580      1579544

这样, 这个 Linux 系统已经可用了。

OpenWrt 下的本地编译环境

在 OpenWrt 下也可以进行本地编译, 你可以 下载 root_fs_mipsel.ext2.bz2 , 并查阅 相关资料。

这里你不必真的在路由器上挂接 root_fs_mipsel.ext2 到文件系统上, 你可以在本地计算机上挂接并拷贝到路由器的 U 盘或者硬盘上。

$ mkdir ~/tmp
$ mkdir ~/tmp/root
$ mount -o loop root_fs_mipsel.ext2 ~/tmp/root
$ cd ~/tmp
$ tar -cjf root_fs_mipsel.tar.bz2 root

然后把 root_fs_mipsel.tar.bz2 拷贝到路由器硬盘上解压缩。

# cd /mnt
# wget http://192.168.x.x/root_fs_mipsel.tar.bz2 # 如果本机有 HTTP 服务, 那么可以通过 wget 从本机上取得文件
# tar -xjf root_fs_mipsel.tar.bz2

这样我们就得到了 /mnt/root 目录, 里面包含了完整的编译环境和需要的库文件。接下来以 /mnt/root 为根 ('/') 目录, 即可使用本地编译环境。

# chroot /mnt/root/ /bin/ash -
# gcc -v
# exit

不过你应该永远避免在路由器上进行本地编译, 首先是速度极慢, 然后诸多依赖也不能满足 (比如 Include 等), 但是这里架设的编译环境也并不是没有用处, 因为在 root_fs_mipsel 的 lib 目录下有许多我们需要的重要的库文件可以直接拿来使用, 省去许多费事的编译。

为 OpenWrt 编译 Stackless Python

很显然, Eurasia3 才是王道。不过这个 Web 应用服务器依赖于 Stackless Python。找了半天, 也只有 Python 的 ipk 包。好吧, 自己编译吧。

除了高度定制, 自己编译 OpenWrt 映像的另一个好处就是交叉编译环境已经准备好了。现在让我们回到 whiterussian_rc6 目录, 来设定交叉编译环境, 很简单, 你只要在你的 PC 中输入下面几条命令。

$ export PATH=/PATH/TO/whiterussian_rc6/staging_dir_mipsel/usr/bin:/PATH/TO/whiterussian_rc6/staging_dir_mipsel/mipsel-linux-uclibc:/PATH/TO/whiterussian_rc6/staging_dir_mipsel/bin:$PATH
$ export AR=/PATH/TO/whiterussian_rc6/staging_dir_mipsel/bin/mipsel-linux-uclibc-ar
$ export AS=/PATH/TO/whiterussian_rc6/staging_dir_mipsel/bin/mipsel-linux-uclibc-as
$ export LD=/PATH/TO/whiterussian_rc6/staging_dir_mipsel/bin/mipsel-linux-uclibc-ld
$ export NM=/PATH/TO/whiterussian_rc6/staging_dir_mipsel/bin/mipsel-linux-uclibc-nm
$ export CC=/PATH/TO/whiterussian_rc6/staging_dir_mipsel/bin/mipsel-linux-uclibc-gcc
$ export CPP=/PATH/TO/whiterussian_rc6/staging_dir_mipsel/bin/mipsel-linux-uclibc-cpp
$ export GCC=/PATH/TO/whiterussian_rc6/staging_dir_mipsel/bin/mipsel-linux-uclibc-gcc
$ export CXX=/PATH/TO/whiterussian_rc6/staging_dir_mipsel/bin/mipsel-linux-uclibc-g++
$ export RANLIB=/PATH/TO/whiterussian_rc6/staging_dir_mipsel/bin/mipsel-linux-uclibc-ranlib
$ export ac_cv_linux_vers=2.4.30
$ export CFLAGS="-Os -s"

现在你的编译环境已经是面向 OpenWrt MIPS 系统的了, 与本地编译唯一的不同, 就是你需要对源代码包的 configure 脚本增加 --host=mipsel-linux 参数。

$ ./configure --host=mipsel-linux
$ make
$ make install

大部分 x86 体系的软件包都可以在交叉编译平台上通过编译。不过 Stackless Python 貌似并不支持 MIPS 体系的计算机, 为此我编写了一个补丁, 你可以访问 这个地址, 将邮件中 "# stackless-2.52.mips.xcompile.patch" 以下部分复制出来保存为 stackless-2.52.mips.xcompile.patch 文件。下面我们就可以编译 Stackless Python 了。

$ wget http://www.stackless.com/binaries/stackless-252-export.tar.bz2
$ tar -xjf stackless-252-export.tar.bz2
$ cat stackless-2.52.mips.xcompile.patch | patch -p0
$ cd python-2.52
$ export CROSS_COMPILE=yes
$ ./configure --prefix=/opt/Stackless-2.5.2 --host=mipsel-linux
$ make
$ make install

现在我们在本机的 /opt 下得到了 Stackless-2.5.2 目录, 打包放到路由器的 /opt 目录下, 我们就可以正常使用 Stackless Python 了。

关于在其他版本的 Stackless Python 里如何 H@ck 代码以支持 MIPS 架构, 请仔细阅读 patch 文件。据 Richard Tew 说他对在 Stackless 中加入 MIPS 支持颇感兴趣, 除非他能跑得过 Python 的开发速度 (这好像有点冷~~`)。很显然 Guido 把 Stackless 拒之门外是一个严重错误, 喂喂, 别再鼓捣 Python 3000 什么拉!

现在登入 WL-HDD, 下载 Eurasia3, 编写一个 Eurasia3 (这里使用 svn 版, 我正准备发布的 alpha4 的原型, alpha2 可以在这里下载) 的测试程序:

# !/opt/Stackless-2.5.2/bin/python2.5
from Eurasia.web import config, mainloop

def controller(client):
 client.write(
  'HTTP/1.0 200 OK\r\n'
  'Content-Type: text\r\n'
  '\r\n'
  'hello world!' )

config(controller=controller,
 port=80)
mainloop()

做了一下小测试, hello world 每秒可以达到 40 个以上的请求数, 尽管比起一台普通的 PC 同样的 Eurasia3 程序慢了几百倍, 但是对于一台嵌入式设备而言, 已是颇令人满意了。

PS:据阿北说他的笔记本是做开发用途, 而不是做了网站, 这里勘下误。

本次发布仍然使用 Python 标准库 asyncore.py 的算法, 优化阶段还未开始, 性能尚待提高。
这里提供部分简单功能的预览, 及简单的基准测试 (Apache ab)。欢迎讨论。

代码一, "hello world!"
-------------------------------------------------------
代码:

#!/usr/bin/env python2.5
#import psyco; psyco.full()

from web import Response, config, poll

def controller(req):
        resp = Response(req)
        resp['Content-Type'] = 'text/plain'
        print >> resp, 'hello world!'
        resp.close()

config(controller=controller, port=8080)
while True:
        poll()

-------------------------------------------------------
基准测试 1:

$ ab -c 1021 -n 10000 'http://localhost:8080/'

Server Hostname:        localhost
Server Port:            8080

Document Path:          /
Document Length:        13 bytes

Concurrency Level:      1021
Time taken for tests:   2.84486 seconds
Complete requests:      10000
Failed requests:        0
Write errors:           0
Total transferred:      1770885 bytes
HTML transferred:       130065 bytes
Requests per second:    4797.35 [#/sec] (mean)
Time per request:       212.826 [ms] (mean)
Time per request:       0.208 [ms] (mean, across all concurrent
requests)
Transfer rate:          829.46 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    1   3.5      1      24
Processing:     9   26   3.4     26     230
Waiting:        7   25   3.4     25     228
Total:         25   27   4.7     27     231

Percentage of the requests served within a certain time (ms)
  50%     27
  66%     27
  75%     27
  80%     27
  90%     28
  95%     28
  98%     45
  99%     50
 100%    231 (longest request)

-------------------------------------------------------
基准测试 2, 使用 psyco.full() 优化:

$ ab -c 1021 -n 10000 'http://localhost:8080/'

Server Hostname:        localhost
Server Port:            8080

Document Path:          /
Document Length:        13 bytes

Concurrency Level:      1021
Time taken for tests:   1.519026 seconds
Complete requests:      10000
Failed requests:        0
Write errors:           0
Total transferred:      1770708 bytes
HTML transferred:       130052 bytes
Requests per second:    6583.17 [#/sec] (mean)
Time per request:       155.093 [ms] (mean)
Time per request:       0.152 [ms] (mean, across all concurrent
requests)
Transfer rate:          1138.23 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    1   4.0      1      25
Processing:    10   18   3.6     19     239
Waiting:        9   17   3.5     17     237
Total:         18   20   5.6     20     241

Percentage of the requests served within a certain time (ms)
  50%     20
  66%     20
  75%     20
  80%     20
  90%     21
  95%     21
  98%     46
  99%     47
 100%    241 (longest request)

代码 2: Eurasia3 自带 Demo
-------------------------------------------------------
启动 demo:
    $ ./demo start

功能:
   使用了逻辑调度器, 每 0.1 秒对协程进行一次调度。
   使用了 session, 在测试中为每个请求建立一份 session (共计 10000 份)。

-------------------------------------------------------
基准测试:

$ ab -c 1021 -n 10000 'http://localhost:8080/'

Server Hostname:        localhost
Server Port:            8080

Document Path:          /
Document Length:        8 bytes

Concurrency Level:      1021
Time taken for tests:   8.923888 seconds
Complete requests:      10000
Failed requests:        0
Write errors:           0
Total transferred:      2521500 bytes
HTML transferred:       80688 bytes
Requests per second:    1120.59 [#/sec] (mean)
Time per request:       911.129 [ms] (mean)
Time per request:       0.892 [ms] (mean, across all concurrent
requests)
Transfer rate:          275.89 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0  252 823.2      5    3011
Processing:   130  186  89.0    170     921
Waiting:      129  182  89.1    165     915
Total:        143  438 877.6    176    3929

$ cat /proc/version
Linux version 2.6.20-16-generic (root@terranova) (gcc version 4.1.2
(Ubuntu 4.1.2-0ubuntu4)) #2 SMP Sun Sep 23 19:50:39 UTC 2007

$ cat /proc/cpuinfo
processor       : 0
vendor_id       : AuthenticAMD
cpu family      : 15
model           : 75
model name      : AMD Athlon(tm) 64 X2 Dual Core Processor 3600+
stepping        : 2
cpu MHz         : 2009.283
cache size      : 256 KB
physical id     : 0
siblings        : 2
core id         : 0
cpu cores       : 2
fdiv_bug        : no
hlt_bug         : no
f00f_bug        : no
coma_bug        : no
fpu             : yes
fpu_exception   : yes
cpuid level     : 1
wp              : yes
flags           : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge
mca cmov pat pse36 clflush mmx fxsr sse sse2 ht syscall nx mmxext
fxsr_opt lm 3dnowext 3dnow pni cx16 lahf_lm cmp_legacy svm cr8legacy
ts fid vid ttp tm stc
bogomips        : 4021.64
clflush size    : 64

processor       : 1
vendor_id       : AuthenticAMD
cpu family      : 15
model           : 75
model name      : AMD Athlon(tm) 64 X2 Dual Core Processor 3600+
stepping        : 2
cpu MHz         : 2009.283
cache size      : 256 KB
physical id     : 0
siblings        : 2
core id         : 1
cpu cores       : 2
fdiv_bug        : no
hlt_bug         : no
f00f_bug        : no
coma_bug        : no
fpu             : yes
fpu_exception   : yes
cpuid level     : 1
wp              : yes
flags           : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge
mca cmov pat pse36 clflush mmx fxsr sse sse2 ht syscall nx mmxext
fxsr_opt lm 3dnowext 3dnow pni cx16 lahf_lm cmp_legacy svm cr8legacy
ts fid vid ttp tm stc
bogomips        : 4018.57
clflush size    : 64

点击图片弹出文件浏览框, 选择文件点击确定便立即上传文件 ── 这被认为是一种不可能实现的技术。因为本博是变态的, 所以这里当然要讲解一下了。不过江湖凶险, 本博还是建议大伙不要轻易尝试。

好了, 下面我们就根据这张例图, 从左到右一步一步地讲解。

第一步, 找一张很帅很帅的图片

我们需要一张很帅的图片作为上传按钮, 这是所有步骤中最关键和最为困难的一步。花了九牛二虎之力, 在下终于找到了一张举世无双的帅气图片 (见上面的例图), 无疑我们已经成功了 99%。

第二、第三、第四步

使用浮动层把透明的文件上传控件 (的按钮部分) 覆盖到图片上。这样用户去点图片, 其实点到的是文件上传控件的 "浏览按钮"。这样, 用户的感觉好像是点击了这个图片才弹出文件选择框的。

设定文件上传控件的 onchange 事件, 实现选定文件立即上传

设置文件上传控件的 "onchange" 事件, 立即调用文件上传表单 (form) 的 "submit()" 方法。这样用户使用文件选择框选择好文件, 单击确定, 文件上传过程就立即开始了。

使用透明文件上传按钮盖住图片的关键

• 我们只需要文件上传控件的按钮部分, 如果无法隐藏文件上传控件左半边的字符输入框部分, 就把他移出屏幕。
• 如果文件上传控件不够大, 不能完全覆盖图片, 就修改控件的字体大小, 增加 font-size 就可以搞大文件上传控件按钮的大小。
• 如果还是不够大, 就用两个文件上传控件来覆盖图片。

当然上述技巧都相当地恶心。这也是博主忠告诸位不要轻易尝试的原因。

代码

<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>upload.html, 一个文件上传按钮, 用于 iframe 嵌入</title>
<script language="JavaScript">
window.do_upload = function(n) {
 if(document.getElementById('upload').value == '')
  return;

 document.getElementById('upload_display').style.display = 'none';
 document.getElementById('uploading').style.display = '';

 var l = filename.split(/[\/\\]/), filename = l[l.length - 1];

 // TODO: 本窗口将被用于提交文件,
 //  请在父窗口 ( window.parent) 再生成一个文件上传按钮

 document.forms[n].submit();
};
</script>
</head>
<body style="padding: 0px; margin: 0px; vertical-align: middle; text-align: center;">
<span id="upload_display">
<img src="http://9.douban.com/mpic/s2356949.jpg"
 style="position: absolute; left: 0px; top: 0px;"/>
<form action="upload.cgi" method="post" enctype="multipart/form-data">
 <input id="upload" name="upload" type="file" onchange="do_upload(0)"
  style="position: absolute; top: 0px; font-size: 44px; left: -640px; -moz-opacity:0; filter:alpha(opacity: 0); opacity: 0;" />
<form action="upload.cgi" method="post" enctype="multipart/form-data">
 <input id="upload" name="upload" type="file" onchange="do_upload(1)"
  style="position: absolute; top: 60px; font-size: 44px; left: -640px; -moz-opacity:0; filter:alpha(opacity: 0); opacity: 0;" />
</form>
</span>

<span id="uploading" style="display: none; font-size: 12px; color: #961;">uploading ...</span>

</body>
</html>

最后一步, 使用 iframe 在需要上传的地方嵌入这个页面

<iframe src="upload.html" border="0" frameborder="no" style="width: 124px; height: 124px;"></iframe>

好了, 不要误会, 我不是在线看的意思。目前流量还不算太便宜 (昨天刚充了 100￥ 今天又欠费了 ……)。

今天我们只需要简单地把土豆网的视频下载下来, 然后用手机来看就可以了。

首先安装 ffmpeg

1. 安装编译环境

sudo apt-get install build-essential
sudo apt-get install dpkg-dev libimlib2-dev texi2html liblame-dev libfaad2-dev libmp4v2-dev libfaac-dev libxvidcore4-dev debhelper libogg-dev libvorbis-dev liba52-dev libdts-dev libsdl1.2-dev libraw1394-dev libdc1394-13-dev libtheora-dev libgsm1-dev

2. 得到 ffmpeg 源码

cd /usr/local/src # 任意你喜欢的目录
apt-get source ffmpeg
cd ffmpeg-0.cvs20060823

3. 下载 amr 支持

wget http://www.3gpp.org/ftp/Specs/archive/26_series/26.204/26204-510.zip
wget http://www.3gpp.org/ftp/Specs/archive/26_series/26.104/26104-510.zip

解压缩 26204-510.zip 把里面的文件放到 libavcodec/amrwb_float 目录下。
解压缩 26104-510.zip 把里面的文件放到 libavcodec/amr_float 目录下。

4. 编译 ffmpeg

在此之前, 你可能需要把原来的 ffmpeg 包卸载掉。

./configure --prefix=/usr --enable-gpl --enable-shared --enable-mp3lame --enable-amr_nb --enable-amr_wb --enable-amr_if2 --enable-libogg --enable-vorbis --enable-xvid --enable-a52 --enable-a52bin --enable-faadbin --enable-dts --enable-pp --enable-faad --enable-faac --enable-x264 --enable-pthreads --disable-ffserver
make
make install

ffmpeg 是手机视频的关键, 请务必搞定本步骤再继续。

一个下载土豆网在线视频的工具

1. 大喊三声 "感谢 Yi.Huang 大师"

大师 Yi.Huang 是上帝派来拯救人类的, 这是他的神迹之一 ……

2. 下载某种工具

wget http://huangyilib.googlecode.com/svn/trunk/tudou_dl.py

3. 现在你已经可以下载土豆网的视频到本地来了

假如 http://www.tudou.com/programs/view/AmYV7YnHqBU/ 是视频地址, 那么

python tudou_dl.py http://www.tudou.com/programs/view/AmYV7YnHqBU/

这样你就可以得到视频的下载地址, 然后你就可以把它下载下来了。

他是一个 flv 格式的视频文件。

把 flv 转换成手机的 3gp 格式

1. 你可以执行命令

ffmpeg -i 输入文件.flv -s 176×144 -vcodec h263 -r 25 -b 200 -ab 64 -acodec aac 输出文件.3gp

请注意其中的 "-acodec aac" 参数这是以 aac 编码声音。这适合我的 Nokia 5300 手机。你也可以使用 "-acodec mp3" 这个参数 (在 Nokia 5300 中使用该参数无法正常播放声音)。

2. 你还可以 ……

下载这个脚本

wget http://blog.fakap.net/mp3toflv/flvto3gp.sh

不过这个脚本输出的 3gp 视频也可能存在声音不正常的情况, 你可以手工修改下面这行代码的声音参数:

ffmpeg -i $1 -s 176×144 -vcodec h263 -r 25 -b 200 -ab 64 -acodec mp3  -ac 1 -ar 8000 $1.3gp

"-acodec mp3 -ac 1 -ar 8000" 这三个是声音参数。你可以只设定 -acodec XXX。

我准备抽空把事情搞得更好玩一些

1. 很显然, 我们需要一个 GUI 来自动化一切。

2. 我们需要支持更多的在线视频网站, 并且持续跟踪。
在线视频网站可能会试图通过修改视频下载策略来避免被用户下载, 但是这对任何一个 Python 玩家来讲都是徒劳的。相对于某些人的举手之劳而言, 网站的更动成本就太高了。

3. 或许我还会考虑一下 Windows 用户。

相关链结:Eurasia3 Pre Alpha! (Eurasia3 Alpha 版预发布)

# server.py
while True:
   continue

好了现在我们已经有了一个服务器了, 接下来要做的事情就是让他跑到后台去。






第一章, 原理

本章仅作了解就可以了, 因为这些细节性的东西实在是无聊,
所以我强烈推荐你直接跳到第二章。

   当然, 如果你有足够的耐心和能力, 还是看下去吧 ……

通常我们把后台进程叫做 "守护进程"、"精灵进程", 或者 daemon。
在 Unix 下, 我们使用 fork 实现。

   import os
   def daemonize():
      # 首先 fork 出两个进程
      pid = os.fork()

      # pid 非零的是父进程,
      # 父进程就是你用命令启动的那个程序。
      #
      if pid != 0:
         # 接着我们退出父进程
         # 这样你的命令行程序就退出了。
         #
         # 父进程退出后, 子进程就被系统托管了
         # 这时子进程就转入后台执行
         os._exit(0)

      # 子进程开始
      # 我们在这里启动后台程序 (服务器)
      os.system('python server.py')
      # 当然, 你永远不会使用 os.system 来启动一个程序
      # os.system 会启动 python、server.py 还有你不希望看到的 sh 进程

当然, 真正能用的 daemonize 程序还要作更多的事情,
这些都被记载在典籍《Unix 高级环境编程》中。

我归纳了一下, 分别是一下几个方面。

   1. 切换程序的身份。
      请看 Apache 的设计, 在使用 root 得到 80 端口后旋即转换成 nobody (www-data) 用户。
      很明显, 使用 root 身份执行一个程序是危险的, 后台程序的身份不应该是 root。

         最实用的选择是: 当配置文件里没有说明以何身份执行时,
         就以当前用户的身份启动后台进程。

   2. 自定义部分信号处理程序。

         如果不是必须, 依我看还是不要做太多信号处理,
         否则你的服务器很可能将只能吃到 kill -9 才可退出了, 这显然很蠢。
      如果你不想看到太多的 undead, 处理 SIGCHLD 是必须的。

   3. 重定向 stdin、stdout 和 stderr。
      标准输入输出对 daemon 进程而言没有意义, 因为后台进程是没有终端可供使用的。

         注意, 这里是重定向而不是关闭, 这样可以避免程序在 print 的时候出错。

         我们通常会将 stdout、stderr 重定向到日志文件。
         /dev/nul 是选择之一。
         stdin 是没有意义的。

   4. setsid(), umask(), chdir() 逐一 google。这里不赘述了。

   5. 把 pid 写到 xxx.pid 文件中去。
      当我们需要结束后台进程的时候, 我们就可以从 pid 文件中得到子进程的 pid,
      然后 kill PID。

目前, Python 最好的 Daemon 库依然是 Zope 的 zdaemon,
欲了解健壮的 Daemon 实现, 可以阅读 zdaemon 的源代码。
当然, 阅读 zdaemon 源码是比较痛苦的, 我自己也比较痛恨 zdaemon 的编码风格。

   我痛恨一切没有必要的, 过度的 OO 设计。

zdaemon 的贡献是它引入了 "进程控制器" 这个概念, 它的 daemonize 使用了两次 fork。

   # zdaemon.py
   import os
   def zdaemonize():
      # 首次 fork, 进入后台
      pid = os.fork()

      if pid != 0:
         os._exit(0)

      # 第二次 fork
      pid = os.fork()

      # 父进程, Daemon 管理器
      if pid != 0:
         # 启动进程管理器服务器
         # 这里, manager_server 是假想的
         import manager_server
         manger_server.serve_forever()

      # 子进程, 启动后台服务
      os.system('python server.py')

进程管理器 manger_server 通常是一个 TCP 服务, 他使用 Unix Socket 与外界交互。
这样, pid 文件就变成了 Unix Socket 文件。
你通过 Unix Socket (TCP Socket) 接口对进程管理器发送控制指令,
比如 'start'、'status' 和 'stop',
进程管理器再对他的子进程 (后台守护进程) 发送控制信号, 启动或者关闭守护进程。

通过进程管理器, 后台进程的控制就和后台进程的运行逻辑分开了。

zdaemon 也有一个致命缺点, 其过度对象化的设计, 使封装层次失控,
加上采用了底层的 Unix Socket, 使其代码量过度膨胀。

   人类能够理解的代码行数是有限制的。
      －－《Unix 编程艺术》

   所以 Python 的语法决定了 Python 能够编写出目前最复杂的程序。
   代码量失控是 Python 的最大敌人, 这说明我们可能正在用 Java 写 Python。

为此我修改了 zdaemon, 将它实现在 270 行代码中。
用 Local XMLRPC Server (Unix Socket) 取代 zdaemon 的 Socket 底层,
为我赢得了不少行数。

同样, 在编写 Local XMLRPC Server 的时候, 再次遇到 Python 标准库 SimpleXMLRPCServer.py
的过度封装问题, 有兴趣的话大家可以阅读第三章 Local XMLRPC Server 的实现部分,

   过度向对象实际上就是完全无法重用, 这是一个典型的例子。

使用 XMLRPC Server 的额外好处,
就是让我们可以更方便地增加除了 start、stop、status 这种控制命令。

   daemon = Daemon(...)
   daemon.register_function(...)

   不过, 额外的控制命令, 通常是不需要的。

我的 daemon 程序 (daemon.py) 源码放在第三章中,
同样, 阅读源码是一件枯燥的事情, 你可以忽略掉第三章。
但是第二章是必须理解的。






第二章、使用 daemon.py 的通用范例
   你可以不用修改就用于你的项目

#!/usr/bin/env python2.5
# -*- coding: utf-8 -*-

import os, sys
from os import fork
from time import sleep
from sys import stderr, stdout
from socket import error as SocketError
from traceback import print_exc

import schema # 载入配置信息, 还记得《配置文件》一招鲜吗?
import pyetc  # ... 要不要复习一下 :)

from daemon import Daemon, ServerProxy, Fault, \
   error as DaemonError

## #

def usage():
   print '使用方法: %s start|stop|status' %sys.argv[0]

def start():
   # 读取配置文件
   # demo.conf
   pyetc.load(schema.ETC('demo.conf'), env=schema.env)
   conf = schema.config.daemon
   # ... 请见《配置文件一招鲜》最后一个范例

   try:
      # 创建 Daemon 对象
      daemon = Daemon(
         address = conf.address, # 进程控制器地址/pid 文件位置
         program = conf.program, # 后台进程程序位置
         verbose = conf.verbose  # 调试
         )

      print '进程管理器已经启动'

      # 启动后台进程
      #    daemon(arg1, arg2, ...)
      #    参数 arg1, arg2 ... 将被用于启动后台进程,
      #    这里相当于命令行:
      #       program.py arg1 arg2 ...
      daemon()

   except DaemonError, msg:
      print '进程管理器未启动, 原因是: ', msg

   except:
      print_exc(file=stderr)

def stop():
   pyetc.load(schema.ETC('demo.conf'), env=schema.env)
   conf = schema.config.daemon

   # 取得进程控制器
   try:
      daemon = ServerProxy(conf.address)
      daemon.stop()

      print '进程已经退出'

   except SocketError:
      print '进程管理器未启动'

   except Fault:
      print '进程管理器已被强制关闭'

   except:
      print_exc(file=stderr)

def status():
   pyetc.load(schema.ETC('demo.conf'), env=schema.env)
   conf = schema.config.daemon

   try:
      daemon = ServerProxy(conf.address)
      status = daemon.status()

      if status == 'running':
         print '进程 "%s" 正在运行' %conf.program

      elif status == 'stopped':
         stdout.write( ('进程管理器正在运行, 但是进程 "%s" 已经停止, '
            '正在停止进程管理器 ... '
            ) %conf.program )

         stop()

      else:
         print '进程管理器正在运行, 进程状态未知'

   except SocketError:
      print '进程管理器未启动'

   except:
      print_exc(file=stderr)

## #

# 解析参数

if len(sys.argv) != 2:
   usage()

elif sys.argv[1] == 'start':
   start()

elif sys.argv[1] == 'stop':
   stop()

elif sys.argv[1] == 'status':
   status()

else: usage()






第三章、附件: daemon.py

import os, sys
from httplib import HTTP, HTTPConnection
from pwd import getpwnam, getpwuid
from signal import signal as setsignal, SIGCHLD, SIGTERM
from sys import stderr, stdout
from urllib import urlopen
from SocketServer import UnixStreamServer
from socket import socket, error as SocketError, \
   AF_UNIX, SOCK_STREAM
from SimpleXMLRPCServer import SimpleXMLRPCDispatcher, \
   SimpleXMLRPCRequestHandler, SimpleXMLRPCServer
from xmlrpclib import Fault, Transport, dumps as xmlrpc_dumps, \
   _Method as _XMLRPCMethod, ServerProxy as ServerProxy_N___G
from os import execv, chdir, chmod, fork, geteuid, getpid, \
   kill, setgid, setuid, umask, unlink, waitpid, \
   error as OSError, WNOHANG

class error(Exception): pass

class nul:
   write = staticmethod(lambda s: None)
   flush = staticmethod(lambda  : None)
   read  = staticmethod(lambda n: ''  )

class UnixStreamXMLRPCServer(UnixStreamServer, SimpleXMLRPCDispatcher):
   def __init__(self, address, requestHandler=SimpleXMLRPCRequestHandler,
      allow_none=False, encoding=None):

      self.logRequests = False

      SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
      UnixStreamServer.__init__(self, address, requestHandler)

class Daemon:
   def __init__(self, **args):
      address      =           args[ 'address'             ]
      allow_none   =       args.get( 'allow_none', True    )
      encoding     =       args.get( 'encoding'  , 'utf-8' )

      self.verbose =       args.get( 'verbose'   , False   )
      self.stdout  =       args.get( 'stdout'    , nul     )
      self.stderr  =       args.get( 'stderr'    , nul     )

      try:
         ServerProxy(address).ping()
      except SocketError:
         pass
      else:
         raise error, 'Another daemon is already up using socket %s' %repr(address)

      if isinstance(address, str):
         try:
            unlink(address)
         except OSError:
            pass

         self.manager = UnixStreamXMLRPCServer(address,
            allow_none=allow_none, encoding=encoding)

         self.pidfile = address
      else:
         self.manager = SimpleXMLRPCServer(address,
            allow_none=allow_none, encoding=encoding)

      self.pid     = None
      self.running = True

      self.program       =     args[ 'program'             ]

      DaemonizeTools.setuid(
         user       = args.get( 'user'      , None    )  )

      SignalTools.setsignals(self)

      DaemonizeTools.daemonize(
         directory  = args.get( 'directory' , None    ),
         umask      = args.get( 'umask'     , 022     )  )

      self.register_function = lambda *args: (
         self.manager.register_function(*args) )

      self.register_function(lambda: self.stop()  , 'stop'  )
      self.register_function(lambda: self.status(), 'status')
      self.register_function(lambda: True         , 'ping'  )

   def __call__(self, *args):
      if not self.verbose:
         DaemonizeTools.close_files(self.stdout, self.stderr)
         del self.stdout, self.stderr

      pid = fork()

      if pid != 0:
         self.pid = pid
         while self.running:
            self.manager.handle_request()

         return pid

      else:
         try:
            for i in xrange(3, 100):
               try:
                  os.close(i)
               except OSError:
                  pass

            try:
               execv(sys.executable, tuple(
                  [sys.executable, self.program] + list(args) ) )
            except OSError, err:
               print >> stderr, ( 'can\'t exec %r: %s\n'
                  % (self.program, err) )

         finally:
            os._exit(127)

   def status(self):
      if not self.pid:
         return 'stopped'
      else:
         return 'running'

   def stop(self):
      if not self.pid:
         self.running = False
         if hasattr(self, 'pidfile'):
            try:
               unlink(self.pidfile)
            except OSError:
               pass

         raise error, 'no subprocess running'

      kill(self.pid, SIGTERM)
      self.running = False
      if hasattr(self, 'pidfile'):
         try:
            unlink(self.pidfile)
         except OSError:
            pass

class UnixStreamHTTPConnection(HTTPConnection):
   def connect(self):
      self.sock = socket(AF_UNIX, SOCK_STREAM)
      self.sock.connect(self.host)

class UnixStreamHTTP(HTTP):
   _connection_class = UnixStreamHTTPConnection

class UnixStreamTransport(Transport):
   def make_connection(self, host):
      return UnixStreamHTTP(host)

class UnixStreamServerProxy_NG:
   def __init__(self, uri, transport=None, encoding=None, verbose=0,
      allow_none=0, use_datetime=0):

      self.__host = uri
      self.__handler = '/RPC2'

      if not transport:
         self.__transport = UnixStreamTransport(use_datetime=use_datetime)

      self.__encoding = encoding
      self.__verbose = verbose
      self.__allow_none = allow_none

   def __request(self, methodname, params):
      request = xmlrpc_dumps(params, methodname, encoding=self.__encoding,
         allow_none=self.__allow_none)

      response = self.__transport.request(
         self.__host, self.__handler, request,
         verbose=self.__verbose )

      if len(response) == 1:
         response = response[0]

      return response

   def __getattr__(self, name):
      return _XMLRPCMethod(self.__request, name)

def ServerProxy(address, **args):
   if isinstance(address, str):
      return UnixStreamServerProxy_NG(address, **args)

   else:
      host, port = address
      host = (host, '127.0.0.1')[host == '0.0.0.0']
      return ServerProxy_N___G('http://%s:%d' %(host, port), **args)

class DaemonizeTools:
   @staticmethod
   def setuid(**args):
      user = args['user']
      if user is None:
         return

      try:
         uid = int(user)

      except ValueError:
         try:
            pwrec = pwd.getpwnam(user)
         except KeyError:
            raise error, 'username %r not found' % user

         uid = pwrec[2]

      else:
         try:
            pwrec = pwd.getpwuid(uid)
         except KeyError:
            raise error, 'uid %r not found' % user

      euid = geteuid()
      if euid != 0 and euid != uid:
         raise error, 'only root can change users'

      setgid(pwrec[3])
      setuid(uid)

   @staticmethod
   def daemonize(**args):
      pid = fork()
      if pid != 0:
         os._exit(0)

      if args['directory']:
         try:
            chdir(args['directory'])
         except OSError, err:
            print >> stderr, ( 'can\'t chdir into %r: %s'
               % (args['directory'], err) )
         else:
            print >> stderr, ( 'set current directory: %r'
               % args['directory'] )

      os.setsid()
      umask(args['umask'])


   @staticmethod
   def close_files(stdout, stderr):
      os.close(0)
      sys.stdin = sys.__stdin__ = nul
      os.close(1)
      sys.stdout = sys.__stdout__ = stdout
      os.close(2)
      sys.stderr = sys.__stderr__ = stderr

class SignalTools:
   daemon = None

   @staticmethod
   def setsignals(daemon):
      SignalTools.daemon = daemon
      setsignal(SIGCHLD, SignalTools.sigchild)

   @staticmethod
   def sigchild(sig, frame):
      try:
         pid, sts = waitpid(-1, WNOHANG)
         if pid == SignalTools.daemon.pid:
            SignalTools.daemon.pid = None

      except OSError:
         return 

毫无疑问, 你需要配置文件。据说配置文件能让你的系统变得可定制。
让系统变得可定制, 有三大思潮, 这决定了三种配置文件的格式:

      1. 图形界面配置工具。

         微机和 Windows 开始流行之后, 我们的用户再也不是黑客了,
         或许你的用户永远不会打开你的配置文件, 你需要给他一个图形工具, 并且帮他换尿布。

         在人类永远不会阅读配置文件的情况下, 让系统变得更简洁的方法就是使用
         机器最容易理解的格式来存储配置, 通常这是一个二进制文件。
         Pickle 是 Python 中的典型选项。

         几十年后, 有人开始以为使用机器和人都能理解 (或者都不能理解) 的格式是一个好主意, 这样就有了 XML。
         在这里, 我只想告诉大家:

               XML 确实是好东西, 但是在绝大多数情况下你其实并不真的需要他。

         而在 Zope/Plone 中, 配置被大规模地保存在 ZODB 数据库中。

         这样就产生了第一种配置文件类型, 他是人类不可读的。

      2. 常规格式的配置文件, 有著名的 httpd.conf 和 INI 等。

         基本上, INI 很弱, 而且 INI 的支持库并没有提供诸如值验证甚至设置变量默认值的功能,
         因此, 除非项目非常小你不应该使用 INI 格式。

               而在任何时候都不使用 INI 格式, 有助于你养成良好的习惯。

         httpd.conf Like 的配置文件, 是配置文件格式的巅峰之作。
         在 Python 中 ZConfig (位于 Zope2/Zope3 中) 提供了对于此种格式的支持。

         我这里有一份入门简介:
            http://eishn.blog.163.com/blog/static/65231820069310828642/

         它只是入门介绍, 你需要阅读文档、源码或者范例才能完全了解 ZConfig 的工作方式。
         尽管并不容易, 但是理解 ZConfig 会帮助你快速掌握配置文件的设计哲学。

         常规的配置文件设计和解析过于复杂, 因此你可以仅作了解。

      3. 使用 Python 本身来作为配置文件。

         Why not? 目前有许多 C 程序正在使用 Python 作为配置文件,
         而 Lighttpd 的配置文件也已经八九不离十了。

         这里是一个例子:

               # demo_conf.py
               # 配置文件
               host = '127.0.0.1'
               port = 8080

               # demo.py
               import demo_conf
               print demo_conf.host, demo_conf.port

         利用 Python 脚本作为配置文件, 在程序实现上简单, 无须格式转换, 而且功能强大。
         这个方案已经开始向传统的配置文件格式宣战。

         最后我修改了原定准备介绍 ZConfig 的计划, 今天着重来介绍这个方案。


下面, 就让我们来设计自己的配置文件格式。

要搞清楚如何设计一个配置文件, 我们首先需要搞清楚系统中有哪些数据类型是需要配置的,
并且弄清楚他们在多大程度上是可以配置的。

根据经验, 一个系统中可以定制的数据有三种:

      1. "静态" 数据, 在 C 语言中, 是用 #define 定义的。
         此类数据仅在开发期具有动态性, 一旦系统完成开发, 此类数据就是静态的。
         此类数据的变化频率最低。

         Python 程序员通常将变量名大写, 并且放在 "config.py" 中, 
         通过 import config 导入使用。

      2. "默认" 配置, 这是项目配置部分最大的乱源。
         默认配置是一种用户可以在配置文件中修改的数据, 他们不是必须的, 他们有默认值。

         你很快就会发现许多 "默认" 配置实际上用户永远不会去修改他,
         在这种情况下, 这些默认配置实际上是上面所说的 "静态" 数据, 应该写入 "config.py"。
         而另一些则是常用配置, 只是带有默认值而已, 这些数据应该写入 "etc" 配置文件中。

         显而易见, 一个变量不能同时存在于 config.py 和 etc 配置文件中。
         问题在于搞清楚一个变量是属于 "静态" 数据还是 "默认" 配置是困难和不确定的。
         这最终导致你的配置文件定义朝令夕改, 而你的项目则风雨飘摇。

      3. 配置项, 毫无疑义地应该放在配置文件中。在系统投入使用后, 这是变化频率最高的数据类型。

         在配置文件中, 你又将面临另一大挑战, 就是变量类型验证。
         变量类型验证之所以讨厌, 就是因为你要同时判断一个配置变量是否存在、类型是否匹配或者是否越界,
         并且是否给以默认值。最后最糟糕的是你还需要回答一个问题:

               默认值是否需要写在配置文件中。

为了解决所有这些问题, 人们发明了 Schema。
和传统配置文件不同, 使用 Python 作为配置文件, Schema 的编写具有相当大的灵活性。
而且 Schema 能帮助你把 Python 格式的配置文件变得更加可读。
下面我就演示一下在 Python 作为配置文件格式时 Schema 的写法。

      # /PATH/TO/ETC/demo_conf.py
      # 配置文件

      import schema

      Server(
            host = '127.0.0.1',
            port = 8080
      )

      # -EOF-



      # /PATH/TO/ETC/schema.py
      #

      config = {}

      def Server(**args):
            config['host'] = args.get('host', '0.0.0.0') # 有默认值

            try:
                  config['port'] = int(args.get('port', 8080)) # 带验证
            except ValueError:
                  raise ValueError, '你必须是整型'

      # -EOF-



      # /PATH/TO/BIN/demo.py
      #

      import sys
      sys.path.append(r'/PATH/TO/ETC')

      import schema, demo_conf
      print schema.config['host'], schema.config['port']

      # -EOF-

好了, 接下来我们需要把 demo_conf.py 变得更像一个配置文件,
因为 "import schema" 不像是一个配置文件中应该有的东西, 我们要让 "Server" 成为预导入的变量。
最后, 我们还要把 demo_conf.py 变成 demo.conf。

这样继 PyQt4 一招鲜之后, 我们又要再次接触到自定义导入技术。
这次我们将使用类似的技术, 也是一个导入钩子 (hook), 不同的是, 这次我们不将钩子挂接到 Python 解释器。


################################################################## # -BOF-
# pyetc.py

# Python 格式的配置文件支持库
#
import sys, os.path

Module = type(sys) # 故技重演
modules = {}       # 缓存已经导入的 etc (配置) 模块


# 导入任意符合 Python 语法的文件
# 用法:
# module = pyetc.load(完整文件路径并包含扩展名, 预载入变量, 自定义返回模块类型)
#
def load(fullpath, env={}, module=Module):
      try:
            code = open(fullpath).read()
      except IOError:
            raise ImportError, 'No module named  %s' %fullpath

      filename = os.path.basename(fullpath)

      try:
            return modules[filename]
      except KeyError:
            pass

      m = module(filename)
      m.__module_class__ = module
      m.__file__ = fullpath

      m.__dict__.update(env)

      exec compile(code, filename, 'exec') in m.__dict__
      modules[filename] = m

      return m

# 移除已经导入的模块
# 用法:
# module = unload(module)
#
def unload(m):
      filename = os.path.basename(m.__file__)
      del modules[filename]

      return None

# 重新导入模块
# 用法:
# module = pyetc.reload(module)
#
def reload(m):
      fullpath = m.__file__

      try:
            code = open(fullpath).read()
      except IOError:
            raise ImportError, 'No module named  %s' %fullpath

      env = m.__dict__
      module_class = m.__module_class__

      filename = os.path.basename(fullpath)
      m = module_class(filename)

      m.__file__ = fullpath
      m.__dict__.update(env)
      m.__module_class__ = module_class

      exec compile(code, filename, 'exec') in m.__dict__
      modules[filename] = m

      return m

################################################################## # -EOF-


下面就让我们来尝试一下。

      # /PATH/TO/ETC/demo.conf
      # 配置文件

      host = '127.0.0.1'
      port = 8080

      # -EOF-



      # demo.py
      import pyetc
      conf = pyetc.load(r'/PATH/TO/ETC/demo.conf')

      print conf.host, conf.port
      # -EOF-


最后是一个较为完整的例子:

      # /PATH/TO/ETC/demo.conf
      # 服务器选项
      #

      Server(
            port = 8080 # 监听 8080 端口
      )


      # 进程控制器选项
      #

      Daemon(
            # 使用 Socket 发布进程控制器
            #       address = ('0.0.0.0', 10080),

            # 使用文件发布进程控制器
            address = var('demo.pid'),

            # 服务器进程
            program = bin('server.py'),

            # 调试开关
            verbose = True
      )

      # -EOF-




      # /PATH/TO/BIN/schema.py
      # 路径工具
      import sys, os.path
      DEMO_HOME = r'/PATH/TO/DEMO'

      ETC = lambda filename: os.path.join(DEMO_HOME, 'etc', filename)
      VAR = lambda filename: os.path.join(DEMO_HOME, 'var', filename)
      BIN = lambda filename: os.path.join(DEMO_HOME, 'bin', filename)

      #
      class Config(dict):
            # 可以像属性一样访问字典的 Key
            #       dict.key 等同于 dict[key]

            def __getattr__(self, name):
                  return self[name]

      # 配置默认值
      config = Config({
            'server': Config({
                  'port': 8080 # 服务器使用 8080 端口

                  }),

            'daemon': Config({
                  'address': VAR('daemon.pid'), # pid 文件
                  'program': BIN('server.py' ), # 服务器程序
                  'verbose': True

                  })
      })

      # 配置接口 (不带验证)
      def Server(**args):
            config['server'].update(args)

      def Daemon(**args):
            config['daemon'].update(args)

      # 配置文件 "demo.conf" 可见的变量
      env = {'Server': Server, 'Daemon': Daemon,
            'etc': ETC, 'var': VAR, 'bin': BIN}

      # -EOF-




      # /PATH/TO/BIN/demo.py
      # 这里启动一个 Daemon 管理器,
      # 注意: 这里的 daemon.py 是一个假想库, 无须理会

      import pyetc
      from daemon import Daemon

      def start():
            # 读取配置文件
            # demo.conf
            pyetc.load(schema.ETC('demo.conf'), env=schema.env)
            conf = schema.config.daemon

            # 创建 Daemon 对象
            daemon = Daemon(
                  address = conf.address, # 进程控制器地址/pid 文件位置
                  program = conf.program, # 后台进程程序位置
                  verbose = conf.verbose  # 调试
                  )

            print '进程管理器已经启动'

            daemon()

      if __name__ == '__main__':
            start()

      # -EOF-

第一掌、比尔·云风刚出生便会说话