Python 装饰器、嵌套函数、高阶函数

装饰器

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

定义

用来装饰其他函数的,即为其他函数添加特定功能的函数,即装饰器本质也是一个函

装饰器函数的两个基本原则

  • 装饰器不能修改被装饰函数的源码
  • 装饰器不能修改被装饰函数的调用方式

函数即变量

函数即变量的思想:即函数也可以像变量一样赋值使用,如

def foo():
    print('in foo')

a = foo  # 把函数赋值给一个变量
a()  # 调用这个变量,即和调用函数一样的效果

高阶函数

高阶函数,符合下列条件之一的函数就是高阶函数:

(1)接收一个函数作为形参

(2)返回一个函数(return 函数)

高阶函数的两个条件对编写装饰器的意义:

(1)接收函数作为形参 -> 可以不改变被装饰函数的代码的前提下增加功能

def foo():
    print('in foo')

# gf 函数接收一个函数作为变量,故 gf 是一个高阶函数
def gf(func):
    # func = foo
    # 等同于把一个函数赋值给一个变量 func,然后通过变量 func 调用函数
    func()  # 通过变量调用函数

    # 高阶函数除了可以调用 foo 函数,即执行 foo 函数功能之外,可以附加执行一些功能,如打印函数地址
    # 这接近于装饰器的功能:在不改变别的函数源码的前提下给其添加附加功能
    # 但高阶函数不是装饰器,因为满足条件一:不改变被装饰函数的源码,但不满足条件二:不改变被装饰函数的调用方式
    print(func)

gf(foo)  # 改变了函数 foo 的调用方式

(2)返回一个函数(return 函数) -> 可以不改变被装饰函数的调用方式

def foo():
    print('in foo')

# gf 函数接收一个函数作为变量,故 gf 是一个高阶函数
def gf(func):
    # func = foo
    # 等同于把一个函数赋值给一个变量 func,然后通过变量 func 调用函数
    return func
    
# 可以不改变 foo 函数的调用方式
foo = gf(foo)
foo()

但是可以看出高阶函数不能同时满足两个条件,所以高阶函数不是真正的装饰器

嵌套函数

通过 def 关键字定义在另一个函数中的函数叫嵌套函数,如

def foo():
    print('in foo')
    
    def boo():
        print('in boo')

装饰器实现

装饰器 = 高阶函数 + 嵌套函数,所以可以得到如下代码

import time


def timer(func):
    # func = foo
    # 接收一个函数,可以在不改变函数源码的情况下为其增加附加功能
    def gf():
        start_time = time.time()
        func()  # => foo()
        end_time = time.time()
        print('func 运行时间为:', end_time - start_time)

    # 返回一个函数,可以不改变被嵌套函数的调用方式
    return gf

def foo():
    time.sleep(2)
    print('in foo')

foo = timer(foo)
foo()  # 函数调用方式不变,又多了打印其运行时间的附加功能

@的形式是Python 提供的装饰器的语法糖,等价于 foo = timer(foo)

import time

def timer(func):
    # func = foo
    # 接收一个函数,可以在不改变函数源码的情况下为其增加附加功能
    def gf():
        start_time = time.time()
        func()  # => foo()
        end_time = time.time()
        print('func 运行时间为:', end_time - start_time)

    # 返回一个函数,可以不改变被嵌套函数的调用方式
    return gf

@timer  # => foo = timer(foo)
def foo():
    time.sleep(2)
    print('in foo')

# foo = timer(foo)
foo()  # 函数调用方式不变,又多了打印其运行时间的附加功能

装饰器的运行过程

可以通过给上述的每一行代码加上断点,运行 debug 就可以看到装饰器的运行过程

装饰器编写的基本套路

  1. 定义一个接收函数的高阶函数
  2. 在高阶函数中定义一个嵌套函数,在该嵌套函数中:
    1. 封装想要添加的功能代码
    2. 调用作为参数传入的函数名
  3. 高阶函数返回该嵌套函数

常见的几种装饰器类型

被装饰函数带参数

带一个参数

import time

def timer(func):
    # func = foo
    # 接收一个函数,可以在不改变函数源码的情况下为其增加附加功能
    def gf(name):
        start_time = time.time()
        func(name)  # => foo(name)
        end_time = time.time()
        print('func 运行时间为:', end_time - start_time)

    # 返回一个函数,可以不改变被嵌套函数的调用方式
    return gf

@timer  # => foo = timer(foo) => foo = gf
def foo(name):
    time.sleep(2)
    print('in foo', name)

# foo = timer(foo)  # => foo = gf
foo('python')  # => gf('python')

带多个参数

import time

def timer(func):
    # func = foo
    # 接收一个函数,可以在不改变函数源码的情况下为其增加附加功能
    # *args, **kwargs 可以接收任意的参数
    def gf(*args, **kwargs):
        start_time = time.time()
        func(*args, **kwargs)  # => foo(*args, **kwargs)
        end_time = time.time()
        print('func 运行时间为:', end_time - start_time)

    # 返回一个函数,可以不改变被嵌套函数的调用方式
    return gf

@timer  # => foo = timer(foo) => foo = gf
def foo(name, age):
    time.sleep(2)
    print('in foo', name, age)

# foo = timer(foo)  # => foo = gf
foo('python', 18)  # => gf('python', 18)

装饰器本身带参数

import time

def timer(timer_type):
    print(timer_type)
    def outer(func):
        # func = foo
        # *args, **kwargs 可以接收任意的参数
        def gf(*args, **kwargs):
            start_time = time.time()
            func(*args, **kwargs)  # => foo(*args, **kwargs)
            end_time = time.time()
            print('func 运行时间为:', end_time - start_time)

        # 返回一个函数,可以不改变被嵌套函数的调用方式
        return gf
    return outer

# 此时 timer('装饰器参数') 带有小括号,表示已经调用了 timer 函数,那么得到了 timer 函数的返回值 outer
# 所以 @timer('装饰器参数') 已经变成了 @outer
@timer('装饰器参数')  # => @outer
def foo(name, age):
    time.sleep(2)
    print('in foo', name, age)

# foo = timer('装饰器参数')(foo)  # => foo = outer(foo)  # => foo = gf
foo('python', 18)  # => gf('python', 18)

# 提示:把每一行代码打断点调试可以更好的理解装饰器的运行过程

被装饰函数带返回值

import time

def timer(timer_type):
    print(timer_type)
    def outer(func):
        # func = foo
        # *args, **kwargs 可以接收任意的参数
        def gf(*args, **kwargs):
            start_time = time.time()
            res = func(*args, **kwargs)  # => foo(*args, **kwargs)
            end_time = time.time()
            print('func 运行时间为:', end_time - start_time)

            return res

        # 返回一个函数,可以不改变被嵌套函数的调用方式
        return gf
    return outer

# 此时 timer('装饰器参数') 带有小括号,表示已经调用了 timer 函数,那么得到了 timer 函数的返回值 outer
# 所以 @timer('装饰器参数') 已经变成了 @outer
@timer('装饰器参数')  # => @outer
def foo(name, age):
    time.sleep(2)
    print('in foo', name, age)
    return 'foo 返回了'

# foo = timer('装饰器参数')(foo)  # => foo = outer(foo)  # => foo = gf
res = foo('python', 18)  # => gf('python', 18)
print(res)

# 提示:把每一行代码打断点调试可以更好的理解装饰器的运行过程

一个函数使用多个装饰器

# 多个装饰器可以放在一个函数上
def add(func):
    def inner1():
        print("inner1...")
        x = func()
        return x + 1

    return inner1


def cube(func):
    def inner2():
        print("inner2...")
        x = func()
        return x * x * x

    return inner2


def square(func):
    def innner3():
        print("inner3...")
        x = func()
        return x * x

    return innner3


@add
@cube
@square
def test():
    return 2


# 从结果判断执行顺序:square -> cube -> add
# test 函数传递给 square 函数
# square 函数中的 innner3 函数传递给 cube 函数
# cube 函数中的 innner2 传递给 add 函数
# add 函数中的 innner1 传递给 test
print(test())  # 65

  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值