使用函数
通过把代码片段抽象为函数，程序可以变得更具声明性。
from random import random
def move_cars():
for i, _ in enumerate(car_positions):
if random() > 0.3:
car_positions[i] += 1
def draw_car(car_position):
print '-' * car_position
def run_step_of_race():
global time
time -= 1
move_cars()
def draw():
print ''
for car_position in car_positions:
draw_car(car_position)
time = 5
car_positions = [1, 1, 1]
while time:
run_step_of_race()
draw()
要理解这段程序，读者只需阅读主循环即可。“如果时间还有剩余，则比赛前进一步并输出结果，然后再次检查时间。如果读者想了解关于"比赛前进一步"或"打印输出"的更多细节，可以阅读相关函数代码。
无需过多说明，代码已描述了一切。
拆分代码到函数之中，可以让代码更具可读性。
该技术使用到了函数，但它只是把函数用作子程序来打包代码，从这个指导意义上来说，代码并非函数式的。函数中的代码使用到了并非作为参数传入的状态值。它们通过改变外部变量影响了其周围的代码，而不是通过返回函数值。为了检查一个函数究竟做了什么，读者必须仔细阅读每一行代码。如果他们发现一个外部变量，他们必须找到变量的源头，而且必须查看是否有其它函数改变了该变量的值。
移除状态
这是车辆比赛代码的函数式版本：
from random import random
def move_cars(car_positions):
return map(lambda x: x + 1 if random() > 0.3 else x,
car_positions)
def output_car(car_position):
return '-' * car_position
def run_step_of_race(state):
return {'time': state['time'] - 1,
'car_positions': move_cars(state['car_positions'])}
def draw(state):
print ''
print '\n'.join(map(output_car, state['car_positions']))
def race(state):
draw(state)
if state['time']:
race(run_step_of_race(state))
race({'time': 5,
'car_positions': [1, 1, 1]})
代码仍然被拆分为多个函数，但是所有函数都是函数式的。它们有三个特征：第一，不存在任何共享的变量。 time 和 car_positions 被直接传入 race() 方法中。第二，所有函数都接受参数。第三，函数中没有变量被实例化。所有数据变化都以返回值方式完成。race() 使用 run_step_of_race() 的返回值进行递归。每一次前进一步产生的新状态，都被立即传入下一步之中。
现在，这里有两个函数，zero() 和 one()：
def zero(s):
if s[0] == "0":
return s[1:]
def one(s):
if s[0] == "1":
return s[1:]
zero() 接受一个字符串 s 作为参数。如果该参数的第一个字符是 '0'，则函数返回余下的字符串；如果不是，则返回 None，即 Python 函数的默认返回值。one() 函数功能一样，只不过用于判断的字符换成了 '1'。
想象一个名为 rule_sequence() 的函数，它接受一个字符串和一个形如zero() 和 one() 的规则函数列表作为参数。对字符串调用第一个规则函数，除非 None 被返回，否则它对返回的字符串调用第二个规则函数。除非 None 被返回，否则它对返回的字符串调用第三个规则函数。以此类推... 如果有任何规则函数返回 None，rule_sequence()函数停止执行并返回 None，否则它会返回最后一个规则函数的返回值。
这是一些输入输出示例：
print rule_sequence('0101', [zero, one, zero])
# => 1
print rule_sequence('0101', [zero, zero])
# => None
这是 rule_sequence() 函数的命令式版本：
def rule_sequence(s, rules):
for rule in rules:
s = rule(s)
if s == None:
break
return s
练习 3. 上述代码使用了一个循环来完成工作。如果将其重写为一个递归函数，它看起来会更具声明性。
我的解决方法：
def rule_sequence(s, rules):
if s == None or not rules:
return s
else:
return rule_sequence(rules[0](s), rules[1:])
使用管道
在上一节中，一些命令式循环被重写为递归函数，这些递归函数调用某些辅助函数。在本节中，一个不同类型的命令式循环将使用管道技术进行重写。
下面的循环对字典进行转换，该字典包含乐队名称、错误国籍以及一些乐队活动状态。
bands = [{'name': 'sunset rubdown', 'country': 'UK', 'active': False},
{'name': 'women', 'country': 'Germany', 'active': False},
{'name': 'a silver mt. zion', 'country': 'Spain', 'active': True}]
def format_bands(bands):
for band in bands:
band['country'] = 'Canada'
band['name'] = band['name'].replace('.', '')
band['name'] = band['name'].title()
format_bands(bands)
print bands
# => [{'name': 'Sunset Rubdown', 'active': False, 'country': 'Canada'},
# {'name': 'Women', 'active': False, 'country': 'Canada' },
# {'name': 'A Silver Mt Zion', 'active': True, 'country': 'Canada'}]
函数的名字让人有点‘担心’，因为“format”一词的含义非常模糊。在仔细检查代码之前，担心就已经开始了。同一循环中做了三件事情：'country' 键的值被设为 'Canada'；删除乐队名称中的标点符号；乐队名称首字母大写。很难说清代码究竟想要做什么，也很难判断代码是否做了它似乎想要做的事情。而且代码难以复用、难以测试，也难以并行化。
将其与以下相比：
print pipeline_each(bands, [set_canada_as_country,
strip_punctuation_from_name,
capitalize_names])
这段代码很容易理解，它给人的印象是，这些辅助函数都是函数式的，因为它们似乎都串在一起。来自前一个函数的输出构成了下一个函数的输入。如果它们是函数式的，它们很容易验证，而且它们易于复用、易于测试、易于并行化。
pipeline_each() 作业每次传递一个乐队到一个转换函数中，比如 set_canada_as_country()。在函数应用于所有乐队之后，pipeline_each() 函数捆绑所有转换后的乐队，然后，它传递每一个乐队到下一个函数中。
让我们看看转换函数。
def assoc(_d, key, value):
from copy import deepcopy
d = deepcopy(_d)
d[key] = value
return d
def set_canada_as_country(band):
return assoc(band, 'country', "Canada")
def strip_punctuation_from_name(band):
return assoc(band, 'name', band['name'].replace('.', ''))
def capitalize_names(band):
return assoc(band, 'name', band['name'].title())
每一个函数将一个乐队的一个键关联到一个新值。在不改变原乐队的情况下，很难做到这一点。通过使用 deepcopy() 函数生成一个字典拷贝，assoc() 函数解决了这一难题。每一个转换函数都是基于拷贝来修改，并返回这个拷贝。
一切看起来很完美，原乐队字典被保护起来，免受字典中的键被赋予新值的影响。但上述代码仍然存在两处潜在的改变。在 strip_punctuation_from_name() 函数中，去除名字中的标点符号是通过对原名字调用 replace() 函数完成的。在 capitalize_names() 函数中，名字的首字母大写是通过对原名字调用 title() 函数完成的。如果 replace() 和 title() 不是函数式的，那么 strip_punctuation_from_name() 和 capitalize_names() 也不是函数式的。
幸运的是，replace() 和 title() 不会改变它们所操作的字符串，这是因为字符串在Python中是不可变的。例如，当乐队名字字符串调用 replace() 时，原乐队名字先生成一个拷贝，然后使用这个拷贝调用 replace() 函数 。哎呀，好险啊！
Python 的字符串和字典在可变性方面的反差，充分展示了如 Clojure 之类语言的魅力。程序员再也不需要为他们是否改变了数据而担心，答案当然是否定的。
练习 4. 试着编写 `pipeline_each`` 函数，把排序考虑进去。对于传入的乐队数组，每次只传入一个乐队到第一个转换函数。返回的乐队结果数组再次作为参数传入，每次只传入一个乐队到第二个转换函数。以此类推。
我的解决方法：
def pipeline_each(data, fns):
return reduce(lambda a, x: map(x, a),
fns,
data)
三个转换函数的功能归根到底是去改变传入乐队的一个特定键的值。call() 函数可用于抽象，它接受一个待应用的函数和一个与变化值对应的键作为参数。
set_canada_as_country = call(lambda x: 'Canada', 'country')
strip_punctuation_from_name = call(lambda x: x.replace('.', ''), 'name')
capitalize_names = call(str.title, 'name')
print pipeline_each(bands, [set_canada_as_country,
strip_punctuation_from_name,
capitalize_names])
或者，如果我们为了简洁而牺牲可读性的话，可以这样写：
print pipeline_each(bands, [call(lambda x: 'Canada', 'country'),
call(lambda x: x.replace('.', ''), 'name'),
call(str.title, 'name')])
call() 函数代码：
def assoc(_d, key, value):
from copy import deepcopy
d = deepcopy(_d)
d[key] = value
return d
def call(fn, key):
def apply_fn(record):
return assoc(record, key, fn(record.get(key)))
return apply_fn
这里发生了很多事情，让我们一点一点来剖析。
第一，call() 是一个高阶函数。高阶函数接受一个函数作为参数，或者返回一个函数，或者像 call() 函数一样两者兼具。
第二，apply_fn() 看上去和三个转换函数非常类似。它接受一个记录（一个乐队）作为参数，查找 record[key] 的值，然后对该值执行 fn 函数，并把函数执行结果分配给该记录的一份拷贝，最后返回这个拷贝。
第三， call() 函数并不执行任何实际操作。 apply_fn() 函数被调用时，负责执行具体操作。在上面使用 pipeline_each() 的例子中，apply_fn() 其中的一个实例是对传入乐队的 'country' 设置为 'Canada'。 另一个实例是将传入乐队的名称首字母大写。
第四，当一个 apply_fn() 实例运行时，fn 和 key 已经不在函数范围之中了。它们既不是 apply_fn() 的参数，也不是它的内部变量，但是它们仍然可以被访问到。当定义一个函数时，它可以保存对一个已关闭变量的引用：那些被定义在函数范围之外却在函数内部使用的变量。当函数运行并且代码中引用了一个变量时，Python会在本地变量和参数中查找这个变量。如果没有找到，它会到保存过的已关闭变量引用中去查找。这里正是找到 fn 和 key 的地方。
第五，在 call() 函数代码中并没有提及乐队。这是因为 call() 函数被用来为任何程序生成管道函数，不管是什么主题。函数式编程部分是关于构建一个通用的、可重用的、可组合的函数库。
干得不错。闭包、高阶函数以及变量范围在上面几个段落中全部涉及到了。来杯柠檬水放松一下（看来女程序员都喜欢柠檬水啊）。
关于乐队，还有一点工作需要去做，也就是只保留名称和国籍，其它都删除。extract_name_and_country() 可以把那些无关信息删除：
def extract_name_and_country(band):
plucked_band = {}
plucked_band['name'] = band['name']
plucked_band['country'] = band['country']
return plucked_band
print pipeline_each(bands, [call(lambda x: 'Canada', 'country'),
call(lambda x: x.replace('.', ''), 'name'),
call(str.title, 'name'),
extract_name_and_country])
# => [{'name': 'Sunset Rubdown', 'country': 'Canada'},
# {'name': 'Women', 'country': 'Canada'},
# {'name': 'A Silver Mt Zion', 'country': 'Canada'}]
extract_name_and_country() 可以写成一个通用的函数 pluck()，pluck() 可以这样用：
print pipeline_each(bands, [call(lambda x: 'Canada', 'country'),
call(lambda x: x.replace('.', ''), 'name'),
call(str.title, 'name'),
pluck(['name', 'country'])])
练习 5. pluck() 接受一个键列表作为参数，从每一个记录中提取信息。尝试编写这个函数，它需要使用一个高阶函数。
我的解决方法：
def pluck(keys):
def pluck_fn(record):
return reduce(lambda a, x: assoc(a, x, record[x]),
keys,
{})
return pluck_fn
接下来呢？
函数式代码可以很好地与其它风格编写的代码和平共处。本篇文章涉及到的转换函数可以应用于任何语言代码，尝试应用它们到你自己的代码中。
思考 Mary、Isla 和 Sam 列表问题，把对列表的迭代转换成 maps 和 reduces 方式。
思考那个比赛问题，把代码封装成函数，使那些函数成为函数式代码，把重复过程的循环转换成递归方式。
思考那个关于乐队的问题，把一系列操作转换成管道方式。
(1) 不可变数据是指不能被改变的数据。一些语言如 Clojure，默认所有值为不可变数据。任何“改变”操作都是基于原值的拷贝进行，首先复制一个拷贝，然后改变拷贝，最后传回这个更改的拷贝。程序可能会陷入程序员不完备的可能状态模型，这样做可以消除由此引发的错误。
(2) 所有将函数视为一等公民，对函数和其它值一视同仁的语言。这就意味着、你不仅可以创建函数，你还可以将函数作为参数传递给函数，作为返回值从函数中返回，存储在数据结构中。
(3) 尾部调用优化是一种编程语言的特性。每一次递归调用，都会产生一个新堆栈帧，用于为当前调用存储参数和本地变量。如果一个函数递归调用很多次，很可能会导致解释器或编译器内存溢出。具备尾部调用优化功能的语言，对于整个序列的递归调用，重用同一个堆栈帧。像 Python 之类的语言没有尾部调用优化这一特性，因此限制了一个函数可以递归调用的次数只能数千次。在 race() 函数中，只有区区5次调用，因此毫无问题。
(4) 柯里化的意思是，把接受多个参数的函数转换成接受第一个参数作为（唯一）参数的函数，并且返回接受第二个参数作为（唯一）参数的新函数，其余以此类推。
(5) 并行化意味着同时运行相同的代码而无需同步。这些并发进程通常运行在多个处理器上。
(6) 惰性求值是一项编译器技术。其目的是将代码运行推迟到实际需要这段代码的最终结果的时候。
(7) 如果每次运行都能生成同样的结果，那么这个进程就具有确定性。
-全文结束-
作者：Mary Rose，一名程序员兼音乐人，生活在纽约，在 Recurse Center 工作。
原文： A practical introduction to functional programming
感谢： Jodoo 帮助审阅并完成校对。
