函数式编程python_*python函数式编程

>[danger]# 函数式编程基础

1. 函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可;定义的函数在被调入内存时函数内容不会被执行

2. 函数式编程，是指代码中每一块都是不可变的(immutable)，都由纯函数(pure function)的形式组成。这里的纯函数，是指函数本身相互独立、互不影响，对于相同的输入，总会有相同的输出，没有任何副作用。

比如对于一个列表，返回由列表中每个元素的平方组成的新列表

>[success]~~~

>def multiply_2(l):

> for index in range(0, len(l)):

> l[index] *= 2

> return l

这段代码就不是一个纯函数的形式，因为列表中元素的值被改变了，如果我多次调用 multiply_2() 这个函数，那么每次得到的结果都不一样。要想让它成为一个纯函数的形式，就得写成下面这种形式，重新创建一个新的列表并返回。

>[success]~~~

>def multiply_2_pure(l):

> new_list = []

> for item in l:

> new_list.append(item * 2)

> return new_list

>[warning]## 优点

其纯函数和不可变的特性使程序更加健壮，易于调试(debug)和测试

>[warning]## 缺点

限制多，难写

>[danger]# 函数式编程应用

当然，Python 不同于一些语言(比如 Scala)，它并不是一门函数式编程语言，不过，Python 也提供了一些函数式编程的特性，值得我们了解和学习。

Python 主要提供了这么几个函数：`map()`、`filter()` 和 `reduce()`，通常结合匿名函数 lambda 一起使用。这些都是你需要掌握的东西。

>[success]1.map(function, iterable) 函数

对 iterable 中的每个元素，都运用 function 这个函数，最后返回一个新的可遍历的集合。比如要对列表中的每个元素乘以 2，那么用 map 就可以表示为下面这样：

>[success]~~~

>l = [1, 2, 3, 4, 5]

>new_list = map(lambda x: x * 2, l) # [2， 4， 6， 8， 10]

我们可以以 map() 函数为例，看一下 Python 提供的函数式编程接口的性能。还是同样的列表例子，它还可以用 for 循环和 list comprehension(列表生成式)实现，我们来比较一下它们的速度：

>[success]~~~

>python3 -m timeit -s 'xs=range(1000000)' 'map(lambda x:x*2,xs)'

>10000000 loops, best of 3: 0.185 usec per loop

>python3 -m timeit -s 'xs=range(1000000)' '[i*2 for i in xs]'

>10 loops, best of 3: 77.2 msec per loop

>python3 -m timeit -s 'xs=range(1000000)' 'l=[]' 'for i in xs:l.append(i)'

>10 loops, best of 3: 87.9 msec per loop

map() 是最快的。因为 map() 函数直接由 C 语言写的，运行时不需要通过 Python 解释器间接调用，并且内部做了诸多优化，所以运行速度最快。

>[success]2.filter(function, iterable) 函数

它和 map 函数类似，function 同样表示一个函数对象。filter() 函数表示对 iterable 中的每个元素，都使用 function 判断，并返回 True 或者 False，最后将返回 True 的元素组成一个新的可遍历的集合。

比如要返回一个列表中的所有偶数，可以写成下面这样：

>[success]~~~

>l = [1, 2, 3, 4, 5]

>new_list = filter(lambda x: x % 2 == 0, l) # [2, 4]

>[success]3.reduce(function, iterable) 函数

通常用来对一个集合做一些累积操作。

function 同样是一个函数对象，规定它有两个参数，表示对 iterable 中的每个元素以及上一次调用后的结果，运用 function 进行计算，所以最后返回的是一个单独的数值。

举个例子，我想要计算某个列表元素的乘积，就可以用 reduce() 函数来表示：

>[success]~~~

>l = [1, 2, 3, 4, 5]

>product = reduce(lambda x, y: x * y, l) # 1*2*3*4*5 = 120

>

>测试某个列表元素的和

>python3 -m timeit -s 'xs=range(10000)' 'from functools import reduce' 's=reduce(lambda x,y:x+y, xs)'

>1000 loops, best of 3: 1.05 msec per loop

>python3 -m timeit -s 'xs=range(10000)' 's=0' 'for i in xs:s+=i'

>1000 loops, best of 3: 464 usec per loop

>python3 -m timeit -s 'xs=range(10000)' 's=sum(xs)'

>10000 loops, best of 3: 175 usec per loop

>[danger]通常来说，在我们想对集合中的元素进行一些操作时，如果操作非常简单，比如相加、累积这种，那么我们优先考虑 map()、filter()、reduce() 这类或者 list comprehension 的形式。至于这两种方式的选择:

>1. 在数据量非常多的情况下，比如机器学习的应用，那我们一般更倾向于函数式编程的表示，因为效率更高；

>2. 在数据量不多的情况下，并且你想要程序更加 Pythonic 的话，那么 list comprehension 也不失为一个好选择。

>3. 如果你要对集合中的元素，做一些比较复杂的操作，那么，考虑到代码的可读性，我们通常会使用 for 循环，这样更加清晰明了。

>[danger]思考题

如果让你对一个字典，根据值进行由高到底的排序，该怎么做呢？以下面这段代码为例

>[success]~~~

>d = {'mike': 10, 'lucy': 2, 'ben': 30}

>[success]~~~

>sorted(d.items(), key=lambda x:x[1],reverse=True)

>[('ben', 30), ('mike', 10), ('lucy', 2)]

## 函数赋值

~~~

def func():

pass

func.way = 123

print(func.way)

~~~