python's twelth day for me

闭包：

　　内层函数对外层函数的变量（非全局变量）的引用。

　　python 遇到闭包，有一个机制，会开辟一个空间，将闭包中的全部变量放入其中。且不会随着函数的结束而关闭。

　　闭包的完美体现：装饰器。

打印函数的注释：

def func1():
    '''
    此函数是完成登陆的功能，参数分别是...作用。
    :return:返回值是登陆的成功与否（True,False）
    '''
    print(666)
    print(func1.__name__)    #打印函数名
    print(func1.__doc__)     #打印注释
    return True
func1()

# 666
# func1
# 
# 此函数是完成登陆的功能，参数分别是...作用。
# :return:返回值是登陆的成功与否（True, False）

放在函数执行外也可以打印：

def func():
    '''
    此函数是完成登陆的功能，参数分别是...作用。
    :return:返回值是登陆成功与否。（True,False）
    '''
    print(666)
    return True
func()
print(func.__name__)
print(func.__doc__)

# 666
# func
# 
#     此函数是完成登陆的功能，参数分别是...作用。
#     :return:返回值是登陆成功与否。（True,False）

打印日志：

from functools import wraps
def wrapper(f):     # f = func1
    @wraps(f)
    def inner(*args,**kwargs):    # 聚合
        '''执行函数之前的相关操作'''
        ret = f(*args,**kwargs)    #打散 1，2，3
        '''执行函数之后的相关操作'''
        return ret
    return inner
@wrapper     #func1 = wrapper(func1)   func1 = inner
def func1():
    '''
    此函数是完成登录功能，参数分别是...作用。
    :return: 返回值是成功与否（True,False）
    '''
    print(666)
    return True
func1()
print(func1.__name__)
print(func1.__doc__)

# 666
# func1
#
#     此函数是完成登录功能，参数分别是...作用。
#     :return: 返回值是成功与否（True,False）

多个装饰器装饰一个函数：

def wrapper1(func):    #func == f 函数名
    def inner1():
        print('wrapper1,before func')  # 2
        func()
        print('wrapper1,after func')   # 4
    return inner1

def wrapper2(func):
    def inner2():
        print('wrapper2,before func')   # 1
        func()
        print('wrapper2,after func')   # 5
    return inner2

@wrapper2  # 后 # f = warpper2(f) 里面的f == inner1  外面的 f == inner2
@wrapper1  # 先  # f = wrapper1(f) 里面的f == 函数名 f 外面的 f == inner1
def f():
    print('in f')   # 3
f()

# wrapper2,before func
# wrapper1,before func
# in f
# wrapper1,after func
# wrapper2,after func

多个装饰器装饰一个函数的打印顺序：

可引用全局变量，但不能修改，用global 才能修改。

a = 6
def func1():
    global a
    a = a+1
    print(a)
func1()

 用标志位，来决定是否执行装饰器：

import time
def timer(*args,**kwargs):
    def wrapper(f):
        def inner(*args,**kwargs):
            if flag:
                start_time = time.time()
                ret = f(*args,**kwargs)
                time.sleep(0.3)
                end_time = time.time()
                print('此函数的执行效率%f' % (end_time-start_time))
            else:
                ret = f(*args,**kwargs)
            return ret
        return inner
    return wrapper
flag = True
@timer(flag)     #两步： 1. timer(flag) --> wrappen   2. @wrapper
def func1():
    print(666)
@timer(flag)
def func2():
    print(777)
func1()
func2()