让Python支持true closure有多难？
只需修改11行代码。

如果你不知道什么是true closure，这里简单解释一下。Python支持lexicalscope：

>>> def add_n(n):
...     def f(m):
...             return n+m
...     return f
>>> add_2 = add_n(2)
>>> add_2(0)
2
>>> add_2(2)
4

f引用了外层函数add_n的局部变量n。有趣的是，f引用n的时候，add_n已经结束，n似乎不存在了。f所以能正常工作，是因为创建它的时候就把n作为f的上下文(closure)保存了下来，并不随add_n结束而消失。
但是，Python的lexical scope和Scheme/Smalltalk/Ruby还有一点区别：不能在内层函数中rebind外层函数的局部变量。
>>> def f():
...     def g():
...             n=1
...     n=0
...     g()
...     return n
...
>>> f()
0

这是因为Python没有变量声明， n=1 自动使n成为g的局部变量，也就无法rebind f中的n了。可以说Python的closure是只读的。如果你听到有人说"Python不支持true closure"，就是指这个。其实，Python VM能够支持true closure。因为，Python支持内层函数看见外层函数的name rebinding:

>>> def f():
...     def g():
...             yield n
...             yield n
...     x = g()
...     n = 0
...     print x.next()
...     n = 1
...     print x.next()
...
>>> f()
0
1

对于Python的closure实现(flat closure)，"外层函数rebind name"和"内层函数rebind name"其实没有区别。我们知道用global关键字可以rebind module scopename。如果增加一个类似的outer关键字，就可以支持rebind outer scope name。真正的限制是Guido不愿意为支持true closure增加关键字。

也可以不增加关键字，而是把global n的语义改为"如果outer scope定义了n，rebind outer scope n；否则rebind module scope n"。简单起见，我没有修改Python的built-in compiler，而是修改了compiler module(用Python实现的Python compiler)。你只需把下面这个patch打到compiler/symbols.py(Python 2.5.1)就可以体验true closure了：

C:\Python\Lib>diff -u compiler/symbols.py.orig compiler/symbols.py
--- compiler/symbols.py.orig    Thu Aug 17 10:28:56 2006
+++ compiler/symbols.py Mon Feb 11 12:03:01 2008
@@ -21,6 +21,7 @@
         self.params = {}
         self.frees = {}
         self.cells = {}
+        self.outers = {}
         self.children = []
         # nested is true if the class could contain free variables,
         # i.e. if it is nested within another function.
@@ -54,8 +55,10 @@
         if self.params.has_key(name):
             raise SyntaxError, "%s in %s is global and parameter" % \
                   (name, self.name)
-        self.globals[name] = 1
-        self.module.add_def(name)
+        if self.nested:
+            self.outers[name] = 1
+        else:
+            self.globals[name] = 1

     def add_param(self, name):
         name = self.mangle(name)
@@ -90,6 +93,8 @@
         """
         if self.globals.has_key(name):
             return SC_GLOBAL
+        if self.outers.has_key(name):
+            return SC_FREE
         if self.cells.has_key(name):
             return SC_CELL
         if self.defs.has_key(name):
@@ -107,6 +112,7 @@
             return ()
         free = {}
         free.update(self.frees)
+        free.update(self.outers)
         for name in self.uses.keys():
             if not (self.defs.has_key(name) or
                     self.globals.has_key(name)):
@@ -134,6 +140,9 @@
         free.
         """
         self.globals[name] = 1
+        if self.outers.has_key(name):
+            self.module.add_def(name)
+            del self.outers[name]
         if self.frees.has_key(name):
             del self.frees[name]
         for child in self.children:

因为我们没有修改built-in compiler，所以程序要写在字符串里，用compiler.compile编译，用exec执行：
>>> from compiler import compile
>>> s = '''
... def counter():
...     n = 0
...     def inc():
...             global n
...             n += 1
...     def dec():
...             global n
...             n -= 1
...     def get():
...             return n
...     return inc, dec, get
... '''
>>> exec compile(s, '', 'exec')
>>> inc, dec, get = counter()
>>> get()
0
>>> inc()
>>> get()
1
>>> dec()
>>> get()
0

后记

1 搞这个东西的缘起是Selfless Python(http://www.voidspace.org.uk/python/weblog/arch_d7_2006_12_16.shtml#e583)。很有趣的bytecode hack，给一个类中的所有函数补上self参数。既然PythonVM支持true closure，能不能用类似的手法让Python支持true closure呢？不过很快就明白这个在bytecode层面不好弄，还是得修改编译器。不过改起来还真是出乎意料地简单。

2 Guido早已明确表示不能改变global的语义（因为会影响现有代码），所以这个只是玩玩而已，不用指望成为现实。当然你可以只发布bytecode，大概还能把反编译器搞挂掉。:-)
3 我可以理解Guido的决定。除非你之前一直在用Scheme，否则我觉得像上面counter例子那种一组共享状态的函数还是写成class为好，至少共享状态是什么一目了然。Lexical scope太implicit，用在开头add_n那种地方挺方便，再复杂就不好了。

又：很抱歉"幕后的故事"拖了这么久。写起来才发现自己还是不懂descriptor。
不过我肯定不会让它烂尾的。

Help on class enumerate in module __builtin__:

class enumerate(object)
 |  enumerate(iterable) -> iterator for index, value of iterable
 |
 |  Return an enumerate object.  iterable must be an other object that supports
 |  iteration.  The enumerate object yields pairs containing a count (from
 |  zero) and a value yielded by the iterable argument.  enumerate is useful
 |  for obtaining an indexed list: (0, seq[0]), (1, seq[1]), (2, seq[2]), ...
 |
 |  Methods defined here:
 |
 |  __getattribute__(...)
 |      x.__getattribute__('name') <==> x.name
 |
 |  __iter__(...)
 |      x.__iter__() <==> iter(x)
 |
 |  next(...)
 |      x.next() -> the next value, or raise StopIteration
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __new__ = <built-in method __new__ of type object at 0xb7f35d20>
 |      T.__new__(S, ...) -> a new object with type S, a subtype of T

#!/usr/bin/env python
d={'a':1,'b':5,'c':4}
print sorted(d.items(), key=lambda (k,v): (v,k))

Help on built-in function sorted in module __builtin__:

sorted(...)
    sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list

2. walk()函数
很好用的一个函数
os.path.walk(rootdir, f, arg)
rootdir是要访问的目录树的根，f是用户定义的函数，arg是调用f时用的一个参数。
对于每一个"walk"过程中遇到的目录directory，设该目录下的文件列表为filelist，walk函数会调用
f(arg, directory, filelist)

函数式编程相关

1.  Mapping
map() 方法对序列中的每个元素调用某个函数，返回新生成的结果序列。
有点类似于Ruby的Array.each do | element |
>>> z = map(len, ["abc", "clounds", "rain"])
>>> z
[3, 6, 4]

2. Filtering
过滤掉满足条件的元素，类似与Array.reject do | element |
>>> x = [5,12,-2,13]
>>> y = filter(lambda z: z > 0, x)
>>> y
[5, 12, 13]

3. List Comprehension
来个复杂的例子
>>> y
[[0, 2, 22], [1, 5, 12], [2, 3, 33]]
>>> [a for b in y for a in b[1:]]
[2, 22, 5, 12, 3, 33]

4. Reduction
先看示例
>>> x = reduce(lambda x,y: x+y, range(5))
>>> x
10
执行的顺序是：首先调用函数处理range(5)前两个值，0 + 1 = 1，然后返回的值1作为x，继续与range(5)的第三个值(2，作为y)。
最后的结果是0+1+2+3+4的值
这个常用来代替for循环

就读取了text变量的内容。
不过这样和直接用text变量有什么区别呢？貌似"<!--%s-->" % text也可以啊
水木上问了一下，得到的答案是
发信人: Essien5 (宝贝晶~), 信区: Python
标  题: Re: 关于locals()的用处
发信站: 水木社区 (Thu Aug  2 11:16:37 2007), 转信

好处就是多个变量是代码很好维护，一一对应
'%s%s.......%s'%(a,b,c,d,....,z)
'%(a)s%(b)s......%(z)s'%locals()
第一种写法前面的%s和后面的变量很难对应起来，bug的源泉
后一个就非常直观了
而且要往中间再随便插变量也方便

2. 自己的类继承了SGMLParser后，需要对特殊标记处理，可以以start_或do_开始命名相关函数。
可以这样做的原因在于python的自醒机制(introspection)

就国内目前引进的唯一一本算是讲Ruby的书，要从这本书开始学习Ruby估计会吓跑不少潜在用户。作者是大牛没错，不过教学则是另一回事了（大家都应有体会，本科上课的时候课讲的最好的老师通常都不是学术最牛的老师）。缺点有两处很明显：

第一是自顶向下，它的顺序是这样的：

对象和类–>容器、集合–>标准类型–>表达式–>异常和模块–>基本输入输出

一个从上降到低又陡然上升的过程。作者自己也说在第一版里这样的效果并不好，因此在第二版里特意增加了一个介绍性章节，粗略的先把所有东西列给读者看一遍。虽然起到些作用，但是实际效果我想对于初学者来说仍然不会太好。C++/Java的书我都读过不少，也没见哪个是一上来就把Class/Object这些东西甩给读者的，总是从基本类型、控制语句过渡。除非你已经对OO这套相当熟悉了，否则上来这个门槛就能把一堆新手挡在门外。

接下来的，谈不上十分晦涩，但也不是什么读来轻快的内容，关键是作者给的例子较少，使得象块、迭代这些特色难以掌握。再有一点，ruby的语法风格有相当部分还保留有Perl的痕迹，而Perl是出了名的以奇怪符号著称于世，这些符号在新手眼里不外天书，而高手们则爱不释手。

所以，要能比较顺利的通过这本书的入门之路，你得事先具有OO的基础，至少一门脚本语言的经验（Perl最佳），函数式编程的一些概念（否则当你看到块的一些用法时会很迷惑）。然后，可以用Ruby笨拙的写一些小程序了。

Ruby作为动态语言之一，它的最大特点自然是“动态”两个字，其著名的“duck typing”就是一大体现（在我看来，就像是基于接口的调用，但却并不用一个给定的接口去事先限制）。这些在高级部分里都有专门讲述，是应该重点学习的部分。

那么入门究竟用什么书更好？我推荐《Everyday Scripting with Ruby》这本。和《Programming Ruby》同一个出版社，今年一月份刚出了原版。它是以相当循序渐进的方式带领读者进入Ruby的世界，尤其是作者精心设计的几个Project是全书亮点（学习一门语言最好的方式还是要动手写程序）。

最后总结如下，首先看《Everyday》这本书，跟着书中的指导摆弄过所有的Project，并完成相应的练习。然后再看《Programmin》一书的Crystallized部分。再之后就主要是当作API参考手册了。花钱去买中文版我个人觉得不是很有必要，总共四部分中，前两部分我觉得蛮鸡肋的，第四部分在电脑上查更方便，只有第三部分有较高的价值。

2. String#chomp 方法
str.chomp(separator=$/) => new_str
Returns a new +String+ with the given record separator removed from
the end of _str_ (if present). If +$/+ has not been changed from
the default Ruby record separator, then +chomp+ also removes
carriage return characters (that is it will remove +\n+, +\r+, and
+\r\n+).

"hello".chomp #=> "hello"
"hello\n".chomp #=> "hello"
"hello\r\n".chomp #=> "hello"
"hello\n\r".chomp #=> "hello\n"
"hello\r".chomp #=> "hello"
"hello \n there".chomp #=> "hello \n there"
"hello".chomp("llo") #=> "he"

3. 判断是否在命令行运行脚本
if $0 == __FILE__
check_usage
compare_inventory_files(ARGV[0], ARGV[1])
end
类似于Java类的main方法，在被其他类导入时不会运行其中的代码。

4. Enumerable#any? 方法查找一个集合中是否有满足条件的元素
irb(main):004:0> deposits = [1, 0, 10000]
irb(main):005:0> deposits.any? do | deposit |
irb(main):006:1* deposit > 9999
irb(main):007:1> end
=> true

5. 关于测试
这本书(Everyday Scripting with Ruby)的很多程序都是依循测试驱动开发的思想写出来的，测试单元中的方法通常有两种目的。
一种是direct test，需要测试那个函数就直接调用那个函数，传递的参数都是直接写出来的。
另一种是bootstrapping test，被测试函数的参数也是通过生成这些参数的函数生成的，即一个方法测试了多个对象。
Everyone finds their own balance between testing directly and testing indirectly. You will too.

6. Time#strftime 方法
t = Time.now
t.strftime("Printed on %m/%d/%Y") #=> "Printed on 04/09/2003"
t.strftime("at %I:%M%p") #=> "at 08:56AM"

2. List 类型
1) 定义：
li = ["a", "b", 1]
2) 下标从0开始。
3) 负数索引从list的尾部向前计数来存取元素，即
li[-n] == li[len(li) - n]
4) 分片(slice)
>>> li = ['a', 'b', 'mpilgrim', 'z', 'example']
>>> li[1:3]   //从第2个元素到第3个元素
['b', 'mpilgrim']
>>> li[1:-1]  //从第2个元素到倒数第2个元素
['b', 'mpilgrim', 'z']
>>> li[:3]
['a', 'b', 'mpilgrim']
>>> li[3:] 
['z', 'example']
>>> li[:]
['a', 'b', 'mpilgrim', 'z', 'example']

5) 增加元素
a) append 末尾追加单个元素
b) insert 将单个元素插入某个位置
>>> li
['a', 'b', 'mpilgrim', 'z', 'example', 'new']
>>> li.insert(2, "new")           
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new']
c) extend 合并另一个List

6) 搜索
a) index 查找一个值的首次出现并返回索引值，如果没有找到则引发异常，与Java不同
b) in 操作符测试一个值是否在list内

7) 删除元素
a) remove 删除某个元素，如不存在则引发异常
b) pop 弹出栈顶元素，即删除最后一个值并返回该值

8) List运算符 真方便啊 -,=
>>> li = ['a', 'b', 'mpilgrim']
>>> li = li + ['example', 'new']
>>> li
['a', 'b', 'mpilgrim', 'example', 'new']
>>> li += ['two']               
>>> li
['a', 'b', 'mpilgrim', 'example', 'new', 'two']
>>> li = [1, 2] * 3             
>>> li
[1, 2, 1, 2, 1, 2]