本文深入探讨了Python中的函数式编程概念，包括filter()函数用于根据条件筛选序列元素，map()函数将函数应用于序列的每个元素并返回新列表，reduce()函数通过累积操作减少序列到单个值。此外，还介绍了闭包的概念，展示了如何在内层函数中访问和使用外层函数的作用域，以及闭包在提供运行环境方面的应用。
Python函数式编程：
函数式编程：
也称作泛函编程，是一种编程范型，说白了就是实现可以把函数当参数传递给另一个函数；
它将电脑运算视为数学上的函数计算，并且避免状态以及可变数据；
函数式编程语言最重要的基础是lambda演算，而且lambda演算的函数可以接受函数当作输入和输出
Python支持有限的函数式编程功能：
filter(func,seq)：
调用一个布尔函数func来迭代遍历每个seq中的元素；返回一个使func返回值为true的元素的序列
1
2
3
4
5
6
7
8
9
10
11In [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个元组的列表
1
2
3
4
5
6
7
8
9
10
11
12
13In [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')]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17In [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就是实现折叠功能
1
2
3
4
5
6
7
8
9
10
11In [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（词法闭包）。是指函数及相关的环境组成的整体。
闭包指的就是一个内层函数和所处的环境（外层函数）所构成的内容所组成的整体。
闭包只是在形式和表现上像函数，但事实上闭包自身并不是函数。
闭包从其表现的形式上可以解释为函数在嵌套环境中，如果在一个内层函数里对外层函数作用域中的变量进行了引用，那么在外层函数返回后，内层函数依然可以使用其外层函数中被引用的变量，这种变量就构成了内层函数可以使用的环境。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16In [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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15In [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).'
对于外层函数中的变量施加了修改，内层函数也就相应的受到影响，所以说外层函数给内层函数提供了一个运行环境，这就叫做闭包。
扫一扫
266
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
