更新时间:2022-08-17 07:47:03
Python函数式编程:
函数式编程:
也称作泛函编程,是一种编程范型,说白了就是实现可以把函数当参数传递给另一个函数;
它将电脑运算视为数学上的函数计算,并且避免状态以及可变数据;
函数式编程语言最重要的基础是lambda演算,而且lambda演算的函数可以接受函数当作输入和输出
Python支持有限的函数式编程功能:
filter(func,seq):
调用一个布尔函数func来迭代遍历每个seq中的元素;返回一个使func返回值为true的元素的序列
1
2
3
4
5
6
7
8
9
10
11
|
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个元组的列表
1
2
3
4
5
6
7
8
9
10
11
12
13
|
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' )]
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
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就是实现折叠功能
1
2
3
4
5
6
7
8
9
10
11
|
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(词法闭包)。是指函数及相关的环境组成的整体。
闭包指的就是一个内层函数和所处的环境(外层函数)所构成的内容所组成的整体。
闭包只是在形式和表现上像函数,但事实上闭包自身并不是函数。
闭包从其表现的形式上可以解释为函数在嵌套环境中,如果在一个内层函数里对外层函数作用域中的变量进行了引用,那么在外层函数返回后,内层函数依然可以使用其外层函数中被引用的变量,这种变量就构成了内层函数可以使用的环境。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
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
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
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).'
|
对于外层函数中的变量施加了修改,内层函数也就相应的受到影响,所以说外层函数给内层函数提供了一个运行环境,这就叫做闭包。