python之函数式编程与函数闭包-白红宇

Python函数式编程：

函数式编程：

也称作泛函编程，是一种编程范型，说白了就是实现可以把函数当参数传递给另一个函数；

它将电脑运算视为数学上的函数计算，并且避免状态以及可变数据；

函数式编程语言最重要的基础是lambda演算，而且lambda演算的函数可以接受函数当作输入和输出

Python支持有限的函数式编程功能：

filter(func,seq)：

调用一个布尔函数func来迭代遍历每个seq中的元素；返回一个使func返回值为true的元素的序列

                            
In [
1
]: 
def
a(x):
   
...:     
if
x > 
20
:
   
...:         
return
True
   
...:     
else
:
   
...:         
return
False
   
...: 
In [
2
]: l1 
=
[
1
,
2
,
3
,
4
,
20
,
21
,
25
,
40
,
50
,
32
,
47
]
In [
3
]: 
filter
(a,l1)
Out[
3
]: [
21
, 
25
, 
40
, 
50
, 
32
, 
47
]
         
       

filter()是一个过滤器：

filter()为已知的序列的每个元素调用给定的布尔函数；

调用中，返回值为非零值的元素将被添加至一个列表中

map(func,seq1[,seq2...])：

将函数func作用于给定序列(s)的每个元素，并用一个列表来提供返回值；

如果func为None，func表现为一个身份函数，返回一个含有每个序列中元素集合的n个元组的列表

                            
In [
1
]: l1 
=
[
0
,
1
,
2
,
3
,
4
,
5
,
6
]
In [
2
]: l2 
=
[
'Sun'
,
'Mon'
,
'Tue'
,
'Wed'
,
'Thu'
,
'Fri'
,
'Sat'
]
In [
3
]: 
map
(
None
,l1,l2)
Out[
3
]:
[(
0
, 
'Sun'
),
 
(
1
, 
'Mon'
),
 
(
2
, 
'Tue'
),
 
(
3
, 
'Wed'
),
 
(
4
, 
'Thu'
),
 
(
5
, 
'Fri'
),
 
(
6
, 
'Sat'
)]
         
       

                            
In [
4
]: l1 
=
[
0
,
1
,
2
,
3
,
4
,
5
,
6
]
In [
5
]: l2 
=
[
'Sun'
,
'Mon'
,
'Tue'
,
'Wed'
,
'Thu'
,
'Fri'
,
'Sat'
]
In [
6
]: 
def
a(x,y):            
#这里的函数参数个数要与map函数中序列的个数一致
   
...:     
return
x
*
2
,y
*
2
   
...:
In [
7
]: 
map
(a,l1,l2)
Out[
7
]:
[(
0
, 
'SunSun'
),
 
(
2
, 
'MonMon'
),
 
(
4
, 
'TueTue'
),
 
(
6
, 
'WedWed'
),
 
(
8
, 
'ThuThu'
),
 
(
10
, 
'FriFri'
),
 
(
12
, 
'SatSat'
)]
         
       

map()是一个映射器；

map()将函数调用“映射”到每个序列的对应元素上并返回一个含有所有返回值的列表。说白点也就是它能将不同序列的同一个位置上的元素通过func函数处理后整合成一个元组，最后生成一个元组列表

带有单个队列的map()如下图所示：

带有多个队列的map()如下图所示：

reduce(func,seq[,init])：

将二元函数作用于seq序列的元素，每次携带一对（先前的结果以及下一个序列元素），连续地将现有的结果和下一个值作用在获得的随后的结果上，最后减少我们的序列为一个单一的返回值；如果初始值init给定，第一个比较会是init和第一个序列元素而不是序列的头两个元素

说白点reduce就是实现折叠功能

                            
In [
9
]: l1 
=
[
0
,
1
,
2
,
3
,
4
,
5
,
6
]
In [
10
]: 
def
a(x,y):
    
...:     
return
x 
+
y
    
...:
In [
11
]: 
reduce
(a,l1)        
#返回所有参数之和
Out[
11
]: 
21
In [
12
]: 
reduce
(a,l1,
10
)     
#返回所有参数+初始值之和
Out[
12
]: 
31
         
       

Python函数闭包：

闭包叫lexical closure（词法闭包）。是指函数及相关的环境组成的整体。

闭包指的就是一个内层函数和所处的环境（外层函数）所构成的内容所组成的整体。

闭包只是在形式和表现上像函数，但事实上闭包自身并不是函数。

闭包从其表现的形式上可以解释为函数在嵌套环境中，如果在一个内层函数里对外层函数作用域中的变量进行了引用，那么在外层函数返回后，内层函数依然可以使用其外层函数中被引用的变量，这种变量就构成了内层函数可以使用的环境。

                            
In [
1
]: 
def
func1(x):            
#外层函数
   
...:     
def
func2(y):        
#内层函数
   
...:         
return
y 
*
*
x
   
...:     
return
func2
   
...:
In [
2
]: f4 
=
func1(
4
)
In [
3
]: 
type
(f4)
Out[
3
]: function
In [
4
]: f4(
2
)
Out[
4
]: 
16
In [
5
]: f4(
3
)
Out[
5
]: 
81
         
       

                            
In [
6
]: 
def
startPos(m,n):        
#象棋起始位置
   
...:     
def
newPos(x,y):      
#象棋新位置
   
...:         
return
"The old position is (%d,%d),and the new position is (%d,%d)."
%
(m,n,m
+
x,n
+
y)
   
...:     
return
newPos
   
...:
In [
7
]: action 
=
startPos(
10
,
10
)
In [
8
]: action(
1
,
2
)
Out[
8
]: 
'The old position is (10,10),and the new position is (11,12).'
In [
9
]: action 
=
startPos(
11
,
12
)
In [
10
]: action(
3
,
-
2
)
Out[
10
]: 
'The old position is (11,12),and the new position is (14,10).'
         
       

对于外层函数中的变量施加了修改，内层函数也就相应的受到影响，所以说外层函数给内层函数提供了一个运行环境，这就叫做闭包。

本文转自忘情OK 51CTO博客，原文链接：http://blog.51cto.com/itchentao/1885110，如需转载请自行联系原作者