Python编程思想（25）：方法详解

喜欢ヅ旅行 2023-02-20 15:54 9阅读 0赞

李宁老师已经在「极客起源」 微信公众号推出《Python编程思想》电子书，囊括了Python的核心技术，以及Python的主要函数库的使用方法。读者可以在「极客起源」 公众号中输入 160442 开始学习。

## [《Python编程思想》总目录][Python] ##

[《Python编程思想》专栏][Python 1]

**目录**

1. 在类中调用实例方法

2. 类方法与静态方法

3. 函数装饰器

--------------------

方法是类或对象行为的抽象，但 Python的方法本章上也是函数，其定义方式、调用方式和函数都非常相似，因此 Python的方法并不仅仅是单纯的方法，它与函数也有莫大的关系。

## 1. 在类中调用实例方法 ##

在前面的文章讲过，在 Python的类体中定义的方法默认都是实例方法，前面也示范了通过对象来调用实例方法。但要提醒大家的是，Python的类在很大程度上是一个命名空间。当程序在类体中定义变量、定义方法时，与前面介绍的定义变量、定义函数其实并没有太大的不同。对比如下代码。

示例代码：class\_demo1.py

# 定义全局空间的test函数
    def test ():
        print("全局空间的test方法")
    # 全局空间的name变量
    name = 'Bill'
    class Dog:
        # 定义Dog空间的run函数
        def run():
            print("Dog空间的run方法")
        # 定义Bird空间的bar变量
        value = 123
    # 调用全局空间的函数和变量
    test()
    print(name)
    # 调用Bird空间的函数和变量
    Dog.run()
    print(Dog.value)

上面代码在全局空间和Dog类（Dog空间）中分别定义了test函数和name变量，从定义它们的代码来看，几乎没有任何区别，只是在Dog类中定义它们时需要缩进。

接下来程序在调用Dog空间内的value变量和run函数（方法）时，只要添加Dog.前缀即可，这说明完全可以通过Dog类来调用run函数（方法）。

现在问题来了，如果使用类调用实例方法，那么该方法的第一个参数（self）怎么自动绑定呢?

例如如下程序：

示例代码：class\_demo2.py

class Person:
        def run (self):
            print(self, '正在跑步...')
    # 通过类调用实例方法
    Person.run()

运行这段代码，程序会抛出如下异常：

TypeError: run() missing 1 required positional argument: 'self'

在这段代码中，run方法缺少传入的self参数，所以导致程序出错。这说明在使用类调用实例方法时, Python不会自动为第1个参数绑定调用者。实际上也没法自动绑定，因此实例方法的调用者是类本身,而不是对象。

如果程序依然希望使用类来调用实例方法，则必须手动为方法的第1个参数传入参数值。例如，使用下面的代码：

class Person:
        def run (self):
            print(self, '正在跑步...')
    # 通过类调用实例方法
    # Person.run()
    person = Person()
    # 显式为方法的第一个参数绑定参数值
    Person.run(person)

这段代码显式地为 run方法的第1个参数绑定了参数值，这样的调用效果完全等同于执行 person.run()方法。实际上，当通过Person类调用run实例方法时， Python只要求手动为第1个参数绑定参数值，并不要求必须绑定Person对象，因此也可使用如下代码进行调用。

# 显式地为方法的第一个参数绑定Python字符串参数值
    Person.run('Python')

如果按上面方式进行绑定，那么Python字符串就会被传给run()方法的第1个参数self。因此，运行上面代码，将会看到如下输出结果：

Python 正在跑步...

Python的类可以调用实例方法，但使用类调用实例方法时，Python不会自动为方法的第1个参数self绑定参数值。程序必须显式地为第1个参数self传入方法调用者。这种调用方式被称为“未绑定调用”。

## 2. 类方法与静态方法 ##

实际上， Python完全支持定义类方法，甚至支持定义静态方法。 Python的类方法和静态方法类似，它们都推荐使用类来调用（其实也可使用对象来调用）。类方法和静态方法的区别：Python会自动绑定类方法的第1个参数，类方法的第1个参数（通常建议参数名为cls）会自动绑定到类本身。但对于静态方法则不会自动绑定。

使用@ classmethod修饰的方法就是类方法，使用@ staticmethod修饰的方法就是静态方法。

下面代码演示了定义类方法和静态方法。

示例代码：class\_static\_method.py

class Pandas:
        # classmethod修饰的方法是类方法
        @classmethod
        def run (cls):
            print('类方法run: ', cls)
        # staticmethod修饰的方法是静态方法
        @staticmethod
        def printName (p):
            print('静态方法info: ', p)
    # 调用类方法，Dog类会自动绑定到第一个参数
    Pandas.run()
    # 调用静态方法，不会自动绑定，因此程序必须手动绑定第1个参数
    Pandas.printName('小团子')
    # 创建Bird对象
    p = Pandas()
    # 使用对象调用run()类方法，其实依然还是使用类调用，
    # 因此第1个参数依然被自动绑定到Pandas类
    p.run()
    # 使用对象调用printName静态方法，其实依然还是使用类调用，
    # 因此程序必须为第一个参数执行绑定
    p.printName('小团子')

从这段代码可以看出，使用@classmethod修饰的方法是类方法，该类方法定义了一个cls参数，该参数会被自动绑定到Pandas类本身，不管程序是使用类还是对象调用该方法，Python始终都会将类方法的第1个参数绑定到类本身。

这段代码还使用 @staticmethod定义了一个静态方法，程序同样既可使用类调用静态方法，也可使用对象调用静态方法，不管用哪种方式调用，Python都不会为静态方法执行自动绑定。

在使用 Python编程时，一般不需要使用类方法或静态方法，程序完全可以使用函数来代替类方法或静态方法。但是在特殊的场景（例如，使用工厂模式）下，类方法或静态方法也是不错的选择。

## 3. 函数装饰器 ##

前面介绍的@staticmethod和@classmethod的本质就是函数装饰器，其中 staticmethod和classmethod都是 Python内置的函数。

使用@符号引用已有的函数（比如@staticmethod和@classmethod）后，可用于修饰其他函数，装饰被修饰的函数。那么我们是否可以开发自定义的函数装饰器呢?答案是肯定的。

当程序使用“@函数”（比如函数X）装饰另一个函数（比如函数Y）时，实际上完成如下两步：

（1） 将被修饰的函数（函数Y）作为参数传给@符号引用的函数（函数A）；

（2）将函数Y替换（装饰）成第（1）步的返回值；

从上面介绍不难看出，被“@函数”修饰的函数不再是原来的函数，而是被替换成一个新的东西。

为了让大家更清楚函数装饰器的作用，下面看一个非常简单的示例。

示例代码：decorator\_demo.py

def funX(fn):
        print('X')
        fn() # 执行传入的fn参数
        return 'Python'
    '''
    下面装饰效果相当于：funX(funY)，
    funY将会替换（装饰）成该语句的返回值；
    由于funX()函数返回Python，因此funB就是Python
    '''
    @funX
    def funY():
        print('funY')
    print(funY) # Python

上面程序使用@funX修饰funY，这意味着程序要完成如下两步操作：

（1）将funY作为 funX的参数，也就是相当于执行funX(funY)；

（2）将funY替换成第（1）步执行的结果，funX()执行完成后返回Python，因此funY就不再是函数，而是被替换成一个字符串；

运行这段代码，可以看到如下输出结果：

X
    funY
    Python

通过这个例子，相信读者对函数装饰器的执行关系已经有了一个较为清晰的认识，但读者可能会产生另一个疑问：这个函数装饰器导致被修饰的函数变成了字符串，那么函数装饰器有什么用?

别忘记了，被修饰的函数总是被替换成@符号所引用的函数的返回值，因此被修饰的函数会变成什么，完全由@符号所引用的函数的返回值决定。如果@符号所引用的函数的返回值是函数，那么被修饰的函数在替换之后还是函数。

下面程序演示了更复杂的函数装饰器（接前面的程序)。

def process(fn):
        # 定义一个嵌套函数
        def print_info(*args):
            print('-------1-------', args)
            n = args[0]
            print('-------2-------', n ** 3)
            # 查看传给process函数的fn函数
            print(fn.__name__)
            fn(n * (n + 1))
            print("*" * 20)
            return fn(n * (n - 1))
        return print_info
    
    '''
    下面装饰效果相当于：process(my_value)，
    my_value将会替换（装饰）成该语句的返回值；
    由于process()函数返回print_info函数，因此funY就是print_info
    
    '''
    @process
    def my_value(a):
        print("-----my_value函数------", a)
    # 打印my_value函数，将看到实际上是bar函数
    print(my_value) #
    # 下面代码看上去是调用my_value()，其实是调用print_info()函数
    my_value(10)
    my_value(6, 5)

上面程序定义了一个装饰器函数process，该函数执行完成后并不是返回普通值，而是返回print\_info函数（这是关键），这意味着被该@process修饰的函数最终都会被替换成print\_info函数。

上面程序使用@process修饰 my\_value()函数，因此程序同样会执行process(my\_value)，并将 my\_value替换成process函数的返回值print\_info函数。所以,在这段代码中打印 my\_value函数时，实际上输出的是print\_info函数，这说明my\_value已经被替换成print\_info函数。接下来程序两次调用 my\_value函数,实际上就是调用print\_info函数。

运行上面程序，可以看到如下输出结果:

<function process.<locals>.print_info at 0x7fb4880a55f0>
    -------1------- (10,)
    -------2------- 1000
    my_value
    -----my_value函数------ 110
    ********************
    -----my_value函数------ 90
    -------1------- (6, 5)
    -------2------- 216
    my_value
    -----my_value函数------ 42
    ********************
    -----my_value函数------ 30

通过@符号来修饰函数是 Python的一个非常实用的功能，它既可以在被修饰函数的前面添加些额外的处理逻辑（比如权限检查）,也可以在被修饰函数的后面添加一些额外的处理逻辑（比如记录日志）,还可以在目标方法抛出异常时进行一些修复操作。这种改变不需要修改被修饰函数的代码，只要增加一个修饰即可。

其实前面介绍的这种在被修饰函数之前、之后、拋出异常后增加某种处理逻辑的方式，就是其他编程语言中的AOP( Aspect Orient Programming，面向切面编程)。

下面例子示范了如何通过函数装饰器为函数添加权限检查的功能。程序代码如下：

示例代码：auth\_demo.py

def auth(fn):
        def verify_auth(*args):
            # 用一条语句模拟执行权限检查
            print("----模拟执行权限检查----")
            # 回调要装饰的目标函数
            fn(*args)
        return verify_auth
    @auth
    def test(a, b,c,d):
        print(f"执行test函数,参数a: {a}, 参数b: {b}, 参数d: {c},参数d: {d}" )
    # 调用test()函数,其实是调用装饰后返回的verify_auth函数
    test(123, 55, 135,66)

上面程序使用@auth修饰了test()函数，这会使得 test()函数被替换成 auth函数所返回的 verify\_auth函数，而 verify\_auth函数的执行流程如下：

（1）先执行权限检查；

（2）回调被修饰的目标函数；

也就是说，verify\_auth函数就为被修饰函数添加了一个权限检查的功能。运行该程序,,可以看到如下输出结果：

\----模拟执行权限检查---- 执行test函数,参数a: 123, 参数b: 55, 参数d: 135,参数d: 66

**-----------------支持作者请转发本文，也可以加李宁老师微信：unitymarvel，或扫描下面二维码加微信--------**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25va2lhZ3V5_size_16_color_FFFFFF_t_70][]

欢迎关注  极客起源  微信公众号，更多精彩视频和文章等着你哦！

![format_png][]

[Python]: https://blog.csdn.net/nokiaguy/article/details/106227459
[Python 1]: https://blog.csdn.net/nokiaguy/category_10033825.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25va2lhZ3V5_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200622132820211.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25va2lhZ3V5,size_16,color_FFFFFF,t_70
[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X2pwZy9VT2ljQmljZDl4dG4yVTN6Z0ppYzBiQ2JJeDVmNkpjSWljUUx0aWJyOVB0RDNiVWhrT3pLNkxqUENoeDAxb0VjSmdKNEVEMGJoN1R6TzJkaDBoNUxMWDY1Zk93LzY0MA?x-oss-process=image/format,png