Python学习9:函数式编程

时间:2021-04-21 22:41:32

1.什么是函数式编程?

 

    函数式编程使用一系列的函数解决问题。函数仅接受输入并产生输出,不包含任何能影响输出的内部状态。任何情况下,使用相同

的参数调用函数始终能产生同样的结果。

    在一个函数式的程序中,输入的数据“流过”一系列的函数,每一个函数根据它的输入产生输出。函数式风格避免编写有“边界效

应”(side effects)的函数:修改内部状态,或者是其他无法反应在输出上的变化。完全没有边界效应的函数被称为“纯函数式的”(purely 

functional)。避免边界效应意味着不使用在程序运行时可变的数据结构,输出只依赖于输入。

     可以认为函数式编程刚好站在了面向对象编程的对立面。对象通常包含内部状态(字段),和许多能修改这些状态的函数,程序

则由不断修改状态构成;函数式编程则极力避免状态改动,并通过在函数间传递数据流进行工作。但这并不是说无法同时使用函数

式编程和面向对象编程,事实上,复杂的系统一般会采用面向对象技术建模,但混合使用函数式风格还能让你额外享受函数式风格

的优点。

 

2. 函数对象的作用域

 

    和其他对象一样,函数对象也有其存活的范围,也就是函数对象的作用域。函数对象是使用def语句定义的,函数对象的作用域与

def所在的层级相同。比如下面代码,我们在line_conf函数的隶属范围内定义的函数line,就只能在line_conf的隶属范围内用。

def line_conf():
def line(x):
return 2*x+1
print(line(5)) # within the scope
line_conf()
print(line(5)) # out of thescope


line函数定义了一条直线(y=2x+1)。可以看到,在line_conf()中可以调用line函数,而在作用域之外调用line将会有下面错误:

NameError: name 'line' is not defined

说明这时已经在作用域之外。同样,如果使用lambda定义函数,那么函数对象的作用域与lambda所在的层级相同。


3. 闭包

 

定义:如果在一个内部函数里,对在外部作用域(但不是在全局作用域)的变量进行引用,那么内部函数就被认为是闭(closure).

     闭包(closure)是函数式编程的重要的语法结构。函数式编程是一种编程范式 (而面向过程编程和面向对象编程也都是编程范式)。

在面向过程编程中,我们见到过函(function);在面向对象编程中,我们见过对象(object)。函数和对象的根本目的是以某种逻辑方式

组织代码,并提高代码的可重复使用性(reusability)。闭包也是一种组织代码的结构,它同样提高了代码的可重复使用性。

def line_conf():
def line(x):
return 2*x+1
return line # return a function object

my_line = line_conf()
print(my_line(5))


       我们可以看到,line定义的隶属程序块中引用了高层级的变量b,但b信息存在于line的定义之外 (b的定义并不在line的隶属程序块

中)。我们称b为line的环境变量。事实上,line作为line_conf的返回值时,line中已经包括b的取值(尽管b并不隶属于line)。

     上面的代码将打印25,也就是说,line所参照的b值是函数对象定义时可供参考的b值,而不是使用时的b值。

      一个函数和它的环境变量合在一起,就构成了一个闭包(closure)。在Python中,所谓的闭包是一个包含有环境变量取值的函数对

象。环境变量取值被保存在函数对象的__closure__属性中。比如下面的代码:

def line_conf():
b = 15
def line(x):
return 2*x+b
return line #return a function object

b = 5
my_line = line_conf()
print(my_line.__closure__)
print(my_line.__closure__[0].cell_contents)

__closure__里包含了一个元组(tuple)。这个元组中的每个元素是cell类型的对象。我们看到第一个cell包含的就是整数15,也就是我

们创建闭包时的环境变量b的取值。

 

下面看一个闭包的实际例子:

def line_conf(a, b):
def line(x):
return ax + b
return line

line1 = line_conf(1, 1)
line2 = line_conf(4, 5)
print(line1(5), line2(5))

      这个例子中,函数line与环境变量a,b构成闭包。在创建闭包的时候,我们通过line_conf的参数a,b说明了这两个环境变量的取值,

这样,我们就确定了函数的最终形式(y = x + 1和y = 4x + 5)。我们只需要变换参数a,b,就可以获得不同的直线表达函数。由此,我们

可以看到,闭包也具有提高代码可复用性的作用。

      如果没有闭包,我们需要每次创建直线函数的时候同时说明a,b,x。这样,我们就需要更多的参数传递,也减少了代码的可移植

性。利用闭包,我们实际上创建了泛函line函数定义一种广泛意义的函数。这个函数的一些方面已经确定(必须是直线),但另一些

方面(比如a和b参数待定)。随后,我们根据line_conf传递来的参数,通过闭包的形式,将最终函数确定下来。

 

4.使用闭包注意事项

 

1) 闭包中是不能修改外部作用域的局部变量的

>>> def foo(): 
... m = 0
... deffoo1():
... m =1
... printm
...
... printm
... foo1()
... printm
...
>>> foo()
0
1
0

从执行结果可以看出,虽然在闭包里面也定义了一个变量m,但是其不会改变外部函数中的局部变量m。


2) 以下这段代码是在python中使用闭包时一段经典的错误代码

def foo(): 
a = 1
def bar():
a = a +1
returna
return bar

这段程序的本意是要通过在每次调用闭包函数时都对变量a进行递增的操作。但在实际使用时

>>> c = foo() 
>>> print c()
Traceback (most recent call last):
File "<stdin>",line 1, in <module>
File "<stdin>",line 4, in bar
UnboundLocalError: local variable 'a' referenced before assignment

      这是因为在执行代码 c = foo()时,python会导入全部的闭包函数体bar()来分析其的局部变量,python规则指定所有在赋值语句

面的变量都是局部变量,则在闭包bar()中,变量a在赋值符号"="的左面,被python认为是bar()中的局部变量。再接下来执行

print c()时,程序运行至a = a + 1时,因为先前已经把a归为bar()中的局部变量,所以python会在bar()中去找在赋值语句右面的a的

值,结果找不到,就会报错。解决的方法很简单

def foo():  
a = [1]
def bar():
a[0] = a[0] + 1
return a[0]
return bar

      只要将a设定为一个容器就可以了。这样使用起来多少有点不爽,所以在python3以后,在a = a + 1 之前,使用语句nonloacal a就

可以了,该语句显式的指定a不是闭包的局部变量。

3 ) 还有一个容易产生错误的事例也经常被人在介绍python闭包时提起,我一直都没觉得这个错误和闭包有什么太大的关系,但是它

倒是的确是在python函数式编程是容易犯的一个错误,我在这里也不妨介绍一下。

先看下面这段代码

for i in range(3):
print i

在程序里面经常会出现这类的循环语句,Python的问题就在于,当循环结束以后,循环体中的临时变量i不会销毁,而是继续存在于

执行环境中。还有一个python的现象是,python的函数只有在执行时,才会去找函数体里的变量的值。

flist = []
for i in range(3):
def foo(x): print x + i
flist.append(foo)
for f in flist:
f(2)


可能有些人认为这段代码的执行结果应该是2,3,4.但是实际的结果是4,4,4。这是因为当把函数加入flist列表里时,python还没有给i赋

值,只有当执行时,再去找i的值是什么,这时在第一个for循环结束以后,i的值是2,所以以上代码的执行结果是4,4,4.

解决方法也很简单,改写一下函数的定义就可以了。

for i in range(3): 
def foo(x,y=i): print x + y
flist.append(foo)