經過長時間學習Python裝飾器，于是和大家分享一下，看完本文你肯定有不少收獲，希望本文能教會你更多東西，學習Python裝飾器時，你可能會遇到Python裝飾器問題，這里將介紹Python裝飾器問題的解決方法，在這里拿出來和大家分享一下。

***個函數deco是裝飾函數，它的參數就是被裝飾的函數對象。我們可以在deco函數內對傳入的函數對象做一番“裝飾”，然后返回這個對象（記住一定要返回 ，不然外面調用foo的地方將會無函數可用。

我寫了個小例子，檢查函數有沒有說明文檔：、

static PyObject* thread_PyThread_start_new_thread(PyObject *self, PyObject  
 
  *fargs)  
 
{  
 
    PyObject *func, *args, *keyw = NULL;  
 
    struct bootstate *boot;  
 
    long ident;  
 
    PyArg_UnpackTuple(fargs, "start_new_thread", 2, 3, &func, &args, &keyw);  
 
    //[1]：創建bootstate結構  
 
    boot = PyMem_NEW(struct bootstate, 1);  
 
    boot->interp = PyThreadState_GET()->interp;  
 
    boot->funcfunc = func;  
 
    boot->argsargs = args;  
 
    boot->keywkeyw = keyw;  
 
    //[2]：初始化多線程環境  
 
    PyEval_InitThreads(); /* Start the interpreter's thread-awareness */  
 
    //[3]：創建線程  
 
    ident = PyThread_start_new_thread(t_bootstrap, (void*) boot);  
 
    return PyInt_FromLong(ident);  
 
[thread.c]  
 
/* Support for runtime thread stack size tuning.  
 
   A value of 0 means using the platform's default stack size  
 
   or the size specified by the THREAD_STACK_SIZE macro. */  
 
static size_t _pythread_stacksize = 0;  
 
[thread_nt.h]  
 
long PyThread_start_new_thread(void (*func)(void *), void *arg)  
 
{ 

Python裝飾器是裝飾函數，它的參數是用來加強“加強裝飾”的。由于此函數并非被裝飾的函數對象，所以在內部必須至少創建一個接受被裝飾函數的函數，然后返回這個對象（實際上此時foo=decomaker(arg)(foo)）。

這個我還真想不出什么好例子，還是見識少啊，只好借用同步鎖的例子了：

def synchronized(lock):     
    """鎖同步裝飾方法    
    ！lock必須實現了acquire和release方法    
    """    
    def sync_with_lock(func):     
        def new_func(*args, **kwargs):     
            lock.acquire()     
            try:     
                return func(*args, **kwargs)     
            finally:     
                lock.release()     
        new_func.func_name = func.func_name     
        new_func.__doc__ = func.__doc__     
        return new_func     
    return sync_with_lock    
@synchronized(__locker)     
def update(data):     
"""更新計劃任務"""    
    tasks = self.get_tasks()     
    delete_task = None    
    for task in tasks:     
        if task[PLANTASK.ID] == data[PLANTASK.ID]:     
            tasks.insert(tasks.index(task), data)     
            tasks.remove(task)     
            delete_task = task     
    r, msg = self._refresh(tasks, delete_task)     
    return r, msg, data[PLANTASK.ID]   

調用時還是updae(data)，同時還可以將多個裝飾器組合 使用：

def synchronized(lock):     
    """鎖同步裝飾方法    
    ！lock必須實現了acquire和release方法    
    """    
    def sync_with_lock(func):     
        def new_func(*args, **kwargs):     
            lock.acquire()     
            try:     
                return func(*args, **kwargs)     
            finally:     
                lock.release()     
        new_func.func_name = func.func_name     
        new_func.__doc__ = func.__doc__     
        return new_func     
    return sync_with_lock    
@synchronized(__locker)     
def update(data):     
"""更新計劃任務"""    
    tasks = self.get_tasks()     
    delete_task = None    
    for task in tasks:     
        if task[PLANTASK.ID] == data[PLANTASK.ID]:     
            tasks.insert(tasks.index(task), data)     
            tasks.remove(task)     
            delete_task = task     
    r, msg = self._refresh(tasks, delete_task)     
    return r, msg, data[PLANTASK.ID]   

學后的總是感覺就是：Python裝飾器可以讓函數輕裝上陣，更重要的是將函數的約束放置于接口處，使意圖更加明了，同時又不增加調用者的負擔，這貼子還是很膚淺的，我一定會回來的 ！

【編輯推薦】

1. 如何使Python嵌入C++應用程序？
2. 深入探討Ruby與Python語法比較
3. Python學習資料介紹分享
4. Python學習經驗談：版本、IDE選擇及編碼解 決方案
5. 淺析Python的GIL和線程安全