函數名（第一對象）

1. 函數的內存地址，print（func）

def func():
    print(222)
print(func)

2. 函數名可以賦值給其他變量

def func():
    print(222)
f = func
print(f())

3. 函數名可以當作容器類的元素

def func1():
    print(111)
def func2():
    print(222)
def func3():
    print(333)
li = [func1,func2,func3]
for i in li:
    i()

4. 函數名可以當作函數的參數

def func1():
    print(111)
def func2(x):
    x()
func2(func1)

5. 函數名可以當作函數的返回值

def f1():
    print(‘f1‘)

def func1(argv):
    argv()
    return argv

f = func1(f1)
f()

閉包：（cell）

1. 內層函數，對外層函數（非全局）的變量的引用，叫閉包

def wrapper():
    name = ‘alex‘
    def inner():
        print(name)
    inner()
    
 
print(inner.__closure__)  #檢查是不是閉包
    return inner

f = wrapper
f()

#輸出的__closure__有cell元素 ：是閉包函數

name = ‘egon‘
def func2():
    def inner():
        print(name)
    print(inner.__closure__)
    return inner

f2 = func2()
f2()

#輸出的__closure__為None ：不是閉包函數

2. 在外層函數的內部執行 inner（）

def wrapper():
    name 
 
= ‘alex‘
    def inner():
        print(name)
    inner()
    print(inner.__closure__)  #檢查是不是閉包
    return inner

f = wrapper
f()

閉包的好處：如果說內存函數是個閉包，python內部有一個機制，遇到閉包，它會在內存中開啟一個內存空間，不會隨著函數的結束而關閉。

裝飾器：

1, 簡單的裝飾器

import  time
def func1():
    print(‘in func1‘)

def timer(func):
    def inner():
        start = time.time()
        func()
        print(time.time() - start)
    return inner

func1 = timer(func1)
func1()

2, 帶參數的裝飾器

import time
def timer(func):
    def inner(a):
        start = time.time()
        func(a)
        print(time.time() - start)
    return inner

@timer
def func1(a):
    print(a)
func1(1)

3, 帶返回值的裝飾器

4, 通用的的裝飾器

import time
def timer(func):
    def inner(*args,**kwargs):
        start = time.time()
        re = func(*args,**kwargs)
        print(time.time() - start)
        return re
    return inner

@timer   #==> func1 = timer(func1)
def func1(a,b):
    print(‘in func1‘)

@timer   #==> func2 = timer(func2)
def func2(a):
    print(‘in func2 and get a:%s‘%(a))
    return ‘fun2 over‘

func1(‘aaaaaa‘,‘bbbbbb‘)
print(func2(‘aaaaaa‘))

裝飾器---hold住所有參數的裝飾器

5, 語法糖 @

import time
def timer(func):
    def inner():
        start = time.time()
        func()
        print(time.time() - start)
    return inner

@timer   #==> func1 = timer(func1)
def func1():
    print(‘in func1‘)


func1()

裝飾器---語法糖

開放封閉原則：

1.對擴展是開放的，為什麽要對擴展開放呢？

　　　　我們說，任何一個程序，不可能在設計之初就已經想好了所有的功能並且未來不做任何更新和修改。所以我們必須允許代碼擴展、添加新功能。

2.對修改是封閉的為什麽要對修改封閉呢？

　　　　就像我們剛剛提到的，因為我們寫的一個函數，很有可能已經交付給其他人使用了，如果這個時候我們對其進行了修改，很有可能影響其他已經在使用該函數的用戶。

裝飾器完美的遵循了這個開放封閉原則。

裝飾器的主要功能和固定結構

#固定格式

def wrapper(func):
    def inner(*args,**kwargs):
        ‘‘‘執行函數前的操作‘‘‘
        ret = func(*args,**kwargs)
        ‘‘‘執行函數後的操作‘‘‘
        return ret
    return inner
def func():
    print(666)

多個裝飾器裝飾一個函數

def outer(flag):
    def timer(func):
        def inner(*args,**kwargs):
            if flag:
                print(‘‘‘執行函數前要做的‘‘‘)
            ret = func(*args,**kwargs)
            if flag:
                    print(‘‘‘執行函數後要做的‘‘‘)
            return ret
        return inner
    return timer

@outer(False)
def func():
    print(111)
func()

python之路——函數（進階）