【Python】类（class）的创建

1 类简介

1.1 什么是类

在面向对象编程（OOP）中，类（Class） 是一种封装了数据和操作这些数据的函数的编程结构。它是一种抽象的概念，用于定义具有相同属性（变量）和方法（函数）的对象的模板。类可以看作是一个“蓝图”，用于创建具有相同特征和行为的对象实例。

1.2 类的作用

1.2.1 封装（Encapsulation）

类将数据（属性）和操作数据的方法封装在一起，形成一个独立的单元。这样可以隐藏内部实现细节，只暴露必要的接口给外部使用。

例如，一个 Car 类可以封装发动机、车轮等属性，以及启动、加速等方法，外部代码只需要调用这些方法，而不需要关心内部的具体实现。

1.2.2 抽象（Abstraction）

类提供一个简化的接口，隐藏复杂的实现细节。类允许开发者通过定义通用的属性和方法来描述一类对象的共性。

例如，Animal 类可以定义 eat() 和 sleep() 方法，具体实现则由子类（如 Dog、Cat）来完成。

1.2.3 继承（Inheritance）

类允许一个类（子类）继承另一个类（父类）的属性和方法。子类可以重用父类的代码，同时还可以添加新的属性和方法或修改父类的行为。

例如，ElectricCar 类可以继承 Car 类的属性和方法，并添加电池容量等新的属性。

1.2.4 多态（Polymorphism）

类允许不同类的对象对同一消息做出响应。即同一个方法可以在不同的子类中实现不同的行为。

例如，Dog 和 Cat 都是 Animal 的子类，它们都有 make_sound() 方法，但 Dog 的实现是“汪汪”，而 Cat 的实现是“喵喵”。

1.3 类的应用场景

1.3.1 当需要描述一组具有相同特征和行为的对象时

当多个对象共享相同的属性和方法，那么使用类来定义它们是一个好主意。例如，Student 类可以用来描述多个学生对象，每个学生都有姓名、年龄、成绩等属性，以及学习、考试等行为。

1.3.2 当需要封装数据和操作数据的逻辑时

如果一组数据和操作这些数据的函数总是紧密相关，那么将它们封装到一个类中可以提高代码的可维护性和可读性。

例如，一个 BankAccount 类可以封装账户余额、存款、取款等操作。

1.3.3 当需要实现继承和多态时

如果你需要创建一个具有层次结构的对象模型，或者需要让不同的对象对同一操作有不同的实现，那么类是实现这些功能的基础。

例如，Shape 类可以有多个子类（如 Circle、Rectangle），每个子类都可以实现自己的 draw() 方法。

1.3.4 当需要隐藏实现细节时

如果某些数据或逻辑不应该被外部直接访问，而是通过类的方法来控制访问，那么类的封装特性可以帮助你实现这一点。
例如，一个类可以隐藏其内部的复杂算法，只提供简单的接口供外部调用。

2 类的创建

# 定义一个类
class Car:
    def __init__(self, make, model, year):
        self.make = make  # 品牌
        self.model = model  # 型号
        self.year = year  # 年份
        self.odometer_reading = 0  # 里程表初始值

    def get_descriptive_name(self):
        """返回整洁的描述性信息"""
        return f"{self.year} {self.make} {self.model}"

    def read_odometer(self):
        """打印一条指出汽车里程的消息"""
        print(f"This car has {self.odometer_reading} miles on it.")

    def update_odometer(self, mileage):
        """将里程表读数设置为指定的值"""
        if mileage >= self.odometer_reading:
            self.odometer_reading = mileage
        else:
            print("You can't roll back an odometer!")

    def increment_odometer(self, miles):
        """将里程表读数增加指定的量"""
        self.odometer_reading += miles

# 创建类的实例
my_new_car = Car('audi', 'a4', 2019)

# 使用类的方法
print(my_new_car.get_descriptive_name())  # 输出：2019 audi a4
my_new_car.read_odometer()  # 输出：This car has 0 miles on it.

# 修改属性值
my_new_car.update_odometer(23)
my_new_car.read_odometer()  # 输出：This car has 23 miles on it.

# 增加里程
my_new_car.increment_odometer(100)
my_new_car.read_odometer()  # 输出：This car has 123 miles on it.

2.1 __init__方法

init 是一个特殊的方法，称为构造方法或初始化方法。它在创建类的实例时被自动调用，用于初始化对象的属性。

作用

初始化对象的属性：为每个新创建的对象设置初始值。

确保对象在创建时处于一致的状态：通过在对象创建时执行必要的初始化操作，确保对象的属性和状态是正确的。

语法

class 类名:
    def __init__(self, 参数1, 参数2, ...):
        # 初始化代码
        self.属性1 = 参数1
        self.属性2 = 参数2
        ...

示例

class Person:
    def __init__(self, name, age):
        # 初始化属性
        self.name = name
        self.age = age

    def greet(self):
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")

# 创建 Person 类的对象
person1 = Person("Alice", 25)
person2 = Person("Bob", 30)

# 调用实例方法
person1.greet()  # 输出：Hello, my name is Alice and I am 25 years old.
person2.greet()  # 输出：Hello, my name is Bob and I am 30 years old.

init 的特点

自动调用：当使用类创建对象时，init 方法会被自动调用。

person = Person("Alice", 25)  # 创建对象时自动调用 __init__

初始化属性：通过 self.属性名 的方式，为对象设置初始属性值

self.name = name
self.age = age

可以有默认参数：init 方法可以定义默认参数值，这样在创建对象时可以省略某些参数。

class Person:
    def __init__(self, name, age=18):  # age 默认值为 18
        self.name = name
        self.age = age

person1 = Person("Alice")  # age 使用默认值 18
person2 = Person("Bob", 30)  # 指定 age 为 30

可以执行其他操作：init 方法不仅用于初始化属性，还可以执行其他必要的初始化操作，例如打印日志、加载资源等。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        print(f"Person {self.name} created with age {self.age}.")

注意事项

不要返回值：init 方法不需要返回值（即隐式返回 None）。如果尝试返回值，会引发错误

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        return "Hello"  # 错误：__init__ 方法不能返回值

self 是必须的：self 是指向当前对象实例的引用，必须作为第一个参数传递给 init 方法

class Person:
    def __init__(name, age):  # 错误：缺少 self 参数
        self.name = name
        self.age = age

2.2 形参self

self是类的方法中的第一个参数，用于指向类的实例本身。通过 self，可以在类的方法中访问和修改实例的属性和其他方法

self 的作用

指向实例本身：self 是一个指向当前对象实例的引用。它确保每个方法都能正确地访问和操作属于该实例的属性和其他方法。
访问实例属性：在类的方法中，通过 self.属性名 的方式可以访问和修改实例的属性。
调用实例方法：在类的方法中，通过 self.方法名() 的方式可以调用其他实例方法。

为什么需要 self？

self 是一个指向当前实例的引用，用于访问和修改实例的属性和其他方法。如果没有 self，Python 就无法区分这些属性和方法是属于类的还是属于某个具体实例的。通过合理使用 self，可以确保类的方法能够正确地操作实例的属性和方法，从而实现面向对象编程的核心功能。

class Person:
    def __init__(self, name, age):
        self.name = name  # 使用 self 访问实例属性
        self.age = age

    def greet(self):
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")  # 使用 self 访问实例属性

如果没有 self，代码会变成这样：

class Person:
    def __init__(name, age):  # 错误：缺少 self 参数
        name = name
        age = age

    def greet():
        print(f"Hello, my name is {name} and I am {age} years old.")  # 错误：name 和 age 未定义

在这种情况下，name 和 age 会被当作局部变量，而不是实例的属性，导致代码无法正常工作

self 的使用示例

定义和使用 self

class Person:
    def __init__(self, name, age):
        self.name = name  # 初始化实例属性 name
        self.age = age    # 初始化实例属性 age

    def greet(self):
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")

    def have_birthday(self):
        self.age += 1  # 修改实例属性 age
        print(f"Happy birthday! Now I am {self.age} years old.")

# 创建实例
person = Person("Alice", 25)

# 调用方法
person.greet()          # 输出：Hello, my name is Alice and I am 25 years old.
person.have_birthday()  # 输出：Happy birthday! Now I am 26 years old.

在方法中调用其他方法

class Calculator:
    def __init__(self):
        self.result = 0

    def add(self, value):
        self.result += value
        return self.result

    def subtract(self, value):
        self.result -= value
        return self.result

    def reset(self):
        self.result = 0
        return self.result

    def display(self):
        print(f"Current result: {self.result}")

# 创建实例
calc = Calculator()

# 调用方法
calc.add(10)        # 输出：10
calc.subtract(5)    # 输出：5
calc.display()      # 输出：Current result: 5
calc.reset()        # 输出：0
calc.display()      # 输出：Current result: 0

self 的命名规则

虽然 self 是一个约定俗成的名称，但它并不是 Python 的关键字。你可以使用任何其他名称来代替 self，但强烈建议使用 self，因为这是 Python 社区的通用约定，使用其他名称会让代码难以理解和维护。

class Person:
    def __init__(this, name, age):  # 使用 this 代替 self
        this.name = name
        this.age = age

    def greet(this):
        print(f"Hello, my name is {this.name} and I am {this.age} years old.")

虽然上述代码可以正常运行，但不建议使用这种方式，因为它违背了 Python 的约定

2.3 类后是否需要加（）

类名后面是否需要加括号 () 取决于你是否需要指定父类（即继承）

不加括号：定义一个没有父类的类

定义的类没有继承任何其他类（即它是顶级类），那么类名后面不需要加括号。例如：

class MyClass:
    def __init__(self):
        self.value = 10

    def show(self):
        print("Value:", self.value)

加括号但为空：显式表示没有父类

在定义没有父类的类时，括号是可选的，但你也可以显式地加上括号，表示这个类没有继承任何父类。例如：

class MyClass():
    def __init__(self):
        self.value = 10

    def show(self):
        print("Value:", self.value)

加括号：定义一个继承父类的类

定义的类继承另一个类（即子类），那么需要在类名后面加上括号，并在括号中指定父类的名称。例如：

class ParentClass:
    def __init__(self):
        self.parent_value = 20

    def parent_method(self):
        print("Parent value:", self.parent_value)


class ChildClass(ParentClass):  # 继承 ParentClass
    def __init__(self):
        super().__init__()  # 调用父类的构造方法
        self.child_value = 30

    def show(self):
        print("Child value:", self.child_value)
        self.parent_method()  # 调用父类的方法

2.4 给属性指定默认值

默认值可以为属性提供一个初始值，这样在创建对象时可以省略某些参数，或者在没有提供参数时使用默认值。

2.4.1 在构造方法中指定默认值

在 init 方法中，可以通过为参数提供默认值来实现属性的默认值。如果在创建对象时没有提供相应的参数，Python 会自动使用默认值。
示例 1：为属性指定默认值

class Car:
    def __init__(self, make, model, year, color="white"):
        self.make = make  # 品牌
        self.model = model  # 型号
        self.year = year  # 年份
        self.color = color  # 颜色，默认为白色
        self.odometer_reading = 0  # 里程表初始值

    def get_descriptive_name(self):
        """返回整洁的描述性信息"""
        return f"{self.year} {self.make} {self.model} ({self.color})"

    def read_odometer(self):
        """打印一条指出汽车里程的消息"""
        print(f"This car has {self.odometer_reading} miles on it.")

    def update_odometer(self, mileage):
        """将里程表读数设置为指定的值"""
        if mileage >= self.odometer_reading:
            self.odometer_reading = mileage
        else:
            print("You can't roll back an odometer!")

    def increment_odometer(self, miles):
        """将里程表读数增加指定的量"""
        self.odometer_reading += miles

# 创建对象时可以省略颜色参数
car1 = Car("Toyota", "Corolla", 2020)
print(car1.get_descriptive_name())  # 输出：2020 Toyota Corolla (white)

# 也可以显式指定颜色
car2 = Car("Ford", "Mustang", 2022, "red")
print(car2.get_descriptive_name())  # 输出：2022 Ford Mustang (red)

2.4.2 在类定义中直接指定默认值

除了在构造方法中为参数指定默认值，还可以在类定义中直接为属性指定默认值。这种方式在构造方法中不需要为该属性提供参数

class Car:
    def __init__(self, make, model, year):
        self.make = make  # 品牌
        self.model = model  # 型号
        self.year = year  # 年份
        self.color = "white"  # 默认颜色为白色
        self.odometer_reading = 0  # 里程表初始值

    def get_descriptive_name(self):
        """返回整洁的描述性信息"""
        return f"{self.year} {self.make} {self.model} ({self.color})"

    def read_odometer(self):
        """打印一条指出汽车里程的消息"""
        print(f"This car has {self.odometer_reading} miles on it.")

    def update_odometer(self, mileage):
        """将里程表读数设置为指定的值"""
        if mileage >= self.odometer_reading:
            self.odometer_reading = mileage
        else:
            print("You can't roll back an odometer!")

    def increment_odometer(self, miles):
        """将里程表读数增加指定的量"""
        self.odometer_reading += miles

# 创建对象时不需要提供颜色参数
car1 = Car("Toyota", "Corolla", 2020)
print(car1.get_descriptive_name())  # 输出：2020 Toyota Corolla (white)

2.4.3 直接修改属性值

假设我们有一个 Car 类，其中包含一些属性，如 make、model、year 和 odometer_reading。我们可以通过直接访问这些属性来修改它们的值。

class Car:
    def __init__(self, make, model, year):
        self.make = make  # 品牌
        self.model = model  # 型号
        self.year = year  # 年份
        self.odometer_reading = 0  # 里程表初始值

    def get_descriptive_name(self):
        """返回整洁的描述性信息"""
        return f"{self.year} {self.make} {self.model}"

    def read_odometer(self):
        """打印一条指出汽车里程的消息"""
        print(f"This car has {self.odometer_reading} miles on it.")

    def update_odometer(self, mileage):
        """将里程表读数设置为指定的值"""
        if mileage >= self.odometer_reading:
            self.odometer_reading = mileage
        else:
            print("You can't roll back an odometer!")

    def increment_odometer(self, miles):
        """将里程表读数增加指定的量"""
        self.odometer_reading += miles

# 创建 Car 类的实例
my_car = Car("Toyota", "Corolla", 2020)

# 直接修改属性值
my_car.make = "Honda"  # 修改品牌
my_car.model = "Civic"  # 修改型号
my_car.year = 2022  # 修改年份
my_car.odometer_reading = 1000  # 修改里程表读数

# 打印修改后的属性值
print(my_car.get_descriptive_name())  # 输出：2022 Honda Civic
my_car.read_odometer()  # 输出：This car has 1000 miles on it.

通过方法修改属性值

class Car:
    def __init__(self, make, model, year):
        self.make = make  # 品牌
        self.model = model  # 型号
        self.year = year  # 年份
        self.odometer_reading = 0  # 里程表初始值

    def get_descriptive_name(self):
        """返回整洁的描述性信息"""
        return f"{self.year} {self.make} {self.model}"

    def read_odometer(self):
        """打印一条指出汽车里程的消息"""
        print(f"This car has {self.odometer_reading} miles on it.")

    def update_odometer(self, mileage):
        """将里程表读数设置为指定的值"""
        if mileage >= self.odometer_reading:
            self.odometer_reading = mileage
        else:
            print("You can't roll back an odometer!")

    def increment_odometer(self, miles):
        """将里程表读数增加指定的量"""
        self.odometer_reading += miles

# 创建 Car 类的实例
my_car = Car("Toyota", "Corolla", 2020)

# 通过方法修改属性值
my_car.update_odometer(2000)  # 修改里程表读数
my_car.increment_odometer(50)  # 增加里程

# 打印修改后的属性值
my_car.read_odometer()  # 输出：This car has 2050 miles on it.

直接修改属性值的缺点：
直接修改属性值可能会绕过类中定义的验证逻辑或处理逻辑。例如，如果里程表读数不允许回退，直接修改可能会导致数据不一致。
直接修改属性值可能会导致代码的可维护性降低，因为属性的修改没有通过统一的方法进行管理。
推荐的做法：
如果需要对属性值进行验证或处理，建议通过类的方法来修改属性值。这样可以确保属性的值始终处于一致的状态。
如果属性的修改不需要额外的逻辑，直接修改属性值也是可行的，但需要确保这种修改不会引发其他问题。

2.4.4 注意事项

• 默认值的覆盖：如果在创建对象时提供了参数值，那么默认值会被覆盖。

car2 = Car("Ford", "Mustang", 2022, "red")  # 指定颜色为红色
print(car2.get_descriptive_name())  # 输出：2022 Ford Mustang (red)

• 可变默认值：如果默认值是一个可变对象（如列表或字典），需要注意 Python 的行为。可变默认值在类定义时只被初始化一次，而不是每次创建对象时。为了避免意外行为，建议使用不可变类型作为默认值，或者在构造方法中显式地初始化可变对象。

class MyClass:
    def __init__(self, data=None):
        if data is None:
            data = []  # 显式初始化为空列表
        self.data = data

obj1 = MyClass()
obj1.data.append(1)
print(obj1.data)  # 输出：[1]

obj2 = MyClass()
print(obj2.data)  # 输出：[]，而不是 [1]

• 默认值的适用场景：默认值适用于那些在大多数情况下不需要用户显式指定的属性。例如，日志级别、初始状态等

导入类

从单个模块导入类

# module1.py
class MyClass:
    def __init__(self, name):
        self.name = name

    def greet(self):
        print(f"Hello, {self.name}!")

# main.py
from module1 import MyClass

obj = MyClass("Alice")
obj.greet()

导入整个模块，再访问类

# main.py
import module1

obj = module1.MyClass("Bob")
obj.greet()

导入多个类

# module1.py
class MyClass:
    def __init__(self, name):
        self.name = name

    def greet(self):
        print(f"Hello, {self.name}!")

class AnotherClass:
    def __init__(self, value):
        self.value = value

    def display(self):
        print(f"Value: {self.value}")

在另一个模块中导入并使用这些类：

# main.py
from module1 import MyClass, AnotherClass

obj1 = MyClass("Alice")
obj1.greet()

obj2 = AnotherClass(42)
obj2.display()

使用 init.py 文件导入包中的类

如果类定义在包中，可以通过包的结构来导入。例如，假设你有以下目录结构：

mypackage/
    __init__.py
    module1.py
    module2.py

module1.py 和 module2.py 分别定义了不同的类：

# mypackage/module1.py
class MyClass:
    def __init__(self, name):
        self.name = name

    def greet(self):
        print(f"Hello, {self.name}!")

# mypackage/module2.py
class AnotherClass:
    def __init__(self, value):
        self.value = value

    def display(self):
        print(f"Value: {self.value}")

可以在 init.py 文件中指定要导出的类：

# mypackage/__init__.py
from .module1 import MyClass
from .module2 import AnotherClass

然后在其他模块中直接从包中导入类：

# main.py
from mypackage import MyClass, AnotherClass

obj1 = MyClass("Alice")
obj1.greet()

obj2 = AnotherClass(42)
obj2.display()

使用 from … import * 导入所有类

虽然不推荐（因为它会污染命名空间），但你可以使用 from … import * 导入模块中的所有类。这需要在模块中定义 all 列表来指定哪些类可以被导入：

# module1.py
__all__ = ['MyClass', 'AnotherClass']

class MyClass:
    def __init__(self, name):
        self.name = name

    def greet(self):
        print(f"Hello, {self.name}!")

class AnotherClass:
    def __init__(self, value):
        self.value = value

    def display(self):
        print(f"Value: {self.value}")

导入

# main.py
from module1 import *

obj1 = MyClass("Alice")
obj1.greet()

obj2 = AnotherClass(42)
obj2.display()

输出

Hello, Alice!
Value: 42

注意事项

命名冲突：如果导入的类名与其他变量或类名冲突，可能会导致意外的行为。建议使用 import module 然后通过 module.ClassName 的方式访问类。
模块路径：确保模块或包在 Python 的搜索路径中（sys.path）。如果不在，可以使用 sys.path.append() 将其添加到路径中。
避免循环依赖：在模块之间相互导入时，要避免循环依赖，否则可能会导致导入失败或运行时错误。