python之函数式编程与函数闭包

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了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).‘

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


本文出自 “忘情博” 博客,请务必保留此出处http://itchentao.blog.51cto.com/5168625/1885110

以上是关于python之函数式编程与函数闭包的主要内容,如果未能解决你的问题,请参考以下文章

python中的函数式编程与装饰器

kotlin学习笔记之闭包

kotlin学习笔记之闭包

python进阶一(函数式编程)2-6 python中闭包

Python 函数式编程 —— 闭包

python_函数式编程