python之路——函数（进阶）

函数名（第一对象）

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()