python学习【第五篇】python函数 (二)

一、装饰器

装饰器：本质就是函数，功能是为其它函数添加附加功能

装饰器的原则：

• 不修改被修饰函数的源代码
• 不修改被修饰函数的调用方式

装饰器的知识储备：

　　装饰器 = 高阶函数 + 函数嵌套 + 闭包

二、高阶函数

高阶函数的定义：

• 函数的接收参数是一个函数名
• 函数的返回值是一个函数名
• 满足上述条件任意一个都可以是高阶函数

import time

def fun1():
    time.sleep(0.5)
    print("hello")

def computing_run_time(fun):
    """
    计算函数运行时间
    :param fun:
    :return:
    """
    start_time = time.time()
    fun()
    end_time = time.time()
    print("运行时间%s" % (end_time - start_time))

computing_run_time(fun1)

"""
优点：在不修改函数源代码的前提下，给函数添加了额外的功能
缺点：改变了调用方式
"""

函数的接收参数是函数名

import time

def fun1():
    time.sleep(0.5)
    print("hello")

def computing_run_time(fun):
    """
    计算函数运行时间
    :param fun:
    :return:
    """
    fun()
    return fun

fun1 = computing_run_time(fun1)
fun1()   

"""
优点：没有改变函数的调用方式
缺点：不能为函数添加新的功能
"""

函数的返回值是函数名

注：仅仅是高阶函数不能满足装饰器的需求

三、函数嵌套和闭包

"""
闭包：首先必须是内部定义的函数，该函数包含对外部作用域而不是全局作用域名字的引用

定义：内部函数的代码包含对外部函数的代码的引用，但一定不是对全局作用域的引用
"""

def fun1():

    print("fun1")
    name = 1

    def fun2():
        print("fun2")
        print(name)

        def fun3():
            print("fun3")
            print(name)
        fun3()
    fun2()

fun1()

　　

四、装饰器示例

无参装饰器

def outer(fun):

    def wrapper():
        fun()

    return wrapper

加上参数

def outer(fun):

    def wrapper(*args, **kwargs):
        fun(*args, **kwargs)

    return wrapper

　　

简单装饰器

import time

def outer(func):
    """
    计算程序的运行时间
    :param func:
    :return:
    """

    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        stop_time = time.time()
        print("函数运行的时间为：%s" % (stop_time-start_time))
        return result
    return wrapper

@outer   # 语法糖  等价于 ： cal = outer(cal)  把wrapper函数的函数地址赋值给cal
def cal(list1):
    result = 0
    for i in list1:
        time.sleep(0.1)
        result += i

    return result

res = cal(range(20))
print(res)

　　

注：

　　函数cal的执行流程，先执行装饰器的outer函数，outer将函数的返回值赋值给变量cal，所以调用cal()  等价于  cal = outer(cal),   cal()  等价于这两步

多层装饰器

装饰器中含有函数参数

def before(name):
    print("before:%s" % name)
    return "before"

def after(name):
    print("after:%s" % name)
    return "after"

# 外层的参数只是为了将值传递到里层
def outer(before_func, after_func):

    def middle(main_func):

        def wrapper(*args, **kwargs):

            before_result = before_func(*args, **kwargs)
            print("before_result:%s" % before_result)

            main_result = main_func(*args, **kwargs)
            print("main_result: %s" % main_result)

            after_result = after_func(*args, **kwargs)
            print("after_result: %s" % after_result)

            return main_result

        return wrapper

    return middle

@outer(before, after)
def index(name):
    print("index")
    return name

result = index("aaa")
print(result)