跳到主要内容

Python 类的构造方法、析构方法、实例方法

上一个小节我们学习了 Python 的类属性和实例属性的知识点，这个小节我们还是会学习关于类的知识。这节课我们会学习类的构造方法、析构方法和实例方法。

1. 实例方法​

1.1 定义​

实例方法是用于访问对象实例属性的方法，语法如下：

class 类:
    def 实例方法(self):
        self.属性

实例方法定义在类中，它的第一个参数 self 指向调用该方法的对象，在实例方法中通过 “self.属性” 访问对象的实例属性。

1.2 例子​

每个人具有 name 和 age 的属性，创建一个类 Person，在类 Person 中定义实例方法 introduce 访问对象的属性，代码示例如下：

class Person:
    def introduce(self):
        print('name = %s, age = %d' % (self.name, self.age))

tom = Person()    
tom.name = 'tom'
tom.age = 10
tom.introduce()

jerry = Person()
jerry.name = 'jerry'
jerry.age = 20
jerry.introduce()

  • 在第 1 行，定义了类 Person
    • 在第 2 行，定义了类 Person 的方法 introduce，introduce 的 self 参数指向调用 introduce 方法的对象
    • 在第 3 行，introduce 方法通过 self.name 和 self.age 访问对象的属性
  • 在第 5 行，使用类 Person 创建一个对象 tom
    • 在第 6 行，设置对象 tom 的属性 name，该属性为实例属性
    • 在第 7 行，设置对象 tom 的属性 age，该属性为实例属性
    • 在第 8 行，调用对象 tom 的方法 introduce，对象 tom 被传递给方法 introduce，作为 self 参数，在执行 introduce 时，self 参数指向对象 tom
  • 在第 10 行，使用类 Person 创建一个对象 jerry
    • 在第 11 行，设置对象 jerry 的属性 name，该属性为实例属性
    • 在第 12 行，设置对象 jerry 的属性 age，该属性为实例属性
    • 在第 13 行，调用对象 jerry 的方法 introduce，对象 jerry 被传递给方法 introduce，作为 self 参数，在执行 introduce 时，self 参数指向对象 jerry

程序运行输出如下：

name = tom, age = 10
name = jerry, age = 20

2. 构造方法​

2.1 为什么需要构造方法​

在前面的演示实例方法的程序中，创建了两个对象 tom 和 age，创建对象后需要设置属性的初始值，具体的过程如下所示：

  • 在第 5 行，使用类 Person 创建一个对象 tom
    • 在第 6 行，通过 tom.name = ‘TOM’ 设置对象 tom 的属性 name
    • 在第 7 行，通过 tom.age = 10 设置对象 tom 的属性 age
  • 在第 10 行，使用类 Person 创建一个对象 jerry
    • 在第 11 行，通过 jerry.name = ‘TOM’ 设置对象 jerry 的属性 name
    • 在第 12 行，通过 jerry.age = 10 设置对象 jerry 的属性 age

在初始化对象属性时，存在一个明显的问题：初始化 tom 的代码块和初始化 jerry 的代码块是类似和重复的。Python 提供了一个特殊的方法：构造方法，该方法用于初始化对象属性，用于解决这个问题。

2.2 定义​

构造方法是用于初始化对象属性的方法，语法如下：

class 类:
    def \_\_init\_\_(self, 参数):
        self.属性 = 参数

对象 = 类(参数)

  • 在第 2 行，在类中定义了一个方法 __init__，该方法被称为构造方法
    • 方法名的前缀和后缀是两个下划线 _
    • 方法的第一个参数 self 指向新创建的对象
    • 方法的其余参数用于设定对象的属性
  • 在第 3 行，在构造方法中，设定初始化对象的属性
  • 在第 5 行，使用 “对象 = 类(参数)” 的形式创建一个新的对象，新创建的对象作为 self 参数传递给类的构造方法 __init__

2.3 例子​

每个人具有 name 和 age 的属性，创建一个类 Person，在类 Person 中定义构造方法 __init__，创建对象时设定对象的属性，代码示例如下：

class Person:
    def \_\_init\_\_(self, name, age):
        self.name = name
        self.age = age

    def introduce(self):
        print('name = %s, age = %d' % (self.name, self.age))

tom = Person('tom', 10)
tom.introduce()

jerry = Person('jerry', 20)
jerry.introduce()

  • 在第 1 行，定义了类 Person
    • 在第 2 行，定义了类 Person 的构造方法 __init__
      • __init__ 的 self 参数指向新创建的对象
      • 在第 3 行和第 4 行，初始化对象的 name 和 age
    • 在第 6 行，定义了类 Person 的实例方法 introduce
      • introduce 的 self 参数指向调用 introduce 方法的对象
      • 在第 7 行，输出对象的 name 和 age
  • 在第 9 行，使用类 Person 创建一个对象 tom
    • 新创建对象 tom 时，tom 的属性 name 和 age 为空
    • 将对象 tom 作为参数传递给类 Person 的构造方法 __init__
    • 在构造方法 __init__** 设置属性 name 和 age
  • 在第 12 行，使用类 Person 创建一个对象 jerry
    • 新创建对象 jerry 时，jerry 的属性 name 和 age 为空
    • 将对象 jerry 作为参数传递给类 Person 的构造方法 __init__
    • 在构造方法 __init__** 设置属性 name 和 age

程序运行输出如下：

name = tom, age = 10
name = jerry, age = 20

3. 析构方法​

3.1 del 语句​

Python 提供了 del 语句用于删除不再使用的变量，del 语句的语法如下：

del 表达式

使用 del 语句删除变量，变量删除后将无法再访问，代码如下：

>>> var = 'hello'
>>> print(var)
hello
>>> del var
>>> print(var)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'var' is not defined

  • 在第 1 行，创建变量 var
    • 在第 2 行，打印变量 var 的值
    • 在第 3 行，正确的输出了
  • 在第 4 行，使用 del 语句删除变量
    • 在第 5 行，打印变量 var 的值
    • 在第 6 行，因为变量 var 已经被删除了，所以无法访问变量 var，显示错误：name ‘var’ is not defined

3.2 定义​

Python 提供了一种机制使得对象被删除前能够得到通知。对象被删除时，如果该对象拥有名为 __del__ 的方法，该方法在删除前被调用，该方法又被称为析构方法，语法如下：

class 类:
    def \_\_del\_\_(self):
        self.属性

  • 在第 2 行，在类中定义了一个方法 __del__，该方法被称为析构方法
    • 方法名的前缀和后缀是两个下划线 _
    • 方法的参数 self 指向将被删除的对象

3.3 例子​

创建一个类 Person，并定义析构方法 __del__，然后使用类 Person 创建两个对象，最后再使用 del 语句删除他们，验证析构方法，代码示例如下：

class Person:
    def \_\_init\_\_(self, name, age):
        self.name = name
        self.age = age

    def \_\_del\_\_(self):
        print('del %s' % self.name)

    def introduce(self):
        print('name = %s, age = %d' % (self.name, self.age))

tom = Person('tom', 10)
tom.introduce()

jerry = Person('jerry', 20)
jerry.introduce()

del tom
del jerry

  • 在第 1 行，定义了类 Person
    • 在第 2 行，定义了构造方法 __init__
    • 在第 6 行，定义了析构方法 __del__
    • 在第 9 行，定义了实例方法 introduce
  • 在第 12 行，使用类 Person 创建一个对象 tom
  • 在第 13 行，使用类 Person 创建一个对象 jerry
  • 在第 18 行，使用 del 语句删除对象 tom，调用析构方法 tom.__del__()
  • 在第 19 行，使用 del 语句删除对象 jerry，调用析构方法 jerry.__del__()

程序运行输出如下：

name = tom, age = 10
name = jerry, age = 20
del tom
del jerry

  • 在第 1 行，执行实例方法 tom.introduce() 输出该行
  • 在第 2 行，执行实例方法 jerry.introduce() 输出该行
  • 在第 3 行，执行 tom.__del__() 输出该行
  • 在第 4 行，执行 jerry.__del__() 输出该行