函数名应用：闭包，装饰器

函数的初识

    def关键字 空格 函数名（与变量设置相同）: 英文的冒号

    函数体

    执行函数 :函数名+（）

    函数是以功能为导向的，

    def login():

        pass

    def register():

        pass

 

 

 

 

函数的返回值。

 

    return: 1,函数中遇到return 结束函数，下面代码不执行。

            2，将函数里面的值返回给函数的执行者（调用者）。

                第一种情况:

                    只有return,返回None

                第二种情况:

                    return None

                第三种情况:

                    return 单个值(返回的值与单个值的类型相同)

                第四种情况:

                    return 多个值 以元组的形式返回给函数的调用者。

函数的参数。

 

    # 实参角度

 

    位置参数

        一一对应，实参形参数量相等

 

    关键字参数

        一一对应，实参形参数量相等，实参顺序可变

 

    混合参数 (位置参数，关键字参数)

        关键字参数必须在位置参数后面

 

    # 形参角度

 

    位置参数

         一一对应，实参形参数量相等

 

    默认参数

        默认参数必须放在形参的位置参数后面

        默认参数不传值则为默认值，传值则覆盖默认值。

    动态参数  *args， **kwargs 

　　用户传入到函数中的实参数量不定时，或者是为了以后的拓展，此时要用到动态参数　　　　

　　*args，**kwargs（万能参数）

　　*args接受的是所有的位置参数

　　**kwargs即为首的是所有的关键字参数。

　　形参顺序：位置参数， *args    默认参数， **kwargs

 

*d的魔性用法：在函数的执行时，*的用意是打散（把外壳打开，取里面元素）
　　　　　　　在函数定义时，*的用意是聚合

补充：
def func1(*args,**kwargs):
    print(args)  #(1, 2, 3, 4)
    print(*args)  #1 2 3 4   (print函数调用，再次打散，相当于print(*1,2,3,4))
    print(kwargs)  #{'name': 'alex'}
    print(**kwargs)  #报错　　（print不接收关键字参数）
func1(*[1,2,3,4],**{'name':'alex'})

函数名的应用：

　　　　1，直接打印函数名得到的是函数的内存地址。

　　　　2，函数名可以赋值运算

　　　　3，函数名可以作为函数的参数

　　　　4，函数名可以当做函数的返回值

　　　　5韩树民可以作为容器类数据类型的元素

第一类对象

　　闭包：（判断是不是闭包   函数名.__closure__       不是返回None,是闭包返回cell.....）

　　　　内层函数对外层函数非全局变量的引用，叫做闭包

　　闭包有什么用？

　　　　当执行一个函数时，如果解释器判断次函数内部闭包存在，这样python就有一个机制，

　　　　闭包所在的临时名称空间不会随着函数值得执行完毕而消失。

 

装饰器

import time
'''第一版本，测试函数low'''
def login():
    time.sleep(0.3)
    print('洗洗更健康...')

def timmer():
    start_time = time.time()
    login()
    end_time = time.time()
    print('此函数的执行时间%s' % (end_time - start_time))
timmer()


改变了我原来执行函数的执行方式，不好
def login():
    time.sleep(0.3)
    print('洗洗更健康...')
# login()

def register():
    time.sleep(0.4)
    print('洗洗更健康22222...')
# register()
def timmer(f):
    start_time = time.time()
    f()
    end_time = time.time()
    print('此函数的执行时间%s' % (end_time - start_time))

timmer(login)
timmer(register)

虽然执行函数的方式已经无限接近于原方式，但是更麻烦了，增加了两步代码。改
def login():
    time.sleep(0.3)
    print('洗洗更健康...')
# login()

def timmer(f):
    start_time = time.time()
    f()
    end_time = time.time()
    print('此函数的执行时间%s' % (end_time - start_time))

f1 = login  # 将login函数名给了f1
login = timmer  # 将timmer函数名给了login
login(f1)  # timmer(login)


初级装饰器
def login():
    time.sleep(0.3)
    print('洗洗更健康...')
# login()

def timmer(f):  # f = login函数名

    def inner():
        start_time = time.time()
        f()  # login()
        end_time = time.time()
        print('此函数的执行时间%s' % (end_time - start_time))
    return inner

login = timmer(login)  # inner 此login是新变量
login()  # inner()

name = 'alex'
name = '老男孩'


简单版装饰器  语法糖
def timmer(f):  # f = login函数名
    def inner():
        start_time = time.time()
        f()  # login()
        end_time = time.time()
        print('此函数的执行时间%s' % (end_time - start_time))
    return inner

@timmer  # login = timmer(login)  # inner 此login是新变量
def login():
    time.sleep(0.3)
    print('洗洗更健康...')
login()

@timmer  # register = timmer(register)
def register():
    time.sleep(0.2)
    print('洗洗更健康22...')

login()  # inner()

被装饰的函数带参数的装饰器

def timmer(f):  # f = login函数名
    def inner(*args,**kwargs):  # args (2, 3)
        start_time = time.time()
        f(*args,**kwargs)  # login() *(2, 3) 2,3
        end_time = time.time()
        print('此函数的执行时间%s' % (end_time - start_time))
    return inner

@timmer  # login = timmer(login)  # inner 此login是新变量
def login(a,b):
    print(a,b)
    time.sleep(0.3)
    print('洗洗更健康...')

login(2,3)  # inner(2,3)

@timmer  # register = timmer(register)
def register(a):
    time.sleep(0.2)
    print('洗洗更健康22...')

register(1)  # inner(1)

def func1(x):
    x = 0
    print(x)
func1(0)

函数带返回值的装饰器 （万能装饰器）
def timmer(f):  # f = login函数名
    def inner(*args,**kwargs):  # args (2, 3)
        start_time = time.time()
        ret = f(*args,**kwargs)  # login() *(2, 3) 2,3
        end_time = time.time()
        print('此函数的执行时间%s' % (end_time - start_time))
        return ret
    return inner

@timmer  # login = timmer(login)  # inner 此login是新变量
def login(a,b):
    print(a,b)
    time.sleep(0.3)
    print('洗洗更健康...')
    return 666

print(login(2,3))  # inner(2,3)



def wrapper(f):
    def inner(*args,**kwargs):
        '''执行被装饰函数之前的操作'''
        ret = f(*args,**kwargs)
        """执行被装饰函数之后的操作"""
        return ret
    return inner

装饰器功能：在不改变原函数的基础上，为原函数增加一些额外的功能，log,登录注册，等等.