1 函数式编程简介
函数：function
函数式：functional 一种编程范式
特点：
把计算视为函数而非指令
纯函数式编程：不需要变量，没有副作用，测试简单
支持高阶函数，代码简洁
Python支持的函数式編程：
不是纯函数式編程：允许有变量
支持高阶函数：函数也可以作为变量传入
支持闭包：有了闭包就能返回函数
有限度的支持匿名函数
变量可以指向函数：
>>> f=abs
>>> f(-20)
函数名其实就是指向函数的变量。
>>> abs=len
>>> abs([1,2,3])
2 高阶函数
能接受函数作为参数的函数
变量可以指向函数
函数的参数可以接受变量
一个函数可以接受另一个函数作为参数
能接受函数作为参数的函数就是高阶函数
def add(x, y, f)
return f(x) + f(y)
add(x, y, abs)
3 map()函数
Python內置的高阶函数，接受一个函数f和一个list，并且通过把函数f依次作用在list的每個元素上，得到一个新的list并返回。
def f(x)
return x*x
map(f, range(1,10))
4 reduce()函数
参数为一个函数f，一个list。函数f接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最后结果。
def f(x, y)
return x + y
reduce(f, [1,3,5,7,9]) #25
5 filter()函数
参数为一个函数f，一个list。函数f的作用是对每個元素进行判断，并返回布尔值。filter()根据判断结果对False的元素进行过滤。
def if_odd(x):
return x%2==1
filter(is_odd, [1,2,3,4,5]) #[1,3,5]
刪除None或者空字符串
def is_not_empty(s):
return s and len(s.strip())>0
filter(is_not_empty, ['test', None, ' ', 'End'])
strip()的作用：刪除字符串首尾的空白字符。
6 sorted（）函數
参数为一个list，一个函数f。函数f接受两个参数x和y，如果x应该排在前面，则返回-1；如果y应该排在前面，则返回1；如果相等则返回0。
>>> sorted([36, 5, 12, 9, 21]) #[5, 9, 12, 21, 36]
def reversed_cmp(x, y)
if x == y
return 0
else
return -cmp(x, y)
>>> sorted([36, 5, 12, 9, 21], reversed_cmp) #[36, 21, 12, 9, 5]
7 返回函数
def f():
print 'call f()...'
def g():
print 'call g()...'
return g
>>> x=f() #调用f()
call f()...
>>> x #变量x是f()返回的函数
<function g at 0x1037bf320>
>>> x() #x指向函数，因此可以调用
call g()...
注意区分返回函数和返回值
延迟计算
def calc_sum(lst):
def lazy_sum():
return sum(lst)
return lazy_sum
>>> f=calc_sum([1,2,3,4]) #调用calc_sum()并没有计算出结果，而是返回函数。
>>> f
<function lazy_sum at 0x1037bfaa0>
>>> f() #对返回的函数进行调用时，才计算出结果
10
8 闭包
在函数内部定义的函数和外部定义的函数是一样的，只是他们无法被外部访问。
内层函数引用外层函数的变量，然后返回内层函数的情况，称为闭包（Closure）。
闭包的特点：
返回的函数还引用了外层函数的局部变量，所以要正确使用闭包，就要确保引用的局部变量在函数返回后不能变。
def count():
fs=[]
for i in range(1, 4)
def f():
return i*i;
fs.append(f)
return fs
f1, f2, f3 = count() #此時调用f1、f2、f3的值都返回9
def count():
fs=[]
for i in range(1, 4)
def f(j):
def g():
return j*j;
return g;
fs.append(f(i))
return fs
f1, f2, f3 = count() #此時调用f1、f2、f3的值返回1,4,9
9 匿名函数
关键字lambda表示匿名函数，冒号前面的x表示函数参数。
匿名函数的限制：只能有一個表达式，该表达式就是返回值。
>>> map(lambda x : x*x, range(1, 10))
>>> sorted([1,5,3,6], lambda x,y : -cmp(x, y))
>>> myabs=lambda x : -x if x < 0 else x #返回匿名函数
>>> filter(lambda s ：s and len(s.strip()>0), ['test', None, ' ', 'END'])
10 decorator装饰器
问题：定义了一個函数，想在运行时动态增加功能，有不想改动函数本身的代码。
示例：希望对下列函数调用增加log功能，打印出函数调用：
def f1(x):
return x*2
def f2(x):
return x*x
def f3():
return x*x*x
高阶函数：可以接受函数作为参数；可以返回函数；接受一個函数，对其包裝，然后返回一个新的函数。
def new_fn(f):
def fn(x):
print 'call' + f._name_ + '()'
return fn
>>> g1=new_fn(f1)
>>> print g1(5)
>>> f1=new_fn(f1)
>>> print f1（5）
装饰器
Python內置的@语法法就是为了简化装饰器的调用
@new_fn
def f1(x):
return x*2
装饰器的作用：
极大简化代码，避免为每个函数编写重复性代码
打印日志：@log
检测性能：@performance
数据库事务：@transaction
URL路由：@post('/register')
编写无参数的decorator
Python的decorator本质上就是一个高阶函数，它接受一个函数作为参数，然后返回一个新函数。
使用decorator用@語法，可以避免手动编写f=decorate(f)这样的代码。
要让decorator自适应任何参数定义的函数，可以利用Python的*args和**kw，保证任意个数的参数总是能正常调用。
*args是非关键字参数，用于元组；**kw是关键字参数，用于字典。
def log(f):
def fn(*args, **kw):
print 'call' + f._name_ + '()...'
return f(*args, **kw)
return fn
例子：编写一个@performance，可以打印出函数调用的时间。
import time
def performance(f):
def fn(*args, **kw):
t1 = time.time()
r = f(*args, **kw)
t2 = time.time()
print 'call %s() in %fs' %(f._name_, t2-t1)
return r
return fn
@performance
def factorial(n):
return reduce(lambda x,y:x+y, range(1,n+1)
print factorial(10)
编写带参数的decorator
如果有的函数非常重要，希望打印出'[INFO]call xxx()...';有的函数不太重要，希望打印出'[DEBUG] call xxx()...'。
这时，log函数本身就需要传入'INFO'或'DEBUG'这样的参数，类似这样：
@log('DEBUG')
def my_func():
pass
上面定义翻译成高阶函数调用，就是：
my_func=log('DEBUG')(my_func)
再展开一下就是：
log_decorator=log('DEBUG')
my_func=log_decorator(my_func)
亦即：
log_decorator=log('DEBUG')
@log_decorator
def my_func():
pass
def log(prefix):
def log_decorator(f):
def wrapper(*args, **kw)
print '[%s]%s()...' %(prefix, f._name_)
return f(*args, **kw)
return warpper
return log_decorator
完善decorator
由decorator返回的函数的信息与被装饰的函数的信息不同，可以利用Python內置的functools来将原函数的所有必要属性一一赋值到新函数上，如__name__,__doc__等。
import functools
def log(f)
@functools.wrap(f)
def wrapper(*args, **kw)
print 'call ...'
return f(*args, **kw)
return wrapper
需要指出的是，无法获得原函数的原始参数信息。
11 偏函数
当一个函数有很多参数时，调用者就需要提供多个参数；如果減少参数个数，就可以简化调用者的负担。
>>> int('12345')
>>> int('12345', base=8)
>>> int('12345', 16)
假设要转换大量的二进制字符串，每次都传入int(x,base==2)非常麻烦，可以定义一个int2()函数，默认把base=2传进去。
def int2(x, base=2)
return int(x,base)
>>> int2('101010110')
functools.partial就是帮助我们创建一个偏函数的。
>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2('101010110')
例子：忽略大小写排序。
>>> import functools
>>> sorted_ignore_case = functools.partial(sorted, cmp=lambda s1,s2:cmp(s1.upper(), s2.upper()))
