您现在的位置是：首页 > Python

当前栏目

Python3: 装饰器

Python3 对象

2023-03-02 11:23:43 时间

本文链接: [https://blog.csdn.net/xietansheng/article/details/115557480][https_blog.csdn.net_xietansheng_article_details_115557480]

[Python3 学习笔记（目录）][Python3]

# 1. 函数的嵌套与闭包 #

Python 中一切皆对象，函数也是一个对象（函数是可调用对象）。

Python 的装饰器（Decorator）通过闭包函数实现，闭包通过函数的嵌套实现。闭包的本质是连接函数内部与外部的桥梁。闭包可以理解为能访问其他函数内部局部变量的（内部）函数。

闭包的实现：通过调用一个外部函数`fun`，在其内部动态创建一个函数对象`fun_inner`并把引用返回给外部。这样在`fun`的部就构成了一个闭合的局部空间（作用域），该作用域内的变量由于还被内部函数引用因此不会马上被垃圾回收，在该作用域内的变量只能在`fun`内被访问，最重要的是每次调用外部函数`fun`都会重新生成独立的新的`fun_inner`函数对象和作用域空间。

外部函数`fun`可以理解为一个“类”，每次调用函数`fun`都会重新创建并返回了一个新对象（闭包）。

下面是闭包的简单例子：

def fun(name):                          # fun 是外部函数, 变量 name 是函数 fun 内部的变量, 并且只能在该函数内部被访问
    
        member = { "count": 0}               # 变量 member 也是函数 fun 内部的变量, 并且只能在该函数内部被访问
    
        def fun_inner():                    # fun_inner 是内部函数, 即闭包（闭包函数）
            member["count"] += 1
            print(name, member["count"])    # 内部函数读取了外部函数的内部变量, 使外部函数执行完后其内部变量不会被垃圾回收
    
        return fun_inner                    # 每一次调用外部函数, 都重新动态加载内部函数（闭包）并返回新的内部函数对象
    
    
    f1 = fun("Hello")       # 调用外部函数, 生成新的函数对象
    f2 = fun("World")       # 调用外部函数, 生成新的函数对象
    
    f1()                    # 调用闭包函数, 输出: Hello 1
    f1()                    # 调用闭包函数, 输出: Hello 2
    
    f2()                    # 调用闭包函数, 输出: World 1

# 2. 装饰器的原理与语法 #

Python 的装饰器通过函数实现，其本质是一个函数。装饰器通过`@`符号作用在其他函数上，通过调用装饰器函数对原函数进行包装并返回新的函数。

装饰器的实现：

#!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    
    import time
    
    
    def exec_time(fun):                     # 定义一个用于打印函数执行时间的装饰器（函数）
        """ 装饰器只有一个参数, 用于接收被装饰的函数对象 """
    
        def inner_fun():                    # 定义内部函数（创建函数对象）
            start_time = time.time()
    
            fun()                           # 调用原函数
    
            end_time = time.time()
    
            print("%s use time %d" % (fun.__name__, end_time - start_time))
    
        return inner_fun
    
    
    @exec_time                  # @exec_time 的作用相当于执行了 test = exec_time(test)
    def test():
        print("test_fun()")
        time.sleep(2)
    
    
    # 经过装饰器装饰后, 这里的 test 函数就不是原来的函数了,
    # 而是调用了 exec_time(fun) 方法返回的一个函数
    print(test.__name__)                        # 结果为: inner_fun
    
    test()                                      # 调用经过装饰后的 test 方法,
                                                # 实际调用的是 exec_time 内部的 inner_fun

# 3. 多个装饰器 #

#!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    
    
    def decorator_01(fun):                              # 第一个装饰器（函数）
        def fun_inner_01():
            print("decorator_01 -> fun_inner_01()")
            fun()                                       # 调用原函数
        return fun_inner_01
    
    
    def decorator_02(fun):                              # 第二个装饰器（函数）
        def fun_inner_02():
            print("decorator_02 -> fun_inner_02()")
            fun()                                       # 调用原函数
        return fun_inner_02
    
    
    #
    # 多个装饰器装饰函数, 靠近函数的装饰器先执行, 相当于:
    #
    # test = decorator_01(decorator_02(test))
    #
    # 即: 先用 @decorator_02 装饰 test() 得到一个新的函数,
    # 再用 @decorator_01 装饰上一步得到的新函数。
    #
    @decorator_01
    @decorator_02
    def test():
        print("test()")
    
    
    print(test.__name__)    # 打印被装饰后的函数的名称, 结果为: fun_inner_01
    
    test()                  # 调用被装饰后的函数, 结果为: decorator_01 -> fun_inner_01()
                            # decorator_02 -> fun_inner_02()
                            # test()

# 4. 带参数的装饰器 #

## 4.1 被装饰函数带参数 ##

#!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    
    
    def decorator(fun):             # 定义一个用于打印函数执行时间的装饰器（函数）
    
        def inner_fun(a, b):        # 在内部函数中定义参数, 参数列表必须要和被装饰的函数的参数列表相同
            print("call inner fun")
            return fun(a, b)        # 调用原函数, 把内部函数接收到的参数传递给原函数, 并返回调用结果
    
        return inner_fun
    
    
    @decorator                      # add = decorator(add)
    def add(a, b):                  # 定义带参数的函数
        return a + b
    
    
    print(add.__name__)             # 结果为: inner_fun
    
    s = add(2, 3)                   # 这里调用的实际上是 inner_fun(a, b), 因此会输出: "call inner fun"
    
    print(s)                        # 结果为 5

## 4.2 带参数的装饰器 ##

装饰器（函数）只有一个参数，用于接收原函数对象，因此实际上装饰器不会带有其他参数。所谓带参数的装饰器，实际上是普通函数调用返回一个内部函数作为装饰器再用于装饰函数。

#!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    
    
    def decorator_fun(name):                # 定一个函数, 该函数返回一个装饰器
    
        def decorator(fun):                 # 定义一个装饰器
            def inner_fun():
                print(name + ": call inner fun")
                fun()                       # 调用原函数
            return inner_fun
    
        return decorator                    # 返回装饰器
    
    
    # 相当于:
    # f = decorator_fun("hello") 调用函数, 返回装饰器
    # test = f(test) 装饰器装饰函数
    @decorator_fun("hello")
    def test():                     # 定义带参数的函数
        print("test")
    
    
    print(test.__name__)            # 结果为: inner_fun
    
    test()                          # 调用被装饰后的函数, 结果为: hello: call inner fun
                                    # test

> `decorator_fun`是一个普通函数，并不是一个装饰器，调用`decorator_fun("hello")`的返回结果才是装饰器。

# 5. 类装饰器 #

类作为装饰器，需要实现`__call__`方法。把类名作为构造器装饰函数，实际上是把 *类的构造方法* 当做构造器使用（因为调用类名，就是调用构造方法，即创建对象）。

#!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    
    
    import time
    
    
    class ShowTime:                     # 创建一个类装饰器
    
        __fun = None
    
        def __init__(self, fun):        # 构造器的第二个参数接收被装饰的函数对象
            self.__fun = fun
    
        def __call__(self):             # 实现 __call__ 方法, 使该类的对象可调用
            start_time = time.time()
            self.__fun()                # 调用原函数
            end_time = time.time()
            print("Call function use time: %f" % (end_time - start_time))
    
    
    # 用类名当做装饰器去装饰函数, 实际上是把类的构造方法当做了装饰器函数,
    # 调用类的构造方法, 创建一个可调用的对象赋值给原函数变量。
    #
    # 相当于: test = ShowTime(test)
    # 装饰完后 test 是 ShowTime 类的一个实例
    @ShowTime
    def test():
        print("test")
        time.sleep(1)
    
    
    # 调用被类名装饰后的 test 函数, 实际上调用的是 ShowTime 的实例对象,
    # 即调用的是 ShowTime 类的 __call__(...) 方法。
    #
    # 输出结果: test
    # Call function use time: 1.003948
    test()

# 6. 常用的内置装饰器 #

## 6.1 @classmethod 和 @staticmethod ##

`@classmethod`类方法装饰，被该装饰器装饰过的类的方法成为类对象的方法（第1个参数接收类本身），直接使用`类名.方法名`调用（类参数自动传入）。

`@staticmethod`静态方法装饰，被该装饰器装饰过的类的方法成为类的静态方法（可以不需要一个参数），直接使用`类名.方法`调用。

## 6.2 @property ##

`@property`装饰器用于装饰类的方法，使该方法名变为一个属性，可以直接读取和赋值。

#!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    
    
    class Student:
    
        __score = 0
    
        @property                   # 使用 @property 装饰方法, 使 score 变为类的一个可读属性,
        def score(self):            # 被 @property 装饰后的 score 对象会有若干可作为"装饰器"属性,
            return self.__score     # 例如 @score.setter 装饰器用于装饰其他函数使其变为可写属性。
    
        @score.setter               # 使用被 @property 装饰后的 score 的一个属性（装饰器）@score.setter 装饰函数,
        def score(self, value):     # 使 score 变为一个可写属性, 第2个参数接收写入操作等号右边的值。
            if value < 0:           # 在 setter 方法内可以检查传入值的合法性
                value = 0
            elif value > 100:
                value = 100
            self.__score = value
    
    
    stu = Student()
    
    # 读取 stu.score 的值实际上会调用 Student 类中的 score(self) 方法
    # 相当于 s = stu.score()
    s = stu.score
    
    # 给 stu.score 写入值实际上会调用 Student 类中的 score(self, value) 方法
    # 相当于 stu.score(50)
    stu.score = 50

[https_blog.csdn.net_xietansheng_article_details_115557480]: https://blog.csdn.net/xietansheng/article/details/115557480
[Python3]: https://blog.csdn.net/xietansheng/article/details/109266600

猜你喜欢

最长无重复子串
写技术博客的一些心得分享
Java 多线程（七）：线程池
Java 多线程（五）：锁（三）
Java 多线程（四）：锁（二）
Java 多线程（三）：锁（一）
Java 多线程（二）：并发编程的三大特性
线性时间非比较类排序
Java 多线程（一）：基础
合并k个已排序的链表
HDFS 高可用分布式环境搭建
合并两个有序数组
连续子数组的最大和
HDFS 分布式环境搭建
容器盛水问题
大数加法
HDFS 伪分布式环境搭建
设计LRU缓存结构
两数之和
使用单调栈来解决的一些问题

zl程序教程

当前栏目

Python3: 装饰器

相关文章