函数式编程
简介：一种编程范式

把计算视为函数而非指令 幸运28源码出售企俄：2152876294 网址diguaym.com
纯函数式编程：不需要变量，没有副作用，测试简单
支持高阶函数，代码简单
高阶函数：
能接收函数做参数的函数

变量可以指向函数
函数的参数可以接收变量
一个函数可以接收另一个函数作为参数
能接收函数作为参数的函数被称为高阶函数
eg1：

def add(x,y,f):
return f(x)+f(y)
print add(0,4,math.sqrt) #注意不是math.sqrt()
1
2
3
eg2：

def format_name(s):
return s[0].upper()+s[1:].lower()
print map(format_name, ['adam', 'LISA', 'barT'])
1
2
3
eg3:

def is_sqr(x):
if int(math.sqrt(x)) == math.sqrt(x):
return x
print filter(is_sqr, range(1, 101))
1
2
3
4
python 中返回函数（一个函数执行的结果是返回另一个函数）

eg:1

def calc_sum(lst):
def lazy_sum():
return sum(lst)
return lazy_sum
1
2
3
4
使用f的时候并没有调用它(延迟求值)

>> f = calc_sum([1, 2, 3, 4])
>> f
<function lazy_sum at 0x1037bfaa0>
1
2
3
>> f()
10
1
2
eg2:

def calc_prod(lst):
def lazy_prod():
def prod(x,y):
return x*y
return reduce(prod,lst)
return lazy_prod
1
2
3
4
5
6
f = calc_prod([1, 2, 3, 4])
print f()
1
2
python闭包：
概念：内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure）。（如上calc_prod函数中，内部的reduce函数引用了 外部的lst变量）

闭包的特点是返回的函数还引用了外层函数的局部变量，所以，要正确使用闭包，就要确保引用的局部变量在函数返回后不能变。

扫描二维码关注公众号，回复： 2742353 查看本文章

eg1：

def count():
fs =[]
for i in range(1,4):
def f():
return i*i
fs.append(f)
return fs
f1,f2,f3 =count()
print(f1(),f2(),f3())
1
2
3
4
5
6
7
8
9
10
结果不是1，4，9 而是9，9，9，因为return的时候fs里面三个函数都没有执行，参数都是i，在调用的时候才开始执行，而此时i已经变成的。因此，返回函数不要引用任何循环变量，或者后续会发生变化的变量。（take this sentence in mind）

注意：python函数加不加括号问题

1、不带括号时，调用的是这个函数本身 （比如上面函数式编程）
2、带括号（此时必须传入需要的参数），调用的是函数的return结果（加括号就是调用了）

python匿名函数：
利用lambda表达匿名返回值而不是return

def is_not_empty(s):
return s and len(s.strip()) > 0
1
2
3
化简为：

print filter(lambda s: s and len(s.strip())>0, ['test', None, '', 'str', ' ', 'END'])
1
python装饰器decorator
接收 一个函数对其包装然后返回一个新函数，用于对原函数功能进行增加又不想修改原函数的代码

def f1(x):
return x*2
def newf(f):
def fn(x)：
print('new functions')
return f(x)
return fn
1
2
3
4
5
6
7
使用方法

g1 = newf(f1)
print g1(5)
or
f1 = new_fn(f1)
print f1(5)
1
2
3
4
5
这样就彻底隐藏了f1函数

python内置的@语法用来简化装饰器的调用

@newf
def f1(x)
return x*2
1
2
3
等价于

def f1(x):
return x*2
f1 =newf(f1)
1
2
3
即把f1包含在了newf里面并返回一个函数名还是f1的新的函数，因而在调用f1时，原来的newf也同时被执行了。想想@log就能明白了，执行@log下面的函数时，log也被打印出来，而新函数的函数名还是@log下面的函数名

def log1(f):
print("print log")
return fbr/>@log1
def d(x):
print(x)
1
2
3
4
5
6
7
output