摘要：重寫(xiě)內(nèi)建名字空間中的函數(shù)閉包閉包是詞法閉包的簡(jiǎn)稱。另一種說(shuō)法認(rèn)為閉包是由函數(shù)和與其相關(guān)的引用環(huán)境組合而成的實(shí)體。

Python 中的 Decorator(裝飾器) 是對(duì)一個(gè)函數(shù)或者方法的封裝，從而使其可以完成一些與自身功能無(wú)關(guān)的工作。

在 Python 中，所有的一切都被視為對(duì)象，任何的變量、函數(shù)、類(lèi)等都是 object 的子類(lèi)。因此除了變量之外，函數(shù)和類(lèi)等也可以被指向和傳遞。

>>> def foo():
...     pass
...
>>> def Foo():
...     pass
...
>>> v = foo
>>> v

>>> v = Foo
>>> v

Python 通過(guò)提供 namespace 來(lái)實(shí)現(xiàn)重名函數(shù)/方法、變量等信息的識(shí)別。其大致可以分為三種 namespace，分別為：

local namespace: 局部空間，作用范圍為當(dāng)前函數(shù)或者類(lèi)方法

global namespace: 全局空間，作用范圍為當(dāng)前模塊

build-in namespace: 內(nèi)建空間，在 Python 解釋器啟動(dòng)時(shí)就已經(jīng)具有的命名空間，作用范圍為所有模塊。例如：abs，all，chr，cmp，int，str 等內(nèi)建函數(shù)，它們?cè)诮忉屍鲉?dòng)時(shí)就被自動(dòng)載入。

當(dāng)函數(shù)/方法、變量等信息發(fā)生重名時(shí)，Python 會(huì)按照 local namespace -> global namespace -> build-in namespace 的順序搜索用戶所需元素，并且以第一個(gè)找到此元素的 namespace 為準(zhǔn)。

>>> # 重寫(xiě)內(nèi)建名字空間中的 str 函數(shù)
>>> def str(obj):
...     print "This is str"
...
>>> str(1)
This is str

閉包（Closure）是詞法閉包（Lexical Closure）的簡(jiǎn)稱。簡(jiǎn)單地說(shuō)，閉包就是根據(jù)不同的配置信息得到不同的結(jié)果。對(duì)閉包的具體定義有很多種說(shuō)法，大致可以分為兩類(lèi)：

一種說(shuō)法認(rèn)為閉包是符合一定條件的函數(shù)，比如一些參考資源中這樣定義閉包：閉包是在其詞法上下文中引用了自由變量的函數(shù)。

另一種說(shuō)法認(rèn)為閉包是由函數(shù)和與其相關(guān)的引用環(huán)境組合而成的實(shí)體。比如一些參考資源中這樣來(lái)定義：在實(shí)現(xiàn)深約束時(shí)，需要?jiǎng)?chuàng)建一個(gè)能顯式表示引用環(huán)境的東西，并將它與相關(guān)的子程序捆綁在一起，這樣捆綁起來(lái)的整體被稱為閉包。

以上兩種定義從某種意義上來(lái)說(shuō)是對(duì)立的，一個(gè)認(rèn)為閉包是函數(shù)，另一個(gè)認(rèn)為閉包是函數(shù)和引用環(huán)境組成的整體。閉包確實(shí)可以認(rèn)為就是函數(shù)，但第二種說(shuō)法更確切些。閉包只是在形式和表現(xiàn)上像函數(shù)，但實(shí)際上不是函數(shù)。函數(shù)是一些可執(zhí)行的代碼，這些代碼在函數(shù)被定義后就確定了，不會(huì)在執(zhí)行時(shí)發(fā)生變化，所以一個(gè)函數(shù)只有一個(gè)實(shí)例。

閉包在運(yùn)行時(shí)可以有多個(gè)實(shí)例，不同的引用環(huán)境和相同的函數(shù)組合可以產(chǎn)生不同的實(shí)例。所謂引用環(huán)境是指在程序執(zhí)行中的某個(gè)點(diǎn)所有處于活躍狀態(tài)的約束所組成的集合。其中的約束是指一個(gè)變量的名字和其所代表的對(duì)象之間的聯(lián)系。那么為什么要把引用環(huán)境與函數(shù)組合起來(lái)呢？這主要是因?yàn)樵谥С智短鬃饔糜虻恼Z(yǔ)言中，有時(shí)不能簡(jiǎn)單直接地確定函數(shù)的引用環(huán)境。

在 Python 語(yǔ)言中，可以這樣簡(jiǎn)單的理解閉包：一個(gè)閉包就是調(diào)用了一個(gè)函數(shù) A，這個(gè)函數(shù) A 返回了一個(gè)函數(shù) B。這個(gè)返回的函數(shù) B 就叫做閉包。在調(diào)用函數(shù) A 的時(shí)候傳遞的參數(shù)就是對(duì)不同引用環(huán)境所做的配置。如下示例所示：

>>> def make_adder(addend):
...     def adder(augend):
...         return augend + addend
...     return adder
...
>>> add1 = make_adder(11)
>>> add2 = make_adder(22)
>>> add1(100)
111
>>> add2(100)
122

函數(shù)式編程指使用一系列的函數(shù)解決問(wèn)題。函數(shù)僅接受輸入并產(chǎn)生輸出，不包含任何能影響產(chǎn)生輸出的內(nèi)部狀態(tài)。任何情況下，使用相同的參數(shù)調(diào)用函數(shù)始終能產(chǎn)生同樣的結(jié)果。

函數(shù)式編程就是一種抽象程度很高的編程范式，純粹的函數(shù)式編程語(yǔ)言編寫(xiě)的函數(shù)沒(méi)有變量，因此，任意一個(gè)函數(shù)，只要輸入是確定的，輸出就是確定的，這種純函數(shù)我們稱之為沒(méi)有副作用。而允許使用變量的程序設(shè)計(jì)語(yǔ)言，由于函數(shù)內(nèi)部的變量狀態(tài)不確定，同樣的輸入，可能得到不同的輸出，因此，這種函數(shù)是有副作用的。函數(shù)式編程的一個(gè)特點(diǎn)就是，允許把函數(shù)本身作為參數(shù)傳入另一個(gè)函數(shù)，還允許返回一個(gè)函數(shù)！

可以認(rèn)為函數(shù)式編程剛好站在了面向?qū)ο缶幊痰膶?duì)立面。對(duì)象通常包含內(nèi)部狀態(tài)（字段），和許多能修改這些狀態(tài)的函數(shù)，程序則由不斷修改狀態(tài)構(gòu)成；函數(shù)式編程則極力避免狀態(tài)改動(dòng)，并通過(guò)在函數(shù)間傳遞數(shù)據(jù)流進(jìn)行工作。但這并不是說(shuō)無(wú)法同時(shí)使用函數(shù)式編程和面向?qū)ο缶幊蹋聦?shí)上，復(fù)雜的系統(tǒng)一般會(huì)采用面向?qū)ο蠹夹g(shù)建模，但混合使用函數(shù)式風(fēng)格也能體現(xiàn)函數(shù)式風(fēng)格的優(yōu)點(diǎn)。

高階函數(shù)即能接受函數(shù)作為參數(shù)的函數(shù)。因?yàn)樵?Python 中一切皆對(duì)象，變量可以指向函數(shù)，函數(shù)名其實(shí)也是指向函數(shù)的變量。也就是說(shuō)，我們可以將函數(shù)賦給其他變量，也就可以將函數(shù)作為參數(shù)傳遞給其他函數(shù)。

>>> def add(x, y, f):
...     return f(x) + f(y)
...
>>> add(6, -9, abs)
15

Python 裝飾器的作用就是為已經(jīng)存在的對(duì)象添加額外的功能。例如裝飾器可以用來(lái) 引入日志、添加計(jì)時(shí)邏輯來(lái)檢測(cè)性能、給函數(shù)加入事務(wù)處理 等等。其實(shí)總體說(shuō)起來(lái)，裝飾器也就是一個(gè)函數(shù)，一個(gè)用來(lái)包裝函數(shù)的函數(shù)。裝飾器在函數(shù)申明完成的時(shí)候被調(diào)用，調(diào)用之后申明的函數(shù)被換成一個(gè)被裝飾器裝飾過(guò)后的函數(shù)。簡(jiǎn)單說(shuō)，本質(zhì)上，裝飾器就是一個(gè)返回函數(shù)的高階函數(shù)，也是一個(gè)閉包。

裝飾器的語(yǔ)法以 @ 開(kāi)頭，接著是裝飾器要裝飾的函數(shù)的申明。

先來(lái)看一下裝飾器本身沒(méi)有參數(shù)的情況。例如，我們想要知道一個(gè)函數(shù)被調(diào)用時(shí)所花的時(shí)間，可以采用如下的方式實(shí)現(xiàn)：

# Author: Huoty
# Time: 2015-08-12 10:37:10

import time

def foo():
    print "in foo()"

# 定義一個(gè)計(jì)時(shí)器，傳入一個(gè)函數(shù)，并返回另一個(gè)附加了計(jì)時(shí)功能的方法
def timeit(func):

    # 定義一個(gè)內(nèi)嵌的包裝函數(shù)，給傳入的函數(shù)加上計(jì)時(shí)功能的包裝
    def wrapper():
        start = time.clock()
        func()
        end = time.clock()
        print "used:", end - start

    # 將包裝后的函數(shù)返回
    return wrapper

# Script starts from here

foo = timeit(foo)
foo()

Python 實(shí)現(xiàn)裝飾器的目的就是為了讓程序更加簡(jiǎn)潔，上邊的代碼可以繼續(xù)用裝飾器來(lái)簡(jiǎn)化：

# Author:  Huoty
# Time: 2015-08-12 10:37:10

import time

def timeit(func):
    def wrapper():
        start = time.clock()
        func()
        end =time.clock()
        print "used:", end - start
    return wrapper

@timeit
def foo():
    print "in foo()"

# Script starts from here

foo()

由上例可以看出，裝飾器 @timeit 的作用等價(jià)與 foo = timeit(foo)。被裝飾器裝飾后的執(zhí)行結(jié)果取決于裝飾函數(shù)的是想，如果裝飾函數(shù)返回被裝飾函數(shù)本身，就等于沒(méi)有裝飾，如果裝飾函數(shù)對(duì)被裝飾函數(shù)進(jìn)行了包裝，并返回包裝后的函數(shù)，那調(diào)用函數(shù)時(shí)執(zhí)行的就是包裝過(guò)的函數(shù)。

如果被裝飾的函數(shù)帶有參數(shù)，則在裝飾器中也應(yīng)該為包裝函數(shù)提供對(duì)應(yīng)的參數(shù)。如果被裝飾的函數(shù)參數(shù)不確定，則可以用如下方式實(shí)現(xiàn)：

# Author:  Huoty
# Time: 2015-08-12 10:59:11

import time

def log(func):
    def wrapper(*args, **kw):
        print "call %s." % func.__name__
        return func(*args, **kw)
    return wrapper

@log
def now():
    print time.asctime()

# Script starts from here

now()

裝飾器本身也可以帶參數(shù)，但是通常對(duì)參數(shù)會(huì)有一定的要求。由于有參數(shù)的裝飾器函數(shù)在調(diào)用時(shí)只會(huì)使用應(yīng)用時(shí)的參數(shù)，而不接收被裝飾的函數(shù)做為參數(shù)，所以必須在其內(nèi)部再創(chuàng)建一個(gè)函數(shù)。如下示例所示：

# Author:  Huoty
# Time: 2015-08-12 11:13:30

def deco(arg):
    def _deco(func):
        def __deco():
            print("before %s called [%s]." % (func.__name__, arg))
            func()
            print("  after %s called [%s]." % (func.__name__, arg))
        return __deco
    return _deco

@deco("module")
def foo():
    print(" foo() called.")

@deco("module2")
def hoo():
    print(" hoo() called.")

# Script starts from here

foo()
hoo()

上例中的第一個(gè)函數(shù) deco 是裝飾器函數(shù)，它的參數(shù)是用來(lái)加強(qiáng) 加強(qiáng)裝飾 的。由于此函數(shù)并非被裝飾的函數(shù)對(duì)象，所以在內(nèi)部必須至少創(chuàng)建一個(gè)接受被裝飾函數(shù)的函數(shù)，然后返回這個(gè)對(duì)象（實(shí)際上此時(shí)等效于 foo=decomaker(arg)(foo)）。

如果裝飾器和被裝飾函數(shù)都帶參數(shù)，則用如下實(shí)現(xiàn)是形式：

def deco(pm):
    def _deco(func):
        def __deco(*args, **kw):
            ret =func(*args, **kw)
            print "func result: ", ret
            return ret ** pm
        return __deco
    return _deco

@deco(2)
def foo(x, y, z=1):
    return x + y + z

print "deco_func result: %s" % foo(10, 20)

輸出：

func result:  31
deco_func result: 961

裝飾器不經(jīng)可以用來(lái)裝飾函數(shù)，還可以用來(lái)裝飾類(lèi)。例如給類(lèi)添加一個(gè)類(lèi)方法：

>>> def bar(obj):
...     print type(obj)
...
>>> def inject(cls):
...     cls.bar = bar
...     return cls
...
>>> @inject
... class Foo(object):
...     pass
...
>>> foo = Foo()
>>> foo.bar()

內(nèi)置的裝飾器有三個(gè)，分別是 staticmethod、classmethod 和 property，作用分別是把類(lèi)中定義的實(shí)例方法變成靜態(tài)方法、類(lèi)方法和類(lèi)屬性。由于模塊里可以定義函數(shù)，所以靜態(tài)方法和類(lèi)方法的用處并不是太多，除非你想要完全的面向?qū)ο缶幊?。這三個(gè)裝飾器的實(shí)現(xiàn)都涉及到 描述符 的概念。

Python的functools模塊主要功能是對(duì)函數(shù)進(jìn)行包裝，增加原有函數(shù)的功能，起主要內(nèi)容包括：cmp_to_key, partial, reduce, total_ordering, update_wrapper, wraps。

函數(shù)也是一個(gè)對(duì)象，它有__name__等屬性。以上我們有一個(gè) callin.py 的例子，我們用裝飾器裝飾之后的 now 函數(shù)，當(dāng)我們用 now.__name__ 查看時(shí)，發(fā)現(xiàn)它的 __name__ 已經(jīng)從原來(lái)的"now"變成了"wrapper"。因?yàn)榉祷氐哪莻€(gè)wrapper()函數(shù)名字就是"wrapper"，所以，需要把原始函數(shù)的name等屬性復(fù)制到wrapper()函數(shù)中，否則，有些依賴函數(shù)簽名的代碼執(zhí)行就會(huì)出錯(cuò)。當(dāng)然，我們可以用wrapper.__name__ = func.__name__來(lái)實(shí)現(xiàn)，但是我們不必這么麻煩，用 Python 內(nèi)置的 functools.wraps 便可實(shí)現(xiàn)這樣的功能：

import functools

def log(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            print("%s %s():" % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator

除了可以用函數(shù)來(lái)實(shí)現(xiàn)裝飾器外，類(lèi)也可以實(shí)現(xiàn)。Python 類(lèi)有一個(gè) __call__ 方法，它能夠讓對(duì)象可調(diào)用。因此可以用該特性來(lái)實(shí)現(xiàn)裝飾器。例如實(shí)現(xiàn)一個(gè)磁盤(pán)緩存：

import os
import uuid
import glob
import pickle


class DiskCache(object):

    _NAMESPACE = uuid.UUID("c875fb30-a8a8-402d-a796-225a6b065cad")

    def __init__(self, func):
        self._func = func
        self.__name__ = func.__name__
        self.__module__ = func.__module__
        self.__doc__ = func.__doc__

        self.cache_path = "/tmp/.diskcache"

    def __call__(self, *args, **kw):
        params_uuid = uuid.uuid5(self._NAMESPACE, "-".join(map(str, (args, kw))))
        key = "{}-{}.cache".format(self._func.__name__, str(params_uuid))
        cache_file = os.path.join(self.cache_path, key)

        if not os.path.exists(self.cache_path):
            os.makedirs(self.cache_path)

        try:
            with open(cache_file, "rb") as f:
                val = pickle.load(f)
        except:
            val = self._func(*args, **kw)
            try:
                with open(cache_file, "wb") as f:
                    pickle.dump(val, f)
            except:
                pass
        return val

    def clear_cache(self):
        for cache_file in glob.iglob("{}/{}-*".format(self.cache_path, self.__name__)):
            os.remove(cache_file)

@DiskCache
def add(x, y):
    print "add: %s + %s" % (x, y)
    return x, y

輸出：

add.clear_cache()
print add(1, 2)
print add(2, 3)
print add(1, 2)

print "cached files:", os.listdir(add.cache_path)
add.clear_cache()
print "cached files:", os.listdir(add.cache_path)

本質(zhì)上，內(nèi)置的 property 裝飾器也是一個(gè)類(lèi)，只不過(guò)它是一個(gè)描述符?？梢杂妙?lèi)似的形式實(shí)現(xiàn)一個(gè)可緩存的 property 裝飾器：

class CachedProperty(object):
    def __init__(self, func, name=None, doc=None):
        self.__name__ = name or func.__name__
        self.__module__ = func.__module__
        self.__doc__ = doc or func.__doc__
        self.func = func

    def __get__(self, obj, type=None):
        if obj is None:
            return self
        value = obj.__dict__.get(self.__name__)
        if value is None:
            value = self.func(obj)
            obj.__dict__[self.__name__] = value
        return value


class Foo(object):

    @CachedProperty
    def foo(self):
        print "first calculate"
        result = "this is result"
        return result


f = Foo()

print f.foo
print f.foo

輸出：

first calculate
this is result
this is result

一個(gè)函數(shù)可以同時(shí)被多個(gè)裝飾器裝飾。裝飾的初始化在函數(shù)定義時(shí)完成，初始化順序?yàn)殡x函數(shù)定義最近的裝飾器首先被初始化，最遠(yuǎn)的則最后被初始化，初始化只進(jìn)行一次。而裝飾器的執(zhí)行順序則跟初始化順序相反。

def decorator_a(func):
    print "decorator_a"
    def wrapper(*args, **kw):
        print "call %s in decorator_a" % func.__name__
        return func()
    return wrapper

def decorator_b(func):
    print "decorator_b"
    def wrapper(*args, **kw):
        print "call %s in decorator_b" % func.__name__
        return func()
    return wrapper

@decorator_a
@decorator_b
def foo():
    print "foo"

print "-"*10
foo()
foo()

輸出：

decorator_b
decorator_a
----------
call wrapper in decorator_a
call foo in decorator_b
foo
call wrapper in decorator_a
call foo in decorator_b
foo

有以上示例可以看出，離函數(shù)定義最近的 decorator_b 裝飾器首先被初始化，在執(zhí)行時(shí)則是里函數(shù)定義最遠(yuǎn)的 decorator_a 首先被執(zhí)行。

http://developer.51cto.com/ar...

http://www.cnblogs.com/ma6174...

http://www.cnblogs.com/huxi/a...

http://www.cnblogs.com/rollen...

http://blog.csdn.net/mdl13412...