1.什么是函数式编程
Wiki上对Functional Programming的定义：
In computer science, functional programming is a programming paradigm—a style of building the structure and elements of computer programs—that treats computation as the evaluation of mathematical functions and avoids changing-state and mutable data. It is a declarative programming paradigm, which means programming is done with expressions[1] or declarations[2] instead of statements. In functional code, the output value of a function depends only on the arguments that are input to the function, so calling a function f twice with the same value for an argument x will produce the same result f(x) each time.** Eliminating side effects, i.e. changes in state that do not depend on the function inputs, can make it much easier to understand and predict the behavior of a program, which is one of the key motivations for the development of functional programming. **
"函数式编程"是一种"编程范式"（programming paradigm），一种构建计算机程序结构和元素的风格/模式。它把运算当作是数据函数的计算，避免了多变的状态和易变的数据。它是一种声明性编程范式，意味着程序是由表达式或声明完成的而不是语句。在函数代码中，函数的输出值只依赖于对这个函数的输入，因此以同样的参数值x调用函数f两次，每次得到的结果是相同的f(x)。消除副作用，即状态的改变不再依赖于函数的输入，这使理解和预测程序的行为更加容易，这也是发展函数式编程的主要动力。****
所谓"副作用"（side effect），指的是函数内部与外部互动（最典型的情况，就是修改全局变量的值），产生运算以外的其他结果。
函数式编程强调没有"副作用"，意味着函数要保持独立，所有功能就是返回一个新的值，没有其他行为，尤其是不得修改外部变量的值。
和声明性编程对应的是命令式编程(imperative programming), 它在源程序中使用命令改变状态，最简单的例子就是赋值。存在的副作用是可能改变程序状态的值。因此函数没有返回值是有意义的。由于它们缺少引用透明性(referential transparency)，即根据程序的执行状态在不同的时间，相同的表达式可能会产生不同的结果。
引用透明（Referential transparency），指的是函数的运行不依赖于外部变量或"状态"，只依赖于输入的参数，任何时候只要参数相同，引用函数所得到的返回值总是相同的。
函数式编程就是一种抽象程度很高的编程范式，纯粹的函数式编程语言编写的函数没有变量(应该也存在不是纯粹的函数式编程，使用函数式编程解决局部问题，同时也存在变量)，因此，任意一个函数，只要输入是确定的，输出就是确定的，这种纯函数我们称之为没有副作用。而允许使用变量的程序设计语言，由于函数内部的变量状态不确定，同样的输入，可能得到不同的输出，因此，这种函数是有副作用的。
函数式编程就是如何编写程序的方法论。
它属于"结构化编程"的一种，主要思想是把运算过程尽量写成一系列嵌套的函数调用。举例来说，现在有这样一个数学表达式：
(1 + 2) * 3 - 4
传统的过程式编程，可能这样写：
var a = 1 + 2;
var b = a * 3;
var c = b - 4;
函数式编程要求使用函数，我们可以把运算过程定义为不同的函数，然后写成下面这样：
var result = subtract(multiply(add(1,2), 3), 4);
这就是函数式编程。
2.函数即变量（first class function）
Python中一切皆为对象。函数也不例外，且函数与其他数据类型一样，处于平等地位。
函数可以赋值给变量，也可以作为参数，传入另一个函数，或者作为别的函数的返回值。函数名其实就是指向函数的变量，它可以被赋其他值。
这样才能快捷实施函数式编程，C语言里函数与变量不平等的，或许借助函数指针倒是可以实现，但颇为麻烦。
函数赋值给其他变量
>>> abs(-10)
10
>>> foo = abs
>>> foo(-10)
10
函数名被赋其他变量
>>> abs
<built-in function abs>
>>> abs = 10
>>> abs
10
函数作为参数传递给另一函数
>>> def add(x, y, foo):
... return foo(x) + foo(y)
...
>>> add(-10, 3, abs)
13
函数作为返回值返回
>>> def foo():
return abs
... ...
>>> fun = foo()
>>> fun(-10)
10
3.匿名函数lambda
lambda表达式用于创建匿名函数，是一种简化函数定义的快速方法。不像def那样可以执行多重语句和注释，lambda形式定义的函数没有def形式的强大。优点是快速简单，一条语句就可定义一个函数。
lambda语法如下：
lambda arguments: expression
lambda定义一个求和函数add。
add = lambda x, y: x + y
效果和def形式定义的是一样的。
def add(x, y):
return x + y
lambda表达式通常是直接嵌入在需要函数的地方，且该函数能使用一个表达式完整描述，不大会直接将lambda表达式命令成函数。这虽然很酷，但是不方便拓展，如果一开始就需要给函数命名，应该使用def形式定义。
4.编程风格
打印斐波那契数列前10个。
- 命令式风格，使用了循环，有变量赋值语句。(如何解释副作用的原因？)
def fibonacci(n, first=0, second=1):
while n != 0:
print(first, end="
") # side-effect
n, first, second = n - 1, second, first + second # assignment
fibonacci(10)
- 函数式风格，使用了递归方式
fibonacci = (lambda n, first=0, second=1:
"" if n == 0 else
str(first) + "
" + fibonacci(n - 1, second, first + second))
print(fibonacci(10), end="")
此处的lambda表达式略微复杂，换成def的形式:
def fibonacci(n, first=0, second=1):
if n == 0:
return ''
else:
return str(first) + "
" + fibonacci(n - 1, second, first + second)
print(fibonacci(10), end="")
循环是在描述我们该如何地去解决问题。
递归是在描述这个问题的定义。
简单点理解，函数式编程就是把函数当普通的变量或对象一样使用，函数用做参数或返回值。函数自身带有逻辑计算，当变量使用可以得到非常高效的代码。
4.高阶函数
传统的说，Python是一种非函数式语言（non-functional），但在编码时可以使用函数式风格。Python中的lambda，高阶函数(map, reduce, filter)，偏函数(partial function),闭包(closure)，装饰器(decorator)都有函数式思想。通过 Python 中的高阶函数稍稍体会下函数式编程的趣味。
把函数作为参数传入的函数，这样的函数称为高阶函数。Python中知名高阶函数有map, reduce, filter。
- map
| map(func, *iterables) --> map object
|
| Make an iterator that computes the function using arguments from
| each of the iterables. Stops when the shortest iterable is exhausted.
map()传入的第一个参数是函数，第二个参数是Iterable对象，即可迭代的对象，如list，dict，str都是Iterable对象。map将函数func依次作用到Iterable对象的元素上，返回一map对象。(map对象是？)
如下将list中元素平方后得到新的list。
>>> ret= map(lambda x: x*x, list(range(5)))
>>> print(ret)
<map object at 0x029AE4B0>
>>> print(list(ret))
[0, 1, 4, 9, 16]
不是很严格的map()实现：
from collections import Iterable
def map(func, a_iterable):
result = []
if isinstance(a_iterable, Iterable) is False:
raise TypeError('%s object is not iterable' % type(a_iterable))
else:
for item in a_iterable:
result.append(func(item))
return result
- reduce
Python3里 reduce() 在 functools 模块下。
functools.reduce = reduce(...)
reduce(function, sequence[, initial]) -> value
Apply a function of two arguments cumulatively to the items of a sequence,
from left to right, so as to reduce the sequence to a single value.
For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates
((((1+2)+3)+4)+5). If initial is present, it is placed before the items
of the sequence in the calculation, and serves as a default when the
sequence is empty.
reduce()最少接收2个参数，最多接收3个参数，第2个参数要求可迭代的。reduce()作用效果：
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
>>> from functools import reduce
>>> reduce(lambda x, y: x+y, [1, 2, 3], 10)
16
>>> reduce(lambda x, y: x+y, [1, 2, 3])
6
map() 和 reduce() 结合使用实现 str 到 int 的过程，简洁又酷炫。
from functools import reduce
def str2int(a_str):
char2int = lambda x :{'0':0, '1':1, '2':2, '3':3, '4': 4, '5': 5,
'6': 6, '7':7, '8': 8, '9': 9}[x]
return reduce(lambda x, y: x*10+y, map(char2int, a_str))
print(str2int('1234'))
- filter
class filter(object)
| filter(function or None, iterable) --> filter object
|
| Return an iterator yielding those items of iterable for which function(item)
| is true. If function is None, return the items that are true.
filter()也接收一个函数和一个序列。和 map()不同的时，filter()把传入的函数依次作用于每个元素， 然后根据返回值是 True 还是 False 决定保留还是丢弃该元素。
如得到序列中的整数：
>>> ret = filter(lambda x: x if x>0 else None, [1, -2, 3, -4, 0])
>>> print(ret)
<filter object at 0x029AEEF0>
>>> print(list(ret))
[1, 3]
- sorted
sorted(iterable, key=None, reverse=False)
Return a new list containing all items from the iterable in ascending order.
|
A custom key function can be supplied to customise the sort order, and the
reverse flag can be set to request the result in descending order.
sorted()函数也是一个高阶函数，它还可以接收一个 key 函数来实现自定义的排序。
按绝对值排序
>>> sorted([1, -2, -3, 4], key=abs)
[1, -2, -3, 4]
问题：
有这样一个 list ：['1y','3m','1m','7d','5d','1d','12h','6h','3h']
其中 y 表示年， m 表示月， d 表示天， h 表示小时，前面的数字表示对应的时间
问如何用 sort 在一行内按照年>月>天>小时或者反过来的顺序进行排序？
>>> a_list = ['1y','3m','1m','7d','5d','1d','12h','6h','3h']
>>> sorted(a_list, key = lambda x: {'y':365*24, 'm':30*24, 'd':24, 'h':1}[x[-1]] * int(x[:-1]))
['3h', '6h', '12h', '1d', '5d', '7d', '1m', '3m', '1y']
参考：
1.wiki-Functional programming
2.Python函数式编程指南（一）：概述
3.函数式编程扫盲篇
4.函数式编程初探
5.函数式编程
完---如有错漏，请指教:)