函数式编程(Functional Programming), 可以归结为面向过程的程序设计, 但是其思想更加接近于数学计算
函数有副作用: 对于同一个函数相同的输入, 产生的结果是不一样的
函数无副作用: 上述的前提下函数输出是一样的
函数式编程就是一种抽象程度很高的编程范式，纯粹的函数式编程语言编写的函数没有变量
函数式编程的一个特点就是，允许把函数本身作为参数传入另一个函数，还允许返回一个函数！
1 高阶函数
变量可以指向函数, 也就是函数本身也可以复制给变量
实际上函数名本身也是变量
将函数作为参数传给另一个函数, 这样的函数就是高阶函数
1.1 map和reduce
map有两个参数, 一个是函数, 另一个是迭代器
>>> def f(x):
... return x * x
...
>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> list(r)
[1, 4, 9, 16, 25, 36, 49, 64, 81]
reduce把一个函数作用在一个序列上, 这个函数必须接受两个参数, reduce会先把序列的前两个参数传入函数计算,返回的结果会继续和下一个参数继续进行运算,直到完成整个序列的运算
>>> from functools import reduce
>>> def add(x, y):
... return x + y
...
>>> reduce(add, [1, 3, 5, 7, 9])
25
其效果等同于1+3+5+7+9
>>> from functools import reduce
>>> def fn(x, y):
... return x * 10 + y
...
>>> def char2num(s):
... return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
...
>>> reduce(fn, map(char2num, '13579'))
13579
该程序可以整个为
from functools import reduce
def str2int(s):
def fn(x, y):
return x * 10 + y
def char2num(s):
return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
return reduce(fn, map(char2num, s))
最后还可以用lambda函数优化
from functools import reduce
def char2num(s):
return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
def str2int(s):
return reduce(lambda x, y: x * 10 + y, map(char2num, s))
1.2 filter
filter用于过滤, 会传入两个参数, 一个是函数, 一个是序列. 函数只会处理一个参数且函数返回值是True或者False.当返回值是True的时候该值保留下来, 当返回值是False的时候该参数将不会被保留.
def not_empty(s):
return s and s.strip()
list(filter(not_empty, ['A', '', 'B', None, 'C', ' ']))
# 结果: ['A', 'B', 'C']
1.3 sorted
sorted是用于排序的.
当排序的序列中是数字的时候, 直接对数字进行排序. 当序列中的内容是非数字的时候排序就不能以大小判断了. 此时可以传入一个参数key来限定排序方法.
>>> sorted([36, 5, -12, 9, -21], key=abs)
[5, 9, -12, -21, 36]
默认情况下, 字母的排序是按照ASCII的排序关系排序
要进行反向排序, 需要加入第三个参数, reverse=True
>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower)
['about', 'bob', 'Credit', 'Zoo']
2 返回函数
函数可以做为对象赋值给变量, 因而返回函数实际上就是将函数封装传出去了
例如想要做一个求和的函数, 但是并不希望调用该函数执行之后就返回结果, 而是在想要使用的时候调用.
def lazy_sum(*args):
def sum():
ax = 0
for n in args:
ax = ax + n
return ax
return sum
可以看到 lazy_sum()函数返回的就是sum函数.当返回值执行函数的时候才进行计算
>>> f = lazy_sum(1, 3, 5, 7, 9)
>>> f
<function lazy_sum.<locals>.sum at 0x101c6ed90>
>>> f()
25
3 闭包
闭包(Closure)就是传出返回函数, 传出的函数在执行的时候可以调用原函数内容的变量. 类似于上述lazy_sun的情况.
闭包的基本形式是:
在函数F1中, 定义F2, F2只能引用F1定义的变量, 之后F1函数返回F2的函数名字
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的时候返回的结果是..
>>> f1()
9
>>> f2()
9
>>> f3()
9
原因是由于闭包的特性是在具体调用的时候去取原函数中变量的值. 然而在返回fs的时候会走count()中的代码, 在具体函数执行之前i值已经是i=3了.
因此在闭包的时候, 不能引用任何循环变量.
如果真的需要引用这个循环变量的话, 就需要将循环变量绑定到一个函数的参数当中.
def count():
def f(j):
def g():
return j*j
return g
fs = []
for i in range(1, 4):
fs.append(f(i)) # f(i)立刻被执行，因此i的当前值被传入f()
return fs
具体还可以通过lambda表达式优化上述代码
def count():
def f(j):
def g():
return j*j
return g
return [f(i) for i in range(1,4)]
f1, f2, f3 = count()
4 匿名函数
匿名函数用于一些操作不必要比较短小没必要写成函数的方式
>>> list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
[1, 4, 9, 16, 25, 36, 49, 64, 81]
匿名函数只能是一个表达式, 且不用写return, 返回值就是表达式的结果.
常用的匿名函数用lambda表达式.
写法:
lambda 参数 : 参数的运算式 (返回的结果是参数的表达式的结果)
lambda 参数表达式 (返回的值就是表达式的计算结果)
5 装饰器
装饰器(Decorator), 在不修改原函数的情况下, 在代码运行期间动态增加功能的方式
def log(func):
def wrapper(*args, **kw):
print('call %s():' % func.__name__)
return func(*args, **kw)
return wrapper
@log
def now():
print('2017-3-28')
>>> now()
call now():
2017-3-28
此处的@log相当于执行了
now = log(now)
另外定义装饰器的时候, 可以用 @装饰器(参数) 装饰器上添加参数传入, 对此原有的装饰器需要在外层再加一层函数来传入参数, 因为如果只在刚才的最外层添加是无法做到准确传入传入的参数的
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')
此处的@log('execute')相当于执行了
now = log('execute')(now)
但是这样的装饰器还是有一个问题就是:
每个函数对象都有一个__name__属性, 这个属性保存了函数的名字. 但是执行完装饰器之后, 该属性值__name__会被覆盖成别的名字.改进方法是:
import functools
def log(func):
@functools.wraps(func)
def wrapper(*args, **kw):
print('call %s():' % func.__name__)
return func(*args, **kw)
return wrapper
对于带参数的装饰器有:
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
6 偏函数
偏函数是 functools.partial模块里, 通过固定某个函数的某个参数来达到形成新函数简化操作的目的.
通过functools.partial可以传入原来的函数名字, 设定的默认参数的值, 来返回一个新的函数更加方便的定义并且使用
诸如:
int(要转化的参数, base进制)
当我们要定义直接转化二进制的时候可以
int2 = functools.partial(int, base=2)
具体的
>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2('1000000')
64
>>> int2('1010101')
85