Python 中的 lambda 和lambda 有什么区别

Python的lambda里只能写一行啦、不能有statement只能有expression啦，这些还是小问题，真正的问题是Python对Closure的实现根本是有缺陷的。闭包的实现都是错误的，哪来的真正的匿名函数？
比如在Python2里这样的代码是没法运行的，

def counter():
count = 0
def inner():
count += 1
return count
return inner

c = counter()
print c()

Python告诉你一个UnboundLocalError，count为什么会unbound呢，因为closure没有正确地实现。什么是closure呢，closure是一个二元组：lambda（别管是有名字的还是没名字的），和这个lambda定义时的environment。而这个environment包含了lambda中的自由变量（比如这里的count），这样才把这个lambda『封闭』起来了，所以叫闭包。
我所理解的『真正的』的lambda是说：完整地支持higher-order function，即函数可以作为函数的参数，也可以作为函数的返回值，那怕引入了mutation。为了达到这一点，语言的实现需要正确地实现closure和lexical scope。而mutation和lexical scope是两个正交的概念，Python因为有mutation而没有完整实现lexical scope进而没有完整地支持first-order function，这就叫broken lambda。Python3里新加的nonlocal关键字就是为了解决closure的历史问题。
然而同样的代码在Racket/Scala/OCaml里却可以跑地欢快：

(define (counter)
(define count 0)
(define (inner)
(begin (set! count (add1 count))
count))
inner)

(define c (counter))
(c) ;1
(c) ;2
(c) ;3

def counter(): () => Int = {
var count = 0
def inner() = {
count += 1
count
}
inner
}

val c = counter()
println(c())
println(c())
println(c())

let counter () =
let count = ref 0 in
let inner () =
count := !count + 1;
!count
in inner
;;

let c = counter();;
print_int(c());
print_int(c());
print_int(c());

真正的lambda就是正确而完整地实现了lexical scope和closure的lambda。这就是python的lambda和『真正的』的lambda的区别。
当然Python并不是函数式语言，Python也从来没有自我标榜是函数式语言，当年lambda都是一个Lisp程序员给Python加的，而且据说当时Guido是强烈反对的……
BTW，lambda这个名字确实没什么神秘的

===
Update：
经灵剑提醒，由于Racket和Python中对于list comprehension的实现不同，list comprehension的例子是不太恰当的。Racket中的list comprehension经过宏展开后是递归的函数调用的形式，而类似的python代码可能是这样的：

map(lambda i: lambda n: i+n, range(10))[3](4)

这个时候Python的行为和Racket是一样的。但对于list comprehension而言，Python并不是函数式语言（again），同Haskell、Scala、Racket这些的实现是不同的，在comprehension的过程中并没有创建出各自包含i的闭包。
原：
比如这个Python代码：

fs = [(lambda n: i + n) for i in range(10)]
fs[3](4)

fs[3](4)应该是几呢？Python告诉你是13 = = 因为每一个lambda都share了相同的i。
同样的代码再看看Racket里呢：

(define fs
(for/list ([i (range 10)])
(λ (n) (+ i n))))
((fourth fs) 4)

Racket里正确地告诉你结果是7。