Python函数式编程

目录

1 概述

1.1 函数式编程

1.2 特征

2 高阶函数

3 匿名函数

3.1 定义

3.2 使用场景 

4 map/reduce/filter

4.1 map

4.2 reduce

4.3 filter 

5 闭包

5.1 定义

5.2 闭包的作用

5.3 常见的误区

6 装饰器

6.1 对一个简单的函数进行装饰  

6.2 装饰器的使用形式

6.3 对带参数的函数进行装饰

6.4 带参数的装饰器

6.5 多个装饰器

6.6 基于类的装饰器 

6.7 装饰器的副作用

6.8 小结 

7 partial

---

1 概述

在前面，我们已经对Python学习做了系统的知识梳理（ Python思维导图），上一节我们讲解了函数的基本知识，这一节我们分享函数式编程。

1.1 函数式编程

函数式编程（ functional programming ）是一种 编程范式（ Programming paradigm ） ，或者说编程模式，比如我们常见的过程式编程是一种编程范式，面向对象编程又是另一种编程范式。

1.2 特征

函数式编程的一大特性就是：可以把函数当成变量来使用，比如将函数赋值给其他变量、把函数作为参数传递给其他函数、函数的返回值也可以是一个函数等等。

Python 不是纯函数式编程语言，但它对函数式编程提供了一些支持。本章主要介绍 Python 中的函数式编程，主要包括以下几个方面：

  

2 高阶函数

在函数式编程中，我们可以将函数当作变量一样自由使用。一个函数接收另一个函数作为参数，这种函数称之为高阶函数（Higher-order Functions ）。

看一个简单的例子：

1. def func ( g , arr ):

2.         return [ g ( x ) for x in arr ]

上面的代码中， func 是一个高阶函数，它接收两个参数，第 1 个参数是函数，第 2 个参数是数

组， func 的功能是将函数 g 逐个作用于数组 arr 上，并返回一个新的数组，比如，我们可以这

样用：

1. def double ( x ):

2.         return 2 * x

3.

4. def square ( x ):

5.         return x * x

6.

7. arr1 = func ( double , [ 1 , 2 , 3 , 4 ])

8. arr2 = func ( square , [ 1 , 2 , 3 , 4 ])

不难判断出，arr1 是 [2, 4, 6, 8]，arr2 是 [1, 4, 9, 16]。 

3 匿名函数

3.1 定义

在 Python 中，我们使用 def 语句来定义函数，比如：

1. def double ( x ):

2. return 2 * x

除了用上面的方式定义函数， Python 还提供了一个关键字 lambda ，让我们可以创建一个匿名函

数，也就是没有名称的函数。它的形式如下：

1. lambda 参数 : 表达式

关键字 lambda 说明它是一个匿名函数，冒号 : 前面的变量是该匿名函数的参数，冒号后面

是函数的返回值，注意这里不需使用 return 关键字。

我们将上面的 double 函数改写成一个匿名函数，如下：

1. lambda x : 2 * x

那怎么调用匿名函数呢？可以直接这样使用：

1. >>> ( lambda x : 2 * x )( 8 )

2. 16

由于匿名函数本质上是一个函数对象，也可以将其赋值给另一个变量，再由该变量来调用函数，如下：

1. >>> f = lambda x : 2 * x # 将匿名函数赋给变量 f

2. >>> f

3. < function < lambda > at 0x7f835a696578 >

4. >>> f ( 8 )

5. 16

3.2 使用场景 

lambda 函数一般适用于创建一些临时性的，小巧的函数。比如上面的 double 函数，我们当

然可以使用 def 来定义，但使用 lambda 来创建会显得很简洁，尤其是在高阶函数的使用

中。

看一个例子：

1. def func ( g , arr ):

2.          return [ g ( x ) for x in arr ]

现在给一个列表 [1, 2, 3, 4] ，利用上面的函数，对列表中的元素加 1 ，返回一个新的列表，你可

能这样用：

1. def add_one ( x ):

2.          return x + 1

3.

4. arr = func ( add_one , [ 1 , 2 , 3 , 4 ])

这样做没什么错，可是 add_one 这个函数太简单了，使用 def 定义未免有点小题大作，我们

改用 lambda ：

1. arr = func ( lambda x : x + 1 , [ 1 , 2 , 3 , 4 ])

是不是很简洁、易懂？

4 map/reduce/filter

map/reduce/filter 是 Python 中较为常用的内建高阶函数，它们为函数式编程提供了不少便

利。

4.1 map

map 函数的使用形式如下：

1. map ( function , sequence )

解释：对 sequence 中的 item 依次执行 function(item) ，并将结果组成一个 List 返回，也

就是：

1. [ function ( item1 ), function ( item2 ), function ( item3 ), ...]

看一些简单的例子： 

1. >>> def square ( x ):

2. ... return x * x

3.

4. >>> map ( square , [ 1 , 2 , 3 , 4 ])

5. [ 1 , 4 , 9 , 16 ]

6.

7. >>> map ( lambda x : x * x , [ 1 , 2 , 3 , 4 ]) # 使用 lambda

8. [ 1 , 4 , 9 , 16 ]

9.

10. >>> map ( str , [ 1 , 2 , 3 , 4 ])

11. [ '1' , '2' , '3' , '4' ]

12.

13. >>> map ( int , [ '1' , '2' , '3' , '4' ])

14. [ 1 , 2 , 3 , 4 ]

再看一个例子：

1. def double ( x ):

2.          return 2 * x

3.

4. def triple ( x ):

5.          return 3 * x

6.

7. def square ( x ):

8.         return x * x

9.

10. funcs = [ double , triple , square ] # 列表元素是函数对象

11.

12. # 相当于 [double(4), triple(4), square(4)]

13. value = list ( map ( lambda f ： f ( 4 ), funcs ))

14.

15. print value

16.

17. # output

18. [ 8 , 12 , 16 ]

上面的代码中，我们加了 list 转换，是为了兼容 Python3 ，在 Python2 中 map 直接返回列

表， Python3 中返回迭代器。

4.2 reduce

reduce 函数的使用形式如下：

1. reduce ( function , sequence [, initial ])

解释：先将 sequence 的前两个 item 传给 function ，即 function(item1, item2) ，函数

的返回值和 sequence 的下一个 item 再传给 function ，即 function(function(item1,

item2), item3) ，如此迭代，直到 sequence 没有元素，如果有 initial ，则作为初始值调用。

也就是说：

1. reduece ( f , [ x1 , x2 , x3 , x4 ]) = f ( f ( f ( x1 , x2 ), x3 ), x4 )

看一些例子，就能很快理解了。

1. >>> reduce ( lambda x , y : x * y , [ 1 , 2 , 3 , 4 ]) # 相当于 ((1 * 2) * 3) * 4

2. 24

3. >>> reduce ( lambda x , y : x * y , [ 1 , 2 , 3 , 4 ], 5 ) # ((((5 * 1) * 2) * 3)) * 4

4. 120

5. >>> reduce ( lambda x , y : x / y , [ 2 , 3 , 4 ], 72 ) # (((72 / 2) / 3)) / 4

6. 3

7. >>> reduce ( lambda x , y : x + y , [ 1 , 2 , 3 , 4 ], 5 ) # ((((5 + 1) + 2) + 3)) + 4

8. 15

9. >>> reduce ( lambda x , y : x - y , [ 8 , 5 , 1 ], 20 ) # ((20 - 8) - 5) - 1

10. 6

11. >>> f = lambda a , b : a if ( a > b ) else b # 两两比较，取最大值

12. >>> reduce ( f , [ 5 , 8 , 1 , 10 ])

13. 10

4.3 filter 

filter 函数用于过滤元素，它的使用形式如下：

1. filter ( function , sequnce )

解释：将 function 依次作用于 sequnce 的每个 item ，即 function(item) ，将返回值为

True 的 item 组成一个 List/String/Tuple ( 取决于 sequnce 的类型， python3 统一返回

迭代器 ) 返回。

看一些例子。

1. >>> even_num = list ( filter ( lambda x : x % 2 == 0 , [ 1 , 2 , 3 , 4 , 5 , 6 ]))

2. >>> even_num

3. [ 2 , 4 , 6 ]

4. >>> odd_num = list ( filter ( lambda x : x % 2 , [ 1 , 2 , 3 , 4 , 5 , 6 ]))

5. >>> odd_num

6. [ 1 , 3 , 5 ]

7. >>> filter ( lambda x : x < 'g' , 'hijack' )

8. 'ac' # python2

9. >>> filter ( lambda x : x < 'g' , 'hijack' )

10. < filter object at 0x1034b4080 > # python3

注意在 python2 和 python3 中， map/reduce/filter 的返回值类型有所不同， python2

返回的是基本数据类型，而 python3 则返回了迭代器；

5 闭包

5.1 定义

在 Python 中，函数也是一个对象。因此，我们在定义函数时，可以再嵌套定义一个函数，并将该嵌套函数返回，比如：

1. from math import pow

2.

3. def make_pow ( n ):

4.          def inner_func ( x ): # 嵌套定义了 inner_func

5.                  return pow ( x , n ) # 注意这里引用了外部函数的 n

6.         return inner_func # 返回 inner_func

上面的代码中，函数 make_pow 里面又定义了一个内部函数 inner_func ，然后将该函数返

回。因此，我们可以使用 make_pow 来生成另一个函数：

1. >>> pow2 = make_pow ( 2 ) # pow2 是一个函数，参数 2 是一个自由变量

2. >>> pow2

3. < function inner_func at 0x10271faa0 >

4. >>> pow2 ( 6 )

5. 36.0

我们还注意到，内部函数 inner_func 引用了外部函数 make_pow 的自由变量 n ，这也就

意味着，当函数 make_pow 的生命周期结束之后， n 这个变量依然会保存在 inner_func

中，它被 inner_func 所引用。

1. >>> del make_pow # 删除 make_pow

2. >>> pow3 = make_pow ( 3 )

3. Traceback ( most recent call last ):

4. File "" , line 1 , in

5. NameError : name 'make_pow' is not defined

6. >>> pow2 ( 9 ) # pow2 仍可正常调用，自由变量 2 仍保存在 pow2 中

7. 81.0

像上面这种情况，一个函数返回了一个内部函数，该内部函数引用了外部函数的相关参数和变量，我们把该返回的内部函数称为闭包（Closure ）。

在上面的例子中， inner_func 就是一个闭包，它引用了自由变量 n 。

5.2 闭包的作用

闭包的最大特点就是引用了自由变量，即使生成闭包的环境已经释放，闭包仍然存在。

闭包在运行时可以有多个实例，即使传入的参数相同。

1. >>> pow_a = make_pow ( 2 )

2. >>> pow_b = make_pow ( 2 )

3. >>> pow_a == pow_b

4. False

利用闭包，我们还可以模拟类的实例。

这里构造一个类，用于求一个点到另一个点的距离：

1. from math import sqrt

2.

3. class Point ( object ):

4.          def __init__ ( self , x , y ):

5.                  self . x , self . y = x , y

6.

7.          def get_distance ( self , u , v ):

8.                  distance = sqrt (( self . x - u ) ** 2 + ( self . y - v ) ** 2 )

9.         return distance

10.

11. >>> pt = Point ( 7 , 2 ) # 创建一个点

12. >>> pt . get_distance ( 10 , 6 ) # 求到另一个点的距离

13. 5.0

用闭包来实现：

1. def point ( x , y ):

2.          def get_distance ( u , v ):

3.                 return sqrt (( x - u ) ** 2 + ( y - v ) ** 2 )

4.

5.          return get_distance

6.

7. >>> pt = point ( 7 , 2 )

8. >>> pt ( 10 , 6 )

9. 5.0

可以看到，结果是一样的，但使用闭包实现比使用类更加简洁。

5.3 常见的误区

闭包的概念很简单，但实现起来却容易出现一些误区，比如下面的例子：

1. def count ():

2.         funcs = []

3.          for i in [ 1 , 2 , 3 ]:

4.                  def f ():

5.                          return i

6.                  funcs . append ( f )

7.         return funcs

在该例子中，我们在每次 for 循环中创建了一个函数，并将它存到 funcs 中。现在，调用上

面的函数，你可能认为返回结果是 1, 2, 3 ，事实上却不是：

1. >>> f1 , f2 , f3 = count ()

2. >>> f1 ()

3. 3

4. >>> f2 ()

5. 3

6. >>> f3 ()

7. 3

为什么呢？原因在于上面的函数 f 引用了变量 i ，但函数 f 并非立刻执行，当 for 循环结束时，此时变量 i 的值是 3 ， funcs 里面的函数引用的变量都是 3 ，最终结果也就全为3。

因此，我们应尽量避免在闭包中引用循环变量，或者后续会发生变化的变量。

那上面这种情况应该怎么解决呢？我们可以再创建一个函数，并将循环变量的值传给该函数，如下：

1. def count ():

2.         funcs = []

3.          for i in [ 1 , 2 , 3 ]:

4.                  def g ( param ):

5.                          f = lambda : param # 这里创建了一个匿名函数

6.                         return f

7.                   funcs . append ( g ( i )) # 将循环变量的值传给 g

8.         return funcs

9.

10. >>> f1 , f2 , f3 = count ()

11. >>> f1 ()

12. 1

13. >>> f2 ()

14. 2

15. >>> f3 ()

16. 3

(1)闭包是携带自由变量的函数，即使创建闭包的外部函数的生命周期结束了，闭包所引用的自由变量仍会存在。

(2)闭包在运行可以有多个实例。

(3)尽量不要在闭包中引用循环变量，或者后续会发生变化的变量。

6 装饰器

我们知道，在 Python 中，我们可以像使用变量一样使用函数：

(1)函数可以被赋值给其他变量

(2)函数可以被删除

(3)可以在函数里面再定义函数

(4)函数可以作为参数传递给另外一个函数

(5)函数可以作为另一个函数的返回

简而言之，函数就是一个对象。

6.1 对一个简单的函数进行装饰  

为了更好地理解装饰器，我们先从一个简单的例子开始，假设有下面的函数：

1. def hello ():

2.          return 'hello world'

现在我们想增强 hello() 函数的功能，希望给返回加上 HTML 标签，比如 hello

world ，但是有一个要求，不改变原来 hello() 函数的定义。这里当然有很多种方法，下面

给出一种跟本文相关的方法：

1. def makeitalic ( func ):

2.          def wrapped ():

3.                  return "" + func () + ""

4.          return wrapped

在上面的代码中，我们定义了一个函数 makeitalic ，该函数有一个参数 func ，它是一个函

数；在 makeitalic 函数里面我们又定义了一个内部函数 wrapped ，并将该函数作为返回。

现在，我们就可以不改变 hello() 函数的定义，给返回加上 HTML 标签了：

1. >>> hello = makeitalic ( hello ) # 将 hello 函数传给 makeitalic

2. >>> hello ()

3. 'hello world'

在上面，我们将 hello 函数传给 makeitalic ，再将返回赋给 hello ，此时调用

hello() 就得到了我们想要的结果。

不过要注意的是，由于我们将 makeitalic 的返回赋给了 hello ，此时 hello() 函数仍

然存在，但是它的函数名不再是 hello 了，而是 wrapped ，正是 makeitalic 返回函数的名

称，可以验证一下：

1. >>> hello . __name__

2. 'wrapped'

对于这个小瑕疵，后文将会给出解决方法。

现在，我们梳理一下上面的例子，为了增强原函数 hello 的功能，我们定义了一个函数，它接收

原函数作为参数，并返回一个新的函数，完整的代码如下：

1. def makeitalic ( func ):

2.          def wrapped ():

3.                  return "" + func () + ""

4.         return wrapped

5.

6. def hello ():

7.          return 'hello world'

8.

9. hello = makeitalic ( hello )

事实上， makeitalic 就是一个装饰器（ decorator ），它『装饰』了函数 hello ，并返回一

个函数，将其赋给 hello 。

一般情况下，我们使用装饰器提供的 @ 语法糖（ Syntactic Sugar ），来简化上面的写法：

1. def makeitalic ( func ):

2.          def wrapped ():

3.                  return "" + func () + ""

4.          return wrapped

5.

6. @makeitalic

7. def hello ():

8.         ` return 'hello world'

像上面的情况，可以动态修改函数（或类）功能的函数就是装饰器。本质上，它是一个高阶函数，以被装饰的函数（比如上面的 hello ）为参数，并返回一个包装后的函数（比如上面的 wrapped ）给被装饰函数（hello ）。

6.2 装饰器的使用形式

装饰器的一般使用形式如下：

1. @decorator

2.          def func ():

3. pass

等价于下面的形式：

1. def func ():

2.          pass

3. func = decorator ( func )

装饰器可以定义多个，离函数定义最近的装饰器先被调用，比如：

1. @decorator_one

2. @decorator_two

3. def func ():

4.          pass

等价于：

1. def func ():

2.          pass

3.

4. func = decorator_one ( decorator_two ( func ))

装饰器还可以带参数，比如：

1. @decorator ( arg1 , arg2 )

2. def func ():

3.          pass

等价于：

1. def func ():

2.          pass

3.

4. func = decorator ( arg1 , arg2 )( func )

下面我们再看一些具体的例子，以加深对它的理解。

6.3 对带参数的函数进行装饰

前面的例子中，被装饰的函数 hello() 是没有带参数的，我们看看被装饰函数带参数的情况。对

前面例子中的 hello() 函数进行改写，使其带参数，如下：

1. def makeitalic ( func ):

2.          def wrapped (* args , ** kwargs ):

3.                  ret = func (* args , ** kwargs )

4.                 return '' + ret + ''

5.          return wrapped

6.

7. @makeitalic

8. def hello ( name ):

9. return 'hello %s' % name

10.

11. @makeitalic

12. def hello2 ( name1 , name2 ):

13. return 'hello %s, %s' % ( name1 , name2 )

由于函数 hello 带参数，因此内嵌包装函数 wrapped 也做了一点改变：

内嵌包装函数的参数传给了 func ，即被装饰函数，也就是说内嵌包装函数的参数跟被装饰函数

的参数对应，这里使用了 (*args, **kwargs) ，是为了适应可变参数。

看看使用：

1. >>> hello ( 'python' )

2. 'hello python'

3. >>> hello2 ( 'python' , 'java' )

4. 'hello python, java'

6.4 带参数的装饰器

上面的例子，我们增强了函数 hello 的功能，给它的返回加上了标签 ... ，现在，我

们想改用标签 ... 或

...

。是不是要像前面一样，再定义一个类似

makeitalic 的装饰器呢？其实，我们可以定义一个函数，将标签作为参数，返回一个装饰器，比

如：

1. def wrap_in_tag ( tag ):

2.          def decorator ( func ):

3.                  def wrapped (* args , ** kwargs ):

4.                          ret = func (* args , ** kwargs )

5.                  return '<' + tag + '>' + ret + ' + tag + '>'

6.          return wrapped

7.

8. return decorator

现在，我们可以根据需要生成想要的装饰器了：

1. makebold = wrap_in_tag ( 'b' ) # 根据 'b' 返回 makebold 生成器

2.

3. @makebold

4. def hello ( name ):

5.         return 'hello %s' % name

6.

7. >>> hello ( 'world' )

8. 'hello world'

上面的形式也可以写得更加简洁：

1. @wrap_in_tag ( 'b' )

2. def hello ( name ):

3.          return 'hello %s' % name

这就是带参数的装饰器，其实就是在装饰器外面多了一层包装，根据不同的参数返回不同的装饰器。

6.5 多个装饰器

现在，让我们来看看多个装饰器的例子，为了简单起见，下面的例子就不使用带参数的装饰器。

1. def makebold ( func ):

2.          def wrapped ():

3.                  return '' + func () + ''

4.

5.         return wrapped

6.

7. def makeitalic ( func ):

8.          def wrapped ():

9.                  return '' + func () + ''

10.

11.         return wrapped

12.

13. @makebold

14. @makeitalic

15. def hello ():

16. return 'hello world'

上面定义了两个装饰器，对 hello 进行装饰，上面的最后几行代码相当于：

1. def hello ():

2.          return 'hello world'

3.

4. hello = makebold ( makeitalic ( hello ))

调用函数 hello ：

1. >>> hello ()

2. 'hello world'

6.6 基于类的装饰器 

前面的装饰器都是一个函数，其实也可以基于类定义装饰器，看下面的例子：

1. class Bold ( object ):

2.          def __init__ ( self , func ):

3.                  self . func = func

4.

5.          def __call__ ( self , * args , ** kwargs ):

6.                  return '' + self . func (* args , ** kwargs ) + ''

7.

8. @Bold

9. def hello ( name ):

10.         return 'hello %s' % name

11.

12. >>> hello ( 'world' )

13. 'hello world'

可以看到，类 Bold 有两个方法：

__init__() ：它接收一个函数作为参数，也就是被装饰的函数

__call__() ：让类对象可调用，就像函数调用一样，在调用被装饰函数时被调用

还可以让类装饰器带参数：

1. class Tag ( object ):

2.         def __init__ ( self , tag ):

3.                 self . tag = tag

4.

5.          def __call__ ( self , func ):

6.                  def wrapped (* args , ** kwargs ):

7.                         return "<{tag}>{res}" . format (

8.                                 res = func (* args , ** kwargs ), tag = self . tag

9.                                 )

10.                 return wrapped

11.

12. @Tag ( 'b' )

13. def hello ( name ):

14.         return 'hello %s' % name

需要注意的是，如果类装饰器有参数，则 __init__ 接收参数，而 __call__ 接收 func 。

6.7 装饰器的副作用

前面提到，使用装饰器有一个瑕疵，就是被装饰的函数，它的函数名称已经不是原来的名称了，回到最开始的例子：

1. def makeitalic ( func ):

2.          def wrapped ():

3.                  return "" + func () + ""

4.          return wrapped

5.

6. @makeitalic

7. def hello ():

8.          return 'hello world'

函数 hello 被 makeitalic 装饰后，它的函数名称已经改变了：

1. >>> hello . __name__

2. 'wrapped'

为了消除这样的副作用， Python 中的 functools 包提供了一个 wraps 的装饰器：

1. from functools import wraps

2.

3. def makeitalic ( func ):

4.          @wraps ( func ) # 加上 wraps 装饰器

5.          def wrapped ():

6.                  return "" + func () + ""

7.         return wrapped

8.

9. @makeitalic

10. def hello ():

11. return 'hello world'

12.

13. >>> hello . __name__

14. 'hello'

6.8 小结 

(1)本质上，装饰器就是一个返回函数的高阶函数。

(2)装饰器可以动态地修改一个类或函数的功能，通过在原有的类或者函数上包裹一层修饰类或修饰函数实现。

(3)事实上，装饰器就是闭包的一种应用，但它比较特别，接收被装饰函数为参数，并返回一个函

数，赋给被装饰函数，闭包则没这种限制。

7 partial

Python 提供了一个 functools 的模块，该模块为高阶函数提供支持， partial 就是其中的一个

函数，该函数的形式如下：

1. functools . partial ( func [,* args ][, ** kwargs ])

这里先举个例子，看看它是怎么用的。

假设有如下函数：

1. def multiply ( x , y ):

2.          return x * y

现在，我们想返回某个数的双倍，即：

1. >>> multiply ( 3 , y = 2 )

2. 6

3. >>> multiply ( 4 , y = 2 )

4. 8

5. >>> multiply ( 5 , y = 2 )

6. 10

上面的调用有点繁琐，每次都要传入 y=2 ，我们想到可以定义一个新的函数，把 y=2 作为默

认值，即：

1. def double ( x , y = 2 ):

2.         return multiply ( x , y )

现在，我们可以这样调用了：

1. >>> double ( 3 )

2. 6

3. >>> double ( 4 )

4. 8

5. >>> double ( 5 )

6. 10

事实上，我们可以不用自己定义 double ，利用 partial ，我们可以这样：

partial 函数

1. from functools import partial

2.

3. double = partial ( multiply , y = 2 )

partial 接收函数 multiply 作为参数，固定 multiply 的参数 y=2 ，并返回一个新

的函数给 double ，这跟我们自己定义 double 函数的效果是一样的。

所以，简单而言， partial 函数的功能就是：把一个函数的某些参数给固定住，返回一个新的函

数。

需要注意的是，我们上面是固定了 multiply 的关键字参数 y=2 ，如果直接使用：

1. double = partial ( multiply , 2 )

则 2 是赋给了 multiply 最左边的参数 x ，不信？我们可以验证一下：

1. from functools import partial

2.

3. def subtraction ( x , y ):

4.          return x - y

5.

6. f = partial ( subtraction , 4 ) # 4 赋给了 x

7. >>> f ( 10 ) # 4 - 10

8. - 6

(1)partial 的功能：固定函数参数，返回一个新的函数。

(2)当函数参数太多，需要固定某些参数时，可以使用 functools.partial 创建一个新的函数。