Python面向对象编程全解析：从零基础到精通类、对象、继承、属性和方法

程序员宝藏库：

全文 5000 字，能让你完全弄明白 Python 类、对象、面向对象、继承、属性、方法等相关内容。

每当看到面向对象的编程（Object-Oriented Programming ，OOP）这个术语，我们就会将其与 Java 联系起来。

事实上，Java让面向对象的编程风格得到了普及。除了 Java 以外，存在着很多 OOP 语言。比如，C++是 OOP 语言；C#也是 OOP 语言；Swift 同样是 OOP 语言；JavaScript 属于 OOP 语言；php 是 OOP 语言。当然，Python 也包含在其中。

Python提供了一种以对象为导向的编程风格。今天，我将逐步地进行讲解。我要讲解的是 Python 面向对象。我保证，即使是完全没有基础的小白，在看完这篇文章之后，也能够完全搞清楚 Python 面向对象。

在本文里，我会从以下这些主题给大家介绍 Python 面向对象编程的基础知识：

类对象继承属性方法1 基本概念1.1 类

什么是OOP中的类？

首先，借助一张图片来理解这个概念。

从上面的图片中，我们能够看到这些信息：有类，有对象，有属性，有方法，还有一只皮卡丘。

这与OOP有什么关系？

好吧，上面的图片正是帮助我们理解OOP概念的东西。

所以，现在进入第一个话题。

OOP 中类的含义是什么？类的定义表明“类是同一类型的对象的集合”。

把这个定义与上面的例子联系起来。

在这幅图里，我们能够看到有一个矩形框，它的名字叫小精灵（Pokemon），而这就是类的名称。

简而言之，类就是一个对象的集合。在 pokemon 宇宙中，所有的 pokemon 都属于“pokemon”类。

为了确保理解，再讲一个示例。

以常见的汽车为例，像日产、特斯拉、福特、丰田这些，能够被理解为一个个独立的对象，而“汽车”这个词则是由这一系列对象组合、汇聚而成的。

1.2 对象

前面已经反复的提到对象这个概念，接下来再具体的解释一下。

在 OOP 里，对象属于一个类的组成部分或成员。拿我们的小精灵例子来说，每一个小精灵都是小精灵类所对应的一个对象。例如，皮卡丘是口袋妖怪类的一个对象。再比如，丰田是汽车类的一个对象。

1.3 属性

回到我们的 Pokemon 例子。让我们把注意力集中在图像中的皮卡丘上。观察它一会儿。你看到了什么呢？

观察皮卡丘的图像，我们能看到它具备两只耳朵，有两只手，长着两条腿，其脸颊上存在两个红色的小圆点，并且还有一个非常显著的黄色。

在图片的邻接表格里，我们看到了一些情况。比如，有名称为“皮卡丘”的，其类型是“电动”，并且健康状况为 70。

这些都被称作属性，属性能够提供关于类或者对象的额外信息。

在这种情形之下，这些属性都为皮卡丘对象提供了额外的信息，像它的颜色以及健康状况等。

1.4 方法

在 Pokemon 这个示例里，从图表中能够看到像 attack()、dodge()、evolve()这样的东西，而这些东西就是所谓的方法。

更简单地解释，方法基是与某个特定对象相关的动作。

在这种情况下，这些动作与我们的皮卡丘对象有关。

很多同学到目前为止，对面向对象中的一些概念有了基本的了解。

下面，就实践起来，看一下Python面向对象到底该怎么用。

2 实践2.1 创建类

class Pokemon():

从上面的代码里可以看出，在 Python 里创建一个类的时候，是需要遵循一定结构的。

以关键字 class 开始，这样一来，Python 能够识别出我们要创建的对象将被当作一个类。

关键字 class 后面跟着的是类的名称，在这个例子当中是 Pokemon 。

最后，它的后面是()，然后是:字符。

当然，到这里类还没有创建好，还需要一些其他的内容。

创建**init方法**

我们继续进行类的创建任务，下一步要创建一个方法，这个方法很特殊，它名为 init。

你可能会问：这个init方法是什么？

简单理解这个概念的话，可以认为 init 方法和 Java 中的构造方法有相似之处。

我之前专门写过一篇文章进行介绍，想深入了解的可以看一下：

先给出具体代码：

class Pokemon():
  def __init__():

从上述代码能够看出，已经在 Python 里创建了 init 方法。

在这里，我们注意到一件事。名为 def 的关键字在 Python 中被使用。它主要用于创建函数或者方法。

添加属性

目前已经定义了 init( )方法。然而，它尚未被完全定义。仍然需要在 init( )方法中传递一些参数，以完成它的定义。

接下来，让给init( )方法中添加这些参数。

class Pokemon():
初始化函数，接收三个参数，分别是名称（name）、类型（Type）和生命值（health）。
    self.name = name
    self.Type = Type
    self.health = health

从上述代码能够看出，我在 init( )这个方法里传递了诸多参数。接下来让我们回过头去，来了解一下在此处传递的究竟是什么参数。

还记得前面介绍过的那些概念吧？我们曾经讨论过皮卡丘的颜色是黄色的，并且它的脸颊上有两个红点等等。这些方面都是与一个对象相关的属性，在这个 init ( )方法里，我们要对这些属性进行定义。

除此之外，再解释一下另外一个问题：self的用途是什么？

简单解释，self 是一个关键字，它的作用是把这些属性与我们的类相连接，在本例中就是与 Pokemon 相连接。

2.2 创建方法

我们已经声明了我们的类。这个类名为 init()。同时还声明了类的属性。

接下来，继续进行最后的部分，即方法的创建。

class Pokemon():
  def __init__(self,name,Type,health):
    self.name = name
    self.Type = Type 
    self.health = health
  def attack(self):
    print("Electric attack!")
  def dodge(self):
    print("Pikachu Dodge!")
  def evolve(self):
    print("Evolving to Raichu!")

从上面的代码中你可以看到，我创建了 3 个方法。这 3 个方法分别名为 attack()、dodge()、evolve()。

观察这段代码，你能够看到我们给每个方法都传递了一个参数，这个参数名为 self。在这个过程中，正通过 self 关键字把这个方法和我们的类关联起来。

到此为止，就创建了一个完整的类。

2.3 创建对象

首先，给出创建对象的代码，在这个过程中我创建了一个名为 pk1 的对象。

Pokemon 被创建并赋值给 pk1，其名称为 "Pikachu"，属性为 "Electric"，初始生命值为 120

创建完对象之后，我们就可以做很多操作。

访问属性

我们可以通过.的方法来访问对象的属性，来看一下具体的代码：

pk1.name  # 输出：Pikachu
pk1.Type  # 输出：Electric
pk1.health  # 输出：120

访问方法

访问方法以及访问属性类型。具体而言，通过具体的代码能够更加清晰地进行解释：

pk1 执行 attack() 操作，其输出为 Electric attack!
pk1 执行 dodge() 函数，其输出为 Pikachu Dodge!
pk1 进行 evolve()操作，输出为正在进化到 Raichu！

到这里，就讲解完了Python面向对象编程的基本内容。

下面，就再进阶一下，介绍一下面向对象编程中的继承。

2.4 继承

OOP 中的关键概念之一是继承，我们可以借助一个简单的例子来更轻松地理解这个概念。

考虑一个例子，是超级跑车，比如迈凯轮 720S spyder。

你可以看到，和大多数其他汽车一样，它具备一些共同的特征。它有门，有挡风玻璃，有 4 个轮子，有头灯，有尾灯等等。

它是一辆超级跑车，所以有自己的定制特征。它配备了 720 马力的 V8 涡轮增压发动机，这台发动机是由迈凯轮开发的。它还有定制的变速箱，该变速箱也是由迈凯轮开发的。此外，它还有定制的 AWD（全轮驱动）系统。

现在把它和面向对象的术语相联系。我们可以说，这辆车从它的父类那里继承了某种特征。在这种情形下，它首先属于汽车类。

这就是 "继承"背后的概念。

继承是一种现象，一个元素会从它的父类那里获得特征。迈凯伦 720S spyder 有这样的情况，它从汽车类中继承了所有的共同特征。同时，它自身也具备某些特殊的特征。

超类和子类

我们的元素所继承的那个类，就像本例中的汽车类，被称作超类。这个超类具有通用性。

这些特征被继承的类被称作子类（Subclass），它本质上具有特殊性。

接下来，在 Python 中实现这些概念。

在这个例子里，我会创建两个类。一个类名为 Car，它是超类。另一个类名为 McLaren，它是子类。这个 McLaren 类会继承 Car 类的所有属性。

class Car():
初始化函数，接收以下参数：ndoors 表示门的数量；nwheels 表示轮子的数量；tailLight 表示尾灯的状态；headLight 表示头灯的状态。
    self.ndoors = ndoors
    self.nwheels = nwheels
    self.tailLight = tailLight
    self.headLight = headLight

在这里，已经创建了第一个名为Car的类。

现在，我们要创建一个新类，这个新类的名字叫 McLaren。并且，这个新类将会继承之前那个类的所有属性。

class McLaren(Car):
初始化函数接收多个参数，包括门的数量 ndoors、车轮的数量 nWheels、尾灯 tailLight、头灯 headLight、发动机 Engine 以及车轮驱动方式 Wheel_Drive。
Car 初始化自身，传入参数 ndoors、nWheels、tailLight 和 headLight。
    self.Engine = Engine
self 的 Wheel_Drive 等于 Wheel_Drive 。
  def Drive(self):
打印出“我正在驾驶迈凯伦 720S 蜘蛛”

你在上面的代码中可以看到，McLaren 类继承了 Car 类。所以在创建 McLaren 类的时候，把 Car 当作参数之一。这是 Python 类继承的一种机制。

我们创建一个 McLaren 的对象，接着验证它是否继承了 Car 的特征。

mk1 是 McLaren 车型，其具有“4”的相关特征，还有“4”的另一特征，是“Yes”的情况，也是“Yes”的另一种情况，发动机类型为“V8”，驱动方式为“AWD”。

然后，再访问一下对象的属性：

mk1.Engine # 输出：V8
mk1.Wheel_Drive # 输出：AWD

我们在这里可以看到，能够访问 McLaren 对象中那些专门定义的特殊属性，而这些属性在基类 Car 里是不存在的。

我们在这里继承了基类。让我们来看一看，基类中的那些属性在我们的 McLaren 类中是否被继承了。

mk1.headLight # 输出：YES
mk1.ndoors # 输出：4
mk1.nWheels # 输出：4

可以看到，新创建的 McLaren 类的对象具备了 Car 基类的所有特征。这表明在当前的这个上下文中，继承的机制得到了正确的实施。

到此为止，从基本概念开始，一直到实践层面，涵盖了 Python 中的类、对象、特殊方法、属性、方法等这些概念以及具体的实现方式。已经全面地介绍了 Python 面向对象中的相关知识和内容。那么，是不是已经对 Python 面向对象有了彻底的了解呢？