【Python篇】Python 类和对象：详细讲解（上篇）

文章目录

Python 类和对象：详细讲解
- 1. 什么是类（Class）
- - 类的定义
- 2. 什么是对象（Object）
- - 创建对象
- 3. 属性和方法
- - 属性（Attributes）
  - 方法（Methods）
  - 在类中定义属性和方法
  - 使用对象的属性和方法
- 4. self 参数的作用
- 5. 总结1
- - 两个问题
  - - 1. Python 类中的缩进
    - 2. 为什么 Python 没有像 C++ 那样单独定义成员变量
    - - 2.1 动态语言的特性
      - 2.2 `__init__` 方法的灵活性
      - 2.3 灵活性和可扩展性
      - 结论
- 6. 实例化多个对象
- - 实例化多个对象
  - 代码解读：
- 7. 添加更多方法
- - 为类添加新的方法
  - 代码解读：
- 8. 类的继承
- - 什么是继承？
  - 代码解读：
- 9.总结2
写在最后

Python 类和对象：详细讲解

在编程中，类和对象是面向对象编程（OOP）的核心概念。Python 是一门支持面向对象编程的语言，这意味着你可以使用类和对象来组织代码，使其更加模块化、可维护和可扩展。

1. 什么是类（Class）

类是一个蓝图或模板，用来描述某一类对象的共同特征和行为。它定义了对象应该具有什么属性（变量）和行为（方法）。
举个例子，如果你要创建一个汽车管理系统，你可能会定义一个 Car 类，其中包括汽车的品牌、颜色、速度等属性，以及启动、停止、加速等行为。

类的定义

在 Python 中，类使用 class 关键字来定义。让我们来看一个简单的例子：

class Car:
    # 类的属性和方法定义在这里
    pass

class Car: 是类的定义，其中 Car 是类的名称。
pass 是一个占位符，表示目前类中没有任何内容，但这是一个合法的类定义。

2. 什么是对象（Object）

对象是根据类创建的具体实例。你可以把类看作是一个模具，而对象则是根据这个模具制作出来的具体产品。
如果 Car 是一个类，那么你可以创建多个对象来代表不同的汽车，如 my_car，your_car 等。

创建对象

要创建一个对象，只需要调用类本身，就像调用一个函数一样：

my_car = Car()

my_car 是 Car 类的一个实例或对象。
现在，my_car 这个对象可以拥有 Car 类中定义的所有属性和行为。

3. 属性和方法

属性（Attributes）

属性是对象的状态或特征。它们是存储在对象中的变量。
例如，汽车的品牌、颜色、速度都可以作为属性来存储在 Car 对象中。

方法（Methods）

方法是对象可以执行的操作或行为。它们是定义在类中的函数。
例如，汽车可以启动、停止、加速，这些行为可以通过方法来实现。

在类中定义属性和方法

让我们扩展 Car 类，添加一些属性和方法：

class Car:
    # 定义属性
    def __init__(self, brand, color):
        self.brand = brand  # 汽车品牌
        self.color = color  # 汽车颜色

    # 定义方法
    def start(self):
        print(f"The {self.color} {self.brand} car is starting.")

    def stop(self):
        print(f"The {self.color} {self.brand} car is stopping.")

__init__ 方法：这是一个特殊的方法，当你创建对象时，Python 会自动调用它。这个方法用于初始化对象的属性。self 是对象自身的引用，后面会详细解释。
start 和 stop 方法：这些是普通的方法，用于描述汽车的行为。

使用对象的属性和方法

现在我们可以创建一个 Car 对象，并使用它的属性和方法：

my_car = Car("Toyota", "Red")
print(my_car.brand)  # 输出: Toyota
print(my_car.color)  # 输出: Red

my_car.start()  # 输出: The Red Toyota car is starting.
my_car.stop()   # 输出: The Red Toyota car is stopping.

当我们创建 my_car 对象时，__init__ 方法被自动调用，brand 被设置为 “Toyota”，color 被设置为 “Red”。
我们可以通过 my_car.brand 和 my_car.color 访问对象的属性，也可以调用 start() 和 stop() 方法来执行相应的行为。

4. self 参数的作用

在方法定义中，self 参数用于指代当前对象的实例。在方法内部，通过 self 可以访问对象的属性和其他方法。
当调用方法时，Python 会自动将调用该方法的对象传递给 self。因此，在定义方法时，self 必须作为第一个参数。

举个例子：

class Car:
    def __init__(self, brand, color):
        self.brand = brand
        self.color = color

    def start(self):
        print(f"The {self.color} {self.brand} car is starting.")

当你调用 my_car.start() 时，实际上等同于 Car.start(my_car)，即 Python 会自动将 my_car 对象传递给 self。

5. 总结1

类：一个蓝图，定义了一类对象的属性和行为。
对象：根据类创建的具体实例，具有类定义的属性和方法。
属性：对象的特征或状态，存储在对象中的变量。
方法：对象的行为或操作，定义在类中的函数。
self 参数：引用当前对象，用于访问对象的属性和方法。

两个问题

1. Python 类中的缩进

在 Python 中，缩进是代码块的唯一表示方式，这与 C++ 和许多其他语言不同。在 Python 中，没有使用 {} 来定义代码块，而是通过缩进来明确代码块的层级关系。

类的缩进：
- 在类定义的最外层，所有方法和属性的定义都需要有相同的缩进级别。
- 类中的每个方法或函数，其内容需要进一步缩进，以表示它们属于该方法。
例如：
```
class Car:
    def __init__(self, brand, color):
        self.brand = brand  # 这行代码相对于方法的定义缩进了一个层级
        self.color = color

    def start(self):
        print(f"The {self.color} {self.brand} car is starting.")
```
在这个示例中：
- def __init__(self, brand, color): 是类的一个方法，它相对于 class Car: 缩进了四个空格（或一个 tab）。
- self.brand = brand 和 self.color = color 是 __init__ 方法中的代码，它们相对于 def __init__ 缩进了四个空格。

2. 为什么 Python 没有像 C++ 那样单独定义成员变量

在 Python 中，没有像 C++ 那样在类的开头单独定义成员变量（属性）的部分。这是因为 Python 采用了一种更灵活的方式来处理对象的属性。这种设计有几个重要原因：

2.1 动态语言的特性

动态类型
- Python 是一种动态类型的语言，这意味着变量的类型在运行时决定，并且你可以在程序的任何地方为对象添加新的属性。
- 这与 C++ 等静态类型语言不同。在 C++ 中，你必须在编译时定义对象的所有成员变量（属性）的类型和数量。

2.2 `init` 方法的灵活性

属性在 __init__ 方法中定义：
- 在 Python 中，通常通过 __init__ 方法来初始化对象的属性。__init__ 方法是一个构造函数，当你创建一个对象时，这个方法会被自动调用。
- 在 __init__ 方法中使用 self 关键字定义的属性，实际上就是成员变量。这种方式可以根据初始化时传入的参数动态地定义和设置对象的属性。
例如：
```
class Car:
    def __init__(self, brand, color):
        self.brand = brand  # 这里 brand 就是一个成员变量
        self.color = color  # color 也是一个成员变量
```
- 在这个例子中，brand 和 color 是 Car 对象的成员变量，通过 self.brand 和 self.color 在 __init__ 方法中定义。

2.3 灵活性和可扩展性

动态添加属性：
- Python 的对象可以在程序的运行时动态地添加或修改属性。这为程序设计提供了极大的灵活性。
例如：
```
my_car = Car("Toyota", "Red")
my_car.year = 2020  # 动态添加一个新的属性 year
```
在运行时，你可以为 my_car 对象添加一个新的属性 year，这是在 C++ 等静态类型语言中难以实现的。
更少的冗余：
- 由于 Python 的灵活性，你不需要在类的定义中事先声明所有可能的属性，而是可以根据实际需要在 __init__ 方法或其他方法中定义它们。

结论

缩进：Python 使用缩进来明确代码块的层级关系，因此类中的方法和属性都需要适当缩进，以表示它们的层次。
属性定义：
- Python 不需要像 C++ 那样在类的开头单独定义成员变量，而是通常在 __init__ 方法中通过 self 来定义对象的属性。
- 这种方式更灵活，可以根据传入参数动态定义属性，并且可以在运行时动态添加或修改对象的属性。

6. 实例化多个对象

在前面的例子中，我们已经学会了如何创建一个对象，并使用它的属性和方法。现在我们将学习如何创建多个对象，并理解对象之间的独立性。

实例化多个对象

当你实例化多个对象时，每个对象都是类的一个独立实例，拥有自己独立的属性值。这意味着你可以创建多个对象，它们可以拥有不同的状态（属性值），但都可以共享相同的行为（方法）。

class Car:
    def __init__(self, brand, color):
        self.brand = brand  # 每个对象都有独立的 brand 属性
        self.color = color  # 每个对象都有独立的 color 属性

    def start(self):
        print(f"The {self.color} {self.brand} car is starting.")

    def stop(self):
        print(f"The {self.color} {self.brand} car is stopping.")

# 创建多个对象
car1 = Car("Toyota", "Red")
car2 = Car("Honda", "Blue")
car3 = Car("Ford", "Black")

# 使用这些对象
car1.start()  # 输出: The Red Toyota car is starting.
car2.start()  # 输出: The Blue Honda car is starting.
car3.start()  # 输出: The Black Ford car is starting.

代码解读：

独立的对象：car1, car2, car3 是 Car 类的三个独立实例。每个对象都有自己的 brand 和 color 属性。
方法的共享：虽然每个对象的属性值不同，但它们都可以调用 start() 和 stop() 方法，这些方法在所有对象之间是共享的。

通过实例化多个对象，你可以清晰地理解对象之间的独立性和类的灵活性。

7. 添加更多方法

我们已经学习了如何定义基本的方法，现在我们将进一步扩展我们的类，添加更多的方法以模拟更加复杂的行为。

为类添加新的方法

你可以为类添加任意数量的方法，这些方法可以操作对象的属性或执行特定的任务。让我们继续扩展 Car 类，添加一个 accelerate 方法，用来模拟汽车的加速。

class Car:
    def __init__(self, brand, color):
        self.brand = brand
        self.color = color
        self.speed = 0  # 初始速度为0

    def start(self):
        self.speed = 10  # 启动后设置初始速度
        print(f"The {self.color} {self.brand} car is starting at {self.speed} km/h.")

    def accelerate(self, increase):
        self.speed += increase
        print(f"The {self.color} {self.brand} car is accelerating to {self.speed} km/h.")

    def stop(self):
        self.speed = 0  # 停车时速度为0
        print(f"The {self.color} {self.brand} car is stopping.")

# 使用新的方法
car1 = Car("Toyota", "Red")
car1.start()         # 输出: The Red Toyota car is starting at 10 km/h.
car1.accelerate(30)  # 输出: The Red Toyota car is accelerating to 40 km/h.
car1.stop()          # 输出: The Red Toyota car is stopping.

代码解读：

speed 属性：我们添加了一个 speed 属性来跟踪汽车的速度。
accelerate 方法：这个方法用于增加汽车的速度。它接收一个 increase 参数，用来指定要增加的速度值。

8. 类的继承

继承是面向对象编程的一个重要特性，它允许你通过创建一个新的类，复用已有类的属性和方法。继承使得代码更加模块化、可重用和易于维护。

什么是继承？

继承：当一个类（子类）继承另一个类（父类）时，子类自动拥有父类的所有属性和方法。你可以在子类中添加新的属性和方法，或者重写父类的方法。

让我们定义一个 ElectricCar 类，它继承自 Car 类，并添加一些特有的功能。

class Car:
    def __init__(self, brand, color):
        self.brand = brand
        self.color = color
        self.speed = 0

    def start(self):
        self.speed = 10
        print(f"The {self.color} {self.brand} car is starting at {self.speed} km/h.")

    def accelerate(self, increase):
        self.speed += increase
        print(f"The {self.color} {self.brand} car is accelerating to {self.speed} km/h.")

    def stop(self):
        self.speed = 0
        print(f"The {self.color} {self.brand} car is stopping.")

# 定义一个 ElectricCar 类，继承自 Car 类
class ElectricCar(Car):
    def __init__(self, brand, color, battery_capacity):
        super().__init__(brand, color)  # 调用父类的构造函数
        self.battery_capacity = battery_capacity  # 电池容量

    def charge(self):
        print(f"The {self.color} {self.brand} electric car is charging with {self.battery_capacity} kWh capacity.")

# 使用 ElectricCar 类
electric_car = ElectricCar("Tesla", "White", 85)
electric_car.start()  # 调用继承的 start 方法
electric_car.accelerate(50)  # 调用继承的 accelerate 方法
electric_car.charge()  # 调用 ElectricCar 类中特有的方法
electric_car.stop()  # 调用继承的 stop 方法

代码解读：

super() 函数：在 ElectricCar 类中，我们使用 super() 函数调用了父类的 __init__ 方法，以便在子类中初始化父类的属性。
子类扩展：ElectricCar 类扩展了 Car 类，添加了一个新的属性 battery_capacity，以及一个新的方法 charge。