你需要理解的Python核心概念-对象（你需要理解的Python核心概念-对象）

Python Object And Classes

对象是 Python 语言的构建块

Python 很容易学习。然而，它有一些更难理解的方面，比如类和对象的世界。在本文中，你将学到：

• 在 Python 中一切都是对象
• 如何创建自己的类和对象
• 什么是继承以及如何利用它来发挥自己的优势

通过揭开 Python 对象的神秘面纱，你对该语言的理解将大大增加！

对象

对象在 Python 中起着核心作用。让我们深入了解一下，以增加你对对象的理解。

你可能知道内置len函数。它返回你给它的对象的长度。但是，比如说，数字5 的长度是多少？让我们运行一下代码看看。

print(len(5))

我喜欢错误，因为它们说明了 Python 内部是如何工作的。在这种情况下，Python 告诉我们 5 是一个对象，它没有len().

在 Python 中，一切都是对象。字符串、布尔值、数字，甚至函数都是对象。

我们可以使用内置函数检查 REPL 中的对象dir()。当我们尝试dir使用数字 5 时，它会显示一个很大的函数列表，这些函数是任何数字对象的一部分

dir(5)

该列表以这些包含下划线的奇怪命名函数开头，例如__add__. 这些被称为魔术方法，或 dunder（双下划线的缩写）方法。

如果你仔细观察，你会发现类型对象没有__len__dunder 方法int。这就是 Python 的len()函数如何知道数字没有长度的方式。len()所做的就是调用你提供的对象上的方法__len__()。这也是 Python 抱怨 'int' 类型的对象没有len().

我在这里随便介绍了方法这个词。让我更正式地定义它：

当函数是对象的一部分时，我们称其为方法。

所以如果一个字符串确实有长度，它一定有一个__len__方法，对吧？让我们来了解一下！

dir("test")

可以看到字符串有__len__()这个方法。由于这是一个方法，我们也可以调用它：

"test".__len__() # 4

这相当于len("test")，但不那么优雅。所以不要这样做，这只是为了说明这些东西是如何工作的。

还有一系列其他不那么神奇的方法dir()向我们揭示了。随意尝试一些，例如

"test".islower() # true

此方法检查整个字符串是否为小写，因此 Python 返回 boolean True。其中一些方法需要一个或多个参数，例如replace：

"abcd".replace('a','b') # 它将所有出现的“a”替换为“b”。 # 'bbcd'

什么是对象

现在我们已经使用了对象并且知道 Python 中的一切都是对象，是时候定义对象是什么了：

对象是数据（变量）和对该数据进行操作的方法的集合

对象和面向对象编程是 1990 年代初流行的概念。早期的计算机语言，如 C，没有对象的概念。然而，事实证明，对象对于人类来说是一种易于理解的范式——它可以用来模拟许多现实生活中的情况。

如今，大多数（如果不是全部）新语言都有对象的概念。因此，你将要学习的内容在概念上也适用于其他语言。

由于对象是 Python 语言的构建块，因此你也可以自己创建对象是合乎逻辑的。为此，我们需要先定义一个类。

class

如果要创建自己的对象类型，首先需要定义它具有哪些方法以及它可以保存哪些数据。这个蓝图被称为一个类

类是对象的蓝图

所有对象都基于一个类。当我们创建一个对象时，我们称之为“创建一个类的实例”。字符串、数字甚至布尔值也是类的实例。让我们用内置函数来探索type：

>>> type('a') <class 'str'> >>> type(1) <class 'int'> type(True) <class 'bool'>

显然我们看到一些有名为str、int和的类bool。这些是 Python 的一些原生类，但我们也可以构建自己的类！

让我们创建一个代表汽车的类。

class Car: speed = 0 started = False def start(self): self.started = True print("Car started, let's ride!") def increase_speed(self, delta): if self.started: self.speed = self. speed delta print('Vrooooom!') else: print("你需要先启动汽车") def stop(self): self.speed = 0 print('Halting')

让我们首先创建并使用一个 Car 类型的对象

car = Car() car.increase_speed(10) car.start() car.increase_speed(40)

对象始终是类的实例。一个类可以有多个实例。我们刚刚创建了一个 Car 类的实例，使用Car()，并将其分配给变量car。创建一个实例看起来就像调用一个函数——你稍后会知道为什么。

接下来，我们在汽车对象上调用其中一种方法：尝试在它还没有启动的时候提高它的速度。哎呀！只有启动汽车后，我们才能提高它的速度并享受它发出的噪音。

现在让我们逐步回顾一下我们的 Car 类：

• 使用class后跟类名 (Car) 的语句定义类。我们用冒号开始一个缩进的代码块。
• 我们定义了两个变量，speed和started。这是该类的所有实例都将拥有的数据。
• 接下来，我们定义了三个对变量进行操作的方法。

在这些方法的定义中，我们遇到了一些特殊的情况：它们都有一个参数，称为self它们的第一个参数。

什么是self？

老实说，如果你问我，这是 Python 不太优雅的语言结构之一。

还记得我们在汽车对象上调用方法的时候car.start()吗？我们不必传递self变量，即使在类内部start定义start(self)。

这就是正在发生的事情：

1. 当我们在对象上调用方法时，Python 会自动填充第一个变量，我们self按照约定调用
2. 第一个变量是对对象本身的引用，因此它的名字
3. 我们可以使用这个变量来引用这个对象的其他实例变量和函数，比如self.speed和self.start()。

因此，仅在类定义中，我们使用 self 来引用属于实例一部分的变量。要修改started属于我们类的变量，我们使用self.started而不仅仅是started.

通过使用self，可以清楚地表明我们正在对作为此实例一部分的变量进行操作，而不是在对象外部定义并且恰好具有相同名称的其他变量。

从一个类创建多个对象

由于一个类只是一个蓝图，你可以使用它来创建多个对象，就像你可以构建多个外观相同的汽车一样。它们的行为都相似，但它们都有自己的数据，而不是在对象之间共享：

>>> car1 = Car() >>> car2 = Car() >>> id(car1) 139771129539104 >>> id(car2) 139771129539160

我们在这里创建了两个汽车对象，car1 和 car2，并使用内置方法id()获取它们的 id。Python 中的每个对象都有一个唯一的标识符，所以我们只是证明了我们从同一个类中创建了两个不同的对象。我们可以独立使用它们：

>>> car1.start() 车子启动了，我们骑吧！ >>> car1.increase_speed(10) 'Vrooom!' >>> car1.speed 10 >>> car2.speed 0

我们刚刚开始car1并增加了它的速度，而car2的速度没有发生改变，这就是不同的实例具有不同的状态。

构造函数

当从一个类创建一个对象时，看起来我们正在调用一个函数：

car = car()

但它看起来不仅仅是我们在调用一个函数，我们实际上是在调用一个函数！这个我们不必定义的方法称为构造函数。它构造并初始化对象。每个类默认都有一个，称为__init__，即使我们自己没有定义它。这与继承有关，稍后我将说明这一点。

你是否曾经使用该str()函数将对象转换为类？或者可能是 int() 函数将字符串转换为数字？

>>> 'a' str(1) 'a1' >>> int('2') 2 4

实际上在这里所做的是创建新的类型对象str并int通过调用类的构造函数str和int.

我们也可以重写该__init__方法，通过接受参数来赋予它额外的能力。让我们使用自定义构造函数重新定义 Car 类：

class Car: def __init__(self, started = False, speed = 0): self.started = started self.speed = speed def start(self): self.started = True print("Car started, let's ride!") def increase_speed(self, delta): if self.started: self.speed = self.speed delta print("Vrooooom!") else: print("你需要先启动汽车") def stop(self): self.speed = 0

我们的自定义构造函数使用默认值命名参数，因此我们可以通过多种方式创建 Car 类的实例：

>>> c1 = Car() >>> c2 = Car(True) >>> c3 = Car(True, 50) >>> c4 = Car(started=True, speed=40)

继承

在编程中，尽可能多地重用代码被认为是一种很好的风格。这种做法甚至有一个很好的首字母缩写词，称为 DRY：不要重复自己。

类可以帮助你避免重复代码，因为你可以编写一个类并基于它创建许多对象。但是，它们还以另一种方式为你提供帮助，称为继承。类可以从其他类继承属性和函数，因此你不必重复自己。

例如，我们希望我们的 Car 类从 Vehicle 类继承一些基础知识。而且，当我们这样做的时候，还要定义一个 Motorcycle 类。从示意图上看，它看起来像这样：

我们已经看到了继承的作用。还记得我告诉过你每个类都有一个构造函数（__init__），即使你没有定义一个？这是因为每个类都继承自 Python 中最基本的类，称为object：

dir(object)

当我告诉你“Python 中的一切都是对象”时，我的意思是一切。这包括类，如你所见，我们也可以dir()在类上使用。它表明object有一个__init__方法。

继承映射到许多现实生活中的情况。让我们根据上图来看看实际的继承。我们将从一个泛型Vehicle类开始：

class Vehicle: def __init__(self, started = False, speed = 0): self.started = started self.speed = speed def start(self): self.started = True print("Started, let's ride!") def stop(self): self.speed = 0 def increase_speed(self, delta): if self.started: self.speed = self.speed delta print("Vrooooom!") else: print("You need to start me first")

现在我们可以Car使用继承重新定义我们的类

class Car(Vehicle): trunk_open = False def open_trunk(self): trunk_open = True def close_trunk(self): trunk_open = False

我们的汽车从类中继承了所有的方法和变量Vehicle，但是增加了一个额外的变量和两个方法。

重写init方法

有时你想覆盖 init 函数。为了演示，我们可以创建一个 Motorcycle 类。大多数摩托车都有一个中心支架。我们将添加在初始化时将其输出或输入的功能：

class Motorcycle(Vehicle): def __init__(self, center_stand_out = False): self.center_stand_out = center_stand_out super().__init__()

当你覆盖构造函数时，根本不会调用来自父类（我们继承的）的构造函数。如果你仍然需要该功能，则必须自己调用它。这是通过super()：它返回对父类的引用，因此我们可以调用父类的构造函数。

在这种情况下，我们为中心支架添加了功能，但删除了在构造函数中设置速度和启动状态的选项。如果需要，你也可以添加速度和启动状态选项，并将它们传递给Vehicle构造函数。

覆盖其他方法

就像__init__，我们也可以覆盖其他方法。例如，如果你想实现一个不启动的摩托车，你可以重写 start 方法：

class Motorcycle(Vehicle): def __init__(self, center_stand_out = False): self.center_stand_out = center_stand_out super().__init__() def start(self): print("Sorry, out of fuel!")

感谢你的阅读。如果你想了解有关 Python 的更多信息，请关注我。

,