函数式编程
函数是Python内建支持的一种封装，通过把大段代码拆成函数，通过一层一层的函数调用，把复杂任务分解成简单的任务，这种分解称之为面向过程的程序设计。函数就是面向过程的程序设计的基本单元。
函数式编程——Functional Programming，虽然也可以归结到面向过程的程序设计，但其思想更接近数学计算。
函数式编程是一种抽象程度很高的编程范式，纯粹的函数式编程语言编写的函数没有变量，因此，任意一个函数，只要输入是确定的，输出就是确定的，这种纯函数我们称之为没有副作用。而允许使用变量的程序设计语言，由于函数内部的变量状态不确定，同样的输入，可能得到不同的输出，因此，这种函数是有副作用的。
函数式编程的一个特点就是，允许把函数本身作为参数传入另一个函数，还允许返回一个函数！Python对函数式编程提供部分支持。由于Python允许使用变量，因此，Python不是纯函数式编程语言。
一、高阶函数Higher-order function
1.变量可以指向函数
以Python内置的求绝对值的函数abs()为例，调用该函数用以下代码：
a=abs
print(a(-10))2.函数名也是变量
函数名其实是指向函数的变量！对于abs()函数，可以把函数名abs看成变量，它指向一个可以计算绝对值的函数！
如果把abs指向其他对象：
>>> abs = 10
>>> abs(-10)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'int' object is not callable把abs指向10后，就无法通过abs(-10)调用该函数了！因为abs这个变量已经不指向求绝对值函数而是指向一个整数10！
注：由于abs函数实际上是定义在__builtin__模块中的，所以要让修改abs变量的指向在其它模块也生效，要用__builtin__.abs = 10。
3.传入函数
变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。
简单的高阶函数：结果为11
def add(x,y,f):
return f(x)+f(y)
m=add(-5,6,abs)
print(m)编写高阶函数，就是让函数的参数能够接收别的函数。
小结：把函数作为参数传入，这样的函数称为高阶函数，函数式编程就是指这种高度抽象的编程范式。
4.map/reduce函数
Python内建了map()和reduce()函数。
map()函数接收两个参数，一个是函数，一个是Iterable可迭代对象，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。
例如，函数f(x)=x²，把这个函数作用在一个list [1, 2, 3, 4, 5, 6, 7, 8, 9]上，就可以用map()实现如下：
用Python代码实现：
def f(x):
return x**2
r = map(f,[1,2,3,4,5,6,7,8,9])
print(list(r))map()传入的第一个参数是f，即函数对象本身。由于结果r是一个Iterator，Iterator是惰性序列，因此通过list()函数让它把整个序列都计算出来并返回一个list。
map()作为高阶函数，它把运算规则抽象了，因此，我们不但可以计算简单的f(x)=x²，还可以计算任意复杂的函数，比如，把这个list所有数字转为字符串：
r2 =list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))reduce(f, [x1, x2, x3, x4]) = f( f( f(x1, x2), x3), x4)from functools import reduce
def add(x,y):
return x + y
r3 = reduce(add,[1,3,5,7,9])
print(r3)def fn(x,y):
return x * 10 + y
r4 = reduce(fn,[1,3,5,7,9])
print(r4)from functools import reduce
def str2int(s):
def fn(x, y):
return x * 10 + y
def char2num(s):
#[s]是key，函数通过s参数查找字典中的key，进而获取value，返回value的值。
return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
return reduce(fn, map(char2num, s))def normalize(name):
return name.title()
L1 = ['adam', 'LISA', 'barT']
L2 = list(map(normalize, L1))
print(L2)from functools import reduce
def prod(L):
def fn(x,y):
return x * y
return reduce(fn,L)
print('3 * 5 * 7 * 9 =', prod([3, 4, 5, 6]))def str2float(s):
def fn(x,y):
return x * 10 + y
n = s.index('.')
s1 = list(map(int,[x for x in s[:n]]))
s2 = list(map(int,[x for x in s[n+1:]]))
return reduce(fn,s1)+ reduce(fn,s2) / 10 ** len(s2)
print('str2float(\'123.456\') =', str2float('123.456'))n = s.index('.')
利用 index() 函数确定字符串 S 中 ‘.’的位置。
s1 = list(map(int,[x for x in s[:n]]))
s2 = list(map(int,[x for x in s[n+1:]]))
先利用切片把传入的 str 分成以前以后两个部分（根据小数点分成整数和浮点数，分别处理），然后再把切割好的 s 利用列表生成式变成单个数字字符，map() 函数再负责把 int 函数作用到截取的s的每个元素中去。
5.filter函数
Python内建的filter()函数用于过滤序列。
filter()接收一个函数和一个序列。把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。
删掉偶数，只保留奇数
def is_odd(n):
return n % 2 == 1
list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
# 结果: [1, 5, 9, 15]def not_empty(s):
return s and s.strip()#移除字符串头尾空字符
list(filter(not_empty, ['A', '', 'B', None, 'C', ' ']))
# 结果: ['A', 'B', 'C']注意：filter()函数返回的是一个Iterator，也就是一个惰性序列，所以要强迫filter()完成计算结果，需要用list()函数获得所有结果并返回list。
PS：关于Lambda
fun = [(lambda n : i + n) for i in range(10)]
print fun[3](4)
print fun[4](4) fun = [(lambda n,m = i : m + n) for i in range(10)]
print fun[3](4)
print fun[4](4) 输出为7,8......m得到了外部的i值形成了闭包，fun [3](4) = lambda n,m=3:3+n n为4
用filter求素数
计算素数的一个方法是埃氏筛法.
列出从2开始的所有自然数，构造一个序列：2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...
取序列的第一个数2，它一定是素数，然后用2把序列的2的倍数筛掉：3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...
取新序列的第一个数3，它一定是素数，然后用3把序列的3的倍数筛掉：5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...
def _odd_iter():#初始数列直接考虑奇数列，除2之外的偶数都不是素数
n = 1
while True:#数列生成器，不担心没有退出条件
n = n+2
yield n
def _not_divisible(n):#排除条件
return lambda x:x % n >0
def primes():
yield 2
it = _odd_iter()#初始数列，其为无穷数列
while True:
n = next(it)
yield n
it = filter(_not_divisible(n),it) #filter()将it中的元素分别作用于参数为n的_not_divisible函数，为False的都删除
for n in primes():#限定一个输出范围，否则无限输出下去
if n<100:
print(n)
else:
break第一轮输出为yield 2，第二轮输出为循环第一步yield n 为 3时，此时以n为3的参数，对it进行元素筛选，能被3整除的元素都删除，然后输出第一个元yield n 为5，再筛选能被5整除的元素，依次进行下去.......
练习：回数是指从左向右读和从右向左读都是一样的数，例如12321，909。请利用filter()滤掉非回数：
def is_palindrome(n):
I,m = n,0
while I:
m = I%10+m*10
I = I//10
return (n==m)
output = filter(is_palindrome,range(0,1000))
print(list(output))小结：filter()的作用是从一个序列中筛出符合条件的元素。由于filter()使用了惰性计算，所以只有在取filter()结果的时候，才会真正筛选并每次返回下一个筛出的元素。
6.sorted排序算法
Python内置的sorted()函数就可以对list进行排序：
>>> sorted([36, 5, -12, 9, -21])
[-21, -12, 5, 9, 36]sorted()函数也是一个高阶函数，它还可以接收一个key函数来实现自定义的排序，例如按绝对值大小排序：
>>> sorted([36, 5, -12, 9, -21], key=abs)
[5, 9, -12, -21, 36]字符串排序，默认情况下，对字符串排序，是按照ASCII的大小比较的，由于'Z' < 'a'，结果，大写字母Z会排在小写字母a的前面：
>>> sorted(['bob', 'about', 'Zoo', 'Credit'])
['Credit', 'Zoo', 'about', 'bob']>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower)
['about', 'bob', 'Credit', 'Zoo']>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)
['Zoo', 'Credit', 'bob', 'about']小结：sorted()也是一个高阶函数。用sorted()排序的关键在于实现一个映射函数。
练习： 用一组tuple表示学生名字和成绩：L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]请用sorted()对上述列表分别按名字和分数排序：
方法一：
L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
def by_name(t):
return t[0].lower()
def by_score(t):
return t[1]
L2 = sorted(L, key=by_name)
print(L2)
L3 = sorted(L, key=by_score,reverse=True)
print(L3)L列表中的每个元素都是一个元组，首先按名字排序，key作用与排序中列表里的每一个元素，所以传入by_name里的参数t是一个元组，需要对元组的第一个元素进行排序，所以是t[0]。
方法二：
def by_name(t):
for i in t:
if isinstance(i,str):
return i.lower()
高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回。
def lazy_sum(*args):
def sum():
ax = 0
for n in args:
ax = ax + n
return ax
return sum调用lazy_sum()时，返回的并不是求和结果，而是求和函数：
>>> f = lazy_sum(1, 3, 5, 7, 9)
>>> f
<function lazy_sum.<locals>.sum at 0x101c6ed90>调用函数f时，才真正计算求和的结果：
>>> f()
25在函数lazy_sum中定义了函数sum，并且，内部函数sum可以引用外部函数lazy_sum的参数和局部变量，当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数中，这种程序结构称为“闭包（Closure）”。
调用lazy_sum()时，每次调用都会返回一个新的函数，调用结果互不影响，即使传入相同的参数：
>>> f1 = lazy_sum(1, 3, 5, 7, 9)
>>> f2 = lazy_sum(1, 3, 5, 7, 9)
>>> f1==f2
False1.闭包
注意到返回的函数在其定义内部引用了局部变量args，所以，当一个函数返回了一个函数后，其内部的局部变量还被新函数引用，所以，闭包用起来简单，实现起来可不容易。另一个需要注意的问题是，返回的函数并没有立刻执行，而是直到调用了f()才执行
def count():
fs = []
for i in range(1, 4):
def f():
return i*i
fs.append(f)
return fs
f1, f2, f3 = count()>>> f1()
9
>>> f2()
9
>>> f3()
9每次循环，都创建了一个新的函数，然后，把创建的3个函数都返回了。结果为9的原因：返回的函数引用了变量i，但它并非立刻执行。等到3个函数都返回时，它们所引用的变量i已经变成了3，因此最终结果为9。
返回闭包时牢记的一点就是：返回函数不要引用任何循环变量，或者后续会发生变化的变量。
如果一定要引用循环变量，就再创建一个函数，用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变：
def count():
def f(j):
return lambda :j*j
fs=[]
for i in range(1,4):
fs.append(f(i))
return fs
f1,f2,f3 = count()
print(f1())
print(f2())小结： 一个函数可以返回一个计算结果，也可以返回一个函数。返回一个函数时，牢记该函数并未执行，返回函数中不要引用任何可能会变化的变量
三、匿名函数
当我们在传入函数时，有些时候，不需要显式地定义函数，直接传入匿名函数更方便。在Python中，对匿名函数提供了有限支持。
>>> list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
[1, 4, 9, 16, 25, 36, 49, 64, 81]def f(x):
return x * x匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数：
>>> f = lambda x: x * x
>>> f
<function <lambda> at 0x101c6ef28>
>>> f(5)
25def build(x, y):
return lambda: x * x + y * y小结：Python对匿名函数的支持有限，只有一些简单的情况下可以使用匿名函数。
四、装饰器假设我们要增强now()函数的功能，比如，在函数调用前后自动打印日志，但又不希望修改now()函数的定义，在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。本质上，decorator就是一个返回函数的高阶函数。
定义一个能打印日志的decorator如下：def log(func):
def wrapper(*args, **kw):
print('call %s():' % func.__name__)
return func(*args, **kw)
return wrapper 函数log，是一个decorator，所以可以接受一个函数作为参数，并返回一个函数。函数对象有一个__name__属性，可以拿到函数的名字。
借助Python的@语法，把decorator置于函数的定义处：
@log
def now():
print('2015-3-25')>>> now()
call now():
2015-3-25now = log(now)log()是一个decorator，返回一个函数，所以，原来的now()函数仍然存在，只是现在同名的now变量指向了新的函数wrapper()函数。
wrapper()函数的参数定义是(*args, **kw)，因此，wrapper()函数可以接受任意参数的调用。在wrapper()函数内，首先打印日志，再紧接着调用原始函数。
def log(text):
def decorator(func):
def wrapper(*args, **kw):
print('%s %s():' % (text, func.__name__))
return func(*args, **kw)
return wrapper
return decorator@log('execute')
def now():
print('2015-3-25')>>> now()
execute now():
2015-3-25>>> now.__name__
'wrapper'不需要编写wrapper.__name__ = func.__name__这样的代码，Python内置的functools.wraps就是干这个事的，所以，一个完整的decorator的写法如下：
import functools
def log(func):
@functools.wraps(func)
def wrapper(*args, **kw):
print('call %s():' % func.__name__)
return func(*args, **kw)
return wrapper>>> now.__name__
'now'import functools
def log(text):
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kw):
print('%s %s():' % (text, func.__name__))
return func(*args, **kw)
return wrapper
return decorator练习：编写一个decorator，能在函数调用的前后打印出'begin call'和'end call'的日志。再思考一下能否写出一个@log的decorator，使它可以同时支持
@log('execute') / @log
def f():
pass import functools
def log(text):
if isinstance(text,(int,str,float)):
def decorator(func):
@functools.wraps(func)
def wrappers(*args,**kw):
print('begin call %s %s():' % (text,func.__name__))
out = func(*args,**kw)
print('end call %s %s():' % (text,func.__name__))
return out
return wrappers
return decorator
else:
func = text
@functools.wraps(func)
def wrapper(*args,**kw):
print('begin call %s():' % func.__name__)
out = func(*args,**kw)
print('end call %s():' % func.__name__)
return out
return wrapperPython的functools模块提供了很多有用的功能，其中一个就是偏函数（Partial function）。通过设定参数的默认值，可以降低函数调用的难度。偏函数也可以做到这一点。举例如下：
int()函数可以把字符串转换为整数，当仅传入字符串时，int()函数默认按十进制转换：
>>> int('12345')
12345>>> int('12345', base=8)
5349
>>> int('12345', 16)
74565def int2(x, base=2):
return int(x, base)>>> import functools
>>> int2 = functools.partial(int, base=2)创建偏函数时，实际上可以接收函数对象、*args和**kw这3个参数
max2 = functools.partial(max, 10)
max2(5, 6, 7)args = (10, 5, 6, 7)
max(*args)
