Python does not promote functional programming even though it works fairly well.
Anonymous function
匿名函数是一种语法糖（syntactic sugar）：所有使用匿名函数的地方，都可以用普通函数代替，少了它程序一样写，匿名函数只是让这一过程更加简便可读。我国程序员们为了给小函数起一个能准确描述功能的英文名称，做归纳、查字典，花的时间比实现函数本身还要长。匿名函数一出，问题迎刃而解。不过从简便可读的角度来讲，Python 的匿名函数，即 lambda 函数，真是有点名不副实。lambda 关键字包含6个字母，外加一个空格，本身就很长，写出来的匿名函数更长，严重影响阅读。比如下面这个：
map(lambda x: x * x, lst)
同样的功能，Scala 写出来就清晰了不少：
lst map (x => x * x)
另外，lambda 函数体只支持一条语句，这也限制了它的功能。不过从另一方面来说，需要两条以上语句实现的函数就不该再作为匿名函数了。
Currying & partial application
Python 并不原生支持柯里化（currying），如果你一定要，那也可以有。
举例来说，你有一个函数 f：
def f(a, b, c):
print(a, b, c)
如果要将其柯里化，你可以改写成这样：
def f(a):
def g(b):
def h(c):
print(a, b, c)
return h
return g
In [2]: f(1)(2)(3)
1 2 3
In [3]: g = f(4)
In [4]: g(5)(6)
4 5 6
得益于函数在 Python 中一等公民的地位，即所谓 first-class function，你可以在函数中返回另一个函数，柯里化也由此实现。《Currying in Python》一文提供了一种将普通函数柯里化的方法。
Partial application（偏函数）与柯里化是相关但不同的概念。你可以用 functools.partial 得到一个函数的偏函数：
In [1]: def f(a, b, c):
...: print(a, b, c)
...:
In [2]: from functools import partial
In [3]: g = partial(partial(f, 1), 2)
In [4]: g(3)
1 2 3
Recursion & tail recursion
Python 不支持对尾递归函数的优化（tail recursion elimination， TRE），也根本不建议程序员在生产代码中使用递归。
摘录一段 Python 领导核心 Guido van Rossum 关于尾递归的讲话，供大家学习领会：
So let me defend my position (which is that I don't want TRE in the language). If you want a short answer, it's simply unpythonic.
Lazy evaluation
生成器（generator）就是 Python 中惰性求值（lazy evaluation）的一个例子：一个值只有当请求到来时，才会被计算。生成器的使用，可以看我的另一篇文章《用 Python 写一个函数式编程风格的斐波那契序列生成器》。
但是 Python 没有一些函数式编程语言中那种精确到每个值的惰性计算。比如在 Scala 中，你可以用关键字 lazy 定义一个值：
scala> lazy val a = 2 * 2
a: Int = <lazy>
scala> a
res0: Int = 4
直到第一次调用，值 a 才会被计算出来。
Python 可以曲折地实现类似的惰性计算特性。Python Cookbook 第三版 8.10 节展示了如何利用描述符（descriptor）实现类属性的惰性计算：
class lazyproperty(object):
def __init__(self, func):
self.func = func
def __get__(self, instance, cls):
if instance is None:
return self
else:
value = self.func(instance)
setattr(instance, self.func.__name__, value)
return value
定义好的 lazyproperty 作为装饰器（decorator），被装饰的属性就只有在被调用时才会求值，求得的值会被缓存供以后使用：
class Circle(object):
def __init__(self, radius):
self.radius = radius
@lazyproperty
def area(self):
print('Computing area')
return math.pi * self.radius ** 2
@lazyproperty
def perimeter(self):
print('Computing perimeter')
return 2 * math.pi * self.radius
In [16]: import math
In [17]: c = Circle(4.0)
In [18]: c.area
Computing area
Out[18]: 50.26548245743669
In [19]: c.area
Out[19]: 50.26548245743669
map, reduce & filter
好消息是，Python 支持这些基本的操作；而坏消息是，Python 不建议你使用它们。
在 Python 2 中，map、reduce 和 filter 都是 build-in functions（内置函数），返回的都是列表或计算结果，使用起来很方便；但到了 Python 3，reduce 不再是内置函数，而被放入 functools，map 和 filter 返回的不再是列表，而是可迭代的对象。假如你需要的恰恰是列表，那么使用起来略显繁琐。
In [1]: from platform import python_version
In [2]: print('Python', python_version())
Python 3.5.2
In [3]: n1 = [1, 2, 3]
In [4]: n2 = [4, 5, 6]
In [5]: import operator
In [6]: map(operator.add, n1, n2)
Out[6]: <map at 0x104749748>
In [7]: list(map(operator.add, n1, n2))
Out[7]: [5, 7, 9]
In [8]: import functools
In [9]: functools.reduce(operator.add, n1)
Out[9]: 6
如果不拘泥于 map、reduce 的形式，实际上，list comprehension （列表推导）和 generator expression（生成器表达式）可以优雅地代替 map 和 filter：
In [10]: [i + j for i, j in zip(n1, n2)] # list(map(operator.add, n1, n2))
Out[10]: [5, 7, 9]
In [11]: [i for i in n1 if i > 1] # list(filter(lambda x: x > 1, n1))
Out[11]: [2, 3]
一个 for 循环也总是可以代替 reduce，当然，你得多写几行代码，看上去也不那么 functional 了。
此外，itertools 中还提供了 takewhile、dropwhile、filterfalse、groupby、permutations、combinations 等诸多函数式编程中常用的函数。
其他
另外，Python 不支持 pattern matching，return 语句怎么看怎么像 imperative programming （命令式编程）余孽，这些都限制了 Python 成为一种更好的函数式编程语言。
综上所述，相信你对于如何使用 Python 编写函数式代码已经入门，考虑到 Python 语言设计上对函数式编程的诸多限制，下一步就该考虑放弃了……
网友评论