1.python中一切皆对象

首先从概念上看“在python中, 函数本身也是对象”

当执行:

alist = [1, 2, 3]

时,你就创建了一个列表对象,并且用alist这个变量引用它。

也可以自己定义一个类:

class House(object):
    def __init__(self, area, city):
        self.area = area
        self.city = city

    def sell(self, price):
        [....] #other code
        return price

然后创建一个类的对象:

houce = House(200, 'Shanghai')

这个对象有一些属性(area, city)和一些方法(__init__, self):

1

2.函数是第一类对象

和list, tuple, dict以及用House创建的对象一样,当你定义一个函数时,函数也是对象:

def func(a, b):
    return a+b

在全局域,函数对象被函数名引用着,他接收两个参数a和b,计算这两个参数的和作为返回值

所谓第一类对象,意思是可以用标识符给对象命名,并且对象可以被当做数据处理,例如赋值、作为参数传递给函数,或者作为返回值return等

因此,可以用其他变量名引用这个函数对象:

add = func

2

这样就可以像调用func(1, 2)一样,通过新的引用调用函数了:

print func(1, 2)
print add(1, 2)

3
3

也可以将函数对象作为参数,传递给另一个函数:

def caller_func(f):
    return f(1, 2)

if __name__ = "__main__":
    print caller_func(func)

3

由此看出

  • 函数对象func作为参数传递给caller_func函数,传参过程类似于一个赋值操作:f = func
  • 于是func函数对象,被caller_func函数作用域中的局部变量f引用,f实际指向了函数func
  • 当执行return f(1, 2)的时候,相当于执行了return func(1, 2)

因此结果输出为3

3.函数对象 vs 函数调用

无论是把函数赋值给新的标识符,还是作为参数传递给新的函数,针对的都是函数对象本身,而不是函数的调用

例如定义了下面这个函数:

def func():
    return "hello, world"

然后分别执行两次赋值:

ref1 = func #将函数对象赋值给ref1
ref2 = func() #调用函数, 将函数的返回值赋值给ref2

这两种赋值容易混淆,可以通过type函数来查看一下两次赋值的类型:

type(ref1)
function
type(ref2)
str

可以看到,ref1引用了函数对象本身, 而ref2则引用了函数的返回值,通过内建的callable函数,可以进一步验证ref1是可调用的,而ref2是不可调用的:

callable(ref1)
True
callable(ref2)
False

传参的的效果类似

4.闭包&LEGB法则

所谓闭包,就是将组成函数的语句和这些语句的执行环境打包在一起时,得到的对象

假设在foo.py模块中作了如下定义:

#foo.py
filename = "foo.py"

def call_func(f):
    return f() # f引用了一个函数对象,然后调用它

在另一个func.py的模块,写下了这样的代码:

#func.py
import foo #导入foo.py

filename = "func.py"
def show_filename():
    return "filename: %s" % filename

if __name__ =="__main__":
    print foo.call_func(show_filename) #实际发生调用的位置,是在foo.call_func函数中

当我们用python func.py命令执行func.py时输出结果为:

filename:func.py

可以看出show_filename()函数使用的filename变量的值,是在与它相同环境(func.py)中定义的那个,尽管foo.py模块中也定义了同名的filename变量,而且实际调用show_filename的位置也是在foo.pycall_func内部

而对于嵌套函数,这一机制则会表现得更加明显:闭包将会捕捉内层函数执行所需的整个环境

#enclosed.py
import foo
def wrapper():
    filename = "enclosed.py"
    def show_filename()
        return "filename: %s" % filename
    print foo.call_func(show_filename) #输出filename: enclosed.py

实际上,每一个函数对象,都有一个指向了该函数定义时所在全局名称空间的__global__属性:

{
#show_filename inside wrapper
#show_filename.__globals__
"__builtins__":<module "__builtin__"(built-in)>,
"__file__": "enclosed.py",
"wrapper":<function wrapper at 0x7f84768b6578>,
"__package__":None,
"__name__":"__main__",
"foo":<module "foo"from "/mystuff/foo.pyc">
"__doc__": None
}

当代码执行到show_filename中的return"filename: %s" %filename语句时,解析器按照下面顺序查找filename变量:

Local:本地函数(show_filename)内部,通过任何方式赋值的,而且没有被global关键字声明为全局变量的filename变量

Enclosing:直接外围空间(上层函数wrapper)的本地作用域,查找filename变量(如果有多层嵌套,则由内而外逐层查找,直至最外层的函数)

Global:全局空间(模块enclosed.py),在模块顶层赋值的filename变量

Builtin:内置模块(__builtin__)中预定义的变量名中查找filename变量

在任何一层先找到了符合要求的filename变量,则不再向更外层查找,如果知道Builtin层仍然没有找到符合要求的变量,则抛出NameError异常,这就是变量名解析的:LEGB法则

总结: 闭包最重要的使用价值在于:封存函数执行的上下文环境

闭包在其捕捉的执行环境(def语句块所在上下文)中,也遵循LEGB规则逐层查找,直至找到符合要求的变量,或者抛出异常

5.装饰器 (syntax sugar)

闭包和装饰器之间的关系:

上文提到闭包的重要特性:封存上下文,这一特性可以巧妙地被用于现有函数的包装,从而为现有函数增加功能,此乃装饰器

举个栗子:

#alist = [1, 2, 3, ..., 100] --> 1+2+3+...+100 = 5050
def lazy_sum():
    return reduce(lambda x, y: x+y, alist)

我们定义了一个函数lazy_sum,作用是对alist中的所有元素求和后返回,alist假设是1到100的整数列表

alist = range(1, 101)

但是出于某种原因不想马上返回计算结果,而是在之后的某个地方,通过显示的调用输出结果,于是用一个wrapper函数对其进行包装:

def wrapper():
    alist = range(1, 101)
    def lazy_sum():
        return reduce(lambda x, y: x+y, alist)
    return lazy_sum

lazy_sum = wrapper()

if __name__ == "__main__":
    lazy_sum() #5050

这是一个典型的Lazy Evaluation的例子,一般情况下,局部变量在函数返回时,就会被垃圾回收器回收,而不能再被使用,但是这里的alist却没有,它随着lazy_sum函数对象的返回被一并返回了(实际是包含在了lazy_sum的执行环境中,通过__globals__),从而延长了生命周期

当在if语句块中调用lazy_sum()的时候,解析器会从上下文中(这里是Enclosing层的wrapper函数的局部作用域中)找到alist列表,计算结果,返回5050

当你需要动态的给已定义的函数增加功能时,比如:参数检查,类似的的原理就变得很有用:

def add(a, b):
    return a+b

这是很简单的一个函数:计算a+b的和返回,但我们知道Python是 动态类型+强类型 的语言,你并不能保证用户传入的参数a和b一定是两个整型,他可能传入了一个整型和一个字符串类型的值,这时,解析器就会抛出一个TypeError异常.

动态类型:在运行期间确定变量的类型,python确定一个变量的类型是在你第一次给他赋值的时候.

强类型:有强制的类型定义,你有一个整数,除非显示的类型转换,否则绝不能将它当作一个字符串(比如直接尝试将一个整型和一个字符串做“+”运算)

因此,为了更加优雅的使用add函数,我们需要在执行+运算前,对a和b进行参数检查,这时候装饰器就很有用了

import logging

logging.basicConfig(level = logging.INFO)

def add(a, b):
    return a + b

def checkParams(fn):
    def wrapper(a, b):
        if isinstance(a,(int, float)) and isinstance(b, (int, float)):
            return fn(a, b)
        # 如果参数类型不正确,则同通过logging记录错误信息并友好退出
        logging.warning("variable 'a' and 'b' cannot be added")
        return
    return wrapper # fn引用add,被封存在闭包的执行环境中返回

if __name__ == "__main__":
    #将add函数对象传入,fn指向add
    #等号左侧的add,指向checkParams的返回值wrapper
    add = checkParams(add)
    add(3, "hello") # 经过类型检查,不会计算结果,而是记录日志并退出

注意checkParams函数

首先看参数fn,当我们调用checkParams(add)的时候,它将成为函数对象add的一个本地(L)引用

checkParams内部,我们定义了一个wrapper函数,添加了参数类型检查的功能,然后调用了fn(a, b),根据LEGB法则,解释器将搜索几个作用域,并最终在(Enclosing层)checkParams函数的本地作用域中找到fn

注意最后的return wrapper,这将创建一个闭包, fn变量(add函数对象的一个引用)将会封存在闭包的执行环境中,不会随着checkParams的返回而被回收

当调用add(3, “Hello”)将不会返回计算结果,而是打印出日志

有人觉得add = checkParams(add) 这样的写法太过麻烦,于是python提供了一种更优雅的写法,称之为 语法糖

@checkParams
def add(a, b):
    return a + b

这只是一种写法上的优化,解释器仍然会将它转化为add = checkParams(add)来执行

6.回归问题

def addspam(fn):
    def new(*args):
        print "spam, spam, spam"
        return fn(*args)
    return new

@addspam
def useful(a, b):
    print a**2 + b**2

首先看第二段代码:

@addspam装饰器,相当于执行了useful = addspam(useful),这里有个理解误区:传递给addspam的参数,是useful这个函数对象本身,而不是它的一个调用结果

再回到addspam函数体:

return new 返回一个闭包,fn被封存在闭包的执行环境中,不会随着addspam函数的返回被回收

fn此时是useful的一个引用,当执行return fn(*args)时,实际相当于执行了return useful(*args)

附代码执行过程中的引用关系图: 4


资料来源: 知乎 - Python 里为什么函数可以返回一个函数内部定义的函数? - 陈伟的精彩回答