Python 30 天 – 第 9 天 – OOP 核心原则

本文是 30 天 Python 挑战系列的一部分。您可以在此处找到本系列之前所有帖子的链接，

• Python 30 天 – 第一天 – 简介
• Python 30 天 – 第 2 天 – 数据类型 I
• Python 30 天 – 第 3 天 – 数据类型 II
• Python 30 天 – 第 4 天 – 数据类型 III
• Python 30 天 – 第 5 天 – 条件和循环 I
• Python 30 天 – 第 6 天 – 循环 II 和函数
• Python 30 天 – 第 7 天 – 开发者环境
• Python 30 天 – 第 8 天 – OOP 基础知识

通过该课程，你将学习基本的面向对象概念，如类和对象、属性和方法、抽象、封装、继承和多态性——OOP的四大支柱

封装

在我之前的文章中介绍了 OOP 的基础知识时，我已经间接介绍了封装。简单来说，封装意味着创建一个容器，其中的属性和与这些属性关联的操作被组合在一起。

class Avenger:  
  def __init__(self, name, knownAs):  
    self.name = name  
    self.knownAs = knownAs  
  
  def reveal_identity(self):  
    print(f'I am {self.name}, also known as {self.knownAs}')  
  
hulk = Avenger('Bruce Banner', 'Hulk')  
iron_man = Avenger('Tony Stark', 'IronMan')  
  
hulk.reveal_identity() # I am Bruce Banner, also known as Hulk  
iron_man.reveal_identity() # I am Tony Stark, also known as IronMan 

在上面的类中，当调用reveal_identity方法时，揭示了每个Avenger 的身份。也就是说，他们的身份已经被封装了。这些执行某些操作的方法使类如此强大。从类创建对象时，我们可以调用这些方法来执行操作，而无需担心它们如何执行这些操作。就像复仇者联盟一样！

抽象

要学习驾驶汽车，我们只需要了解 3 件事 – A、B 和 C，即油门、制动器和离合器（现在有了自动驾驶汽车，就更简单了）。作为司机，我们不需要知道是什么让汽车加速或在刹车时汽车是如何停下来的。这称为抽象。它在现实生活中无处不在。轻按电源按钮启动计算机，点击屏幕从我们的手机中捕获照片等。在上面的示例中，reveal_identity 方法被抽象化。

class Avenger:  
  def __init__(self, name, knownAs):  
    self.name = name  
    self.knownAs = knownAs  
  
  def reveal_identity(self):  
    print(f'I am {self.name}, also known as {self.knownAs}')  
  
hulk = Avenger('Bruce Banner', 'Hulk')  
  
hulk.name = 'Thanos'  
hulk.knownAs = 'Loki'  
  
hulk.reveal_identity() # I am Thanos, also known as Loki  

上面的类实现有问题。虽然创造了绿巨人，但洛基来了，决定将绿巨人伪装成灭霸！这不是我现在想要的，尽管实现了封装和抽象，但可以从外部篡改或修改内部功能。

Python 默认不支持创建私有变量。将不得不探索更多，看看是否有可能使变量和方法不可访问并获得真正的抽象。

然而，有一个约定是通过在它前面加上 _ 来创建一个私有变量。这允许其他开发人员将其识别为私有变量，而不会意外地尝试更新这些变量和方法（尽管他们可以）。这与我们在 JavaScript 世界中定义私有变量的方式非常相似。

继承

顾名思义，继承意味着从父级继承属性和功能。基于父类，可以创建任意数量的从父类继承的子类。这样做是为了在相似的类之间共享功能，而无需一次又一次地编写相同的逻辑。

class Player:  
  def __init__(self, name, age):  
    self.name = name  
    self.age = age  
  
  def run(self):  
    return f'{self.name} is running'  
  
class Cricketer(Player): # Syntax to inherit a class  
  def catch_ball(self):  
    return f'{self.name} Caught the ball'  
  
class Batsman(Cricketer):  
  def swing_bat(self):  
    return f'what a shot by {self.name}'  
  
player1 = Batsman('Virat Kohli', 31)  
  
print(player1.run())  
print(player1.catch_ball())  
print(player1.swing_bat())  

player1 是 Batsman 类的一个实例。Batsman 是Cricketer的一个子类。在 JavaScript 世界中，类是使用 extends 关键字继承的。所以我只是在我的心智模型中对两者进行了另一个比较。类 Cricketer 再次是 Player 的子类或子类，或者换句话说，它继承了 Player 类。

由于 player1 是从 Batsman 创建的对象，因此它具有swing 的功能。

它还继承了 Cricketer 类的能力。

它还继承了从 Player 类运行的能力。

在 Python 中，有一个非常方便的内置函数 isinstance 来检查一个对象是否是一个类的实例。

class Player:  
  def __init__(self, name, age):  
    self.name = name  
    self.age = age  
  
  def run(self):  
    return f'{self.name} is running'  
  
class Cricketer(Player):  
  def catch_ball(self):  
    return f'{self.name} Caught the ball'  
  
class Batsman(Cricketer):  
  def swing_bat(self):  
    return f'what a shot by {self.name}'  
  
player1 = Batsman('Virat Kohli', 31)  
  
print(isinstance(player1, Batsman)) # True  
print(isinstance(player1, Cricketer)) # True  
print(isinstance(player1, Player)) # True  
print(isinstance(player1, object)) # True  

由于 Python 中的一切都是对象，所有类都从这个基类对象继承所有属性和方法

多态性

Python中多态的作用，让具有不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同内容(功能)的函数。

class ProgrammingLanguage:  
  def __init__(self, name):  
    self.name = name  
  
class JavaScript(ProgrammingLanguage):  
  def comment(self):  
    return(f'// A Comment in {self.name}')  
  
class Python(ProgrammingLanguage):  
  def comment(self):  
    return(f'# A comment in {self.name}')  
  
language1 = JavaScript('JavaScript')  
language2 = Python('Python')  
  
def add_comment(languageObject):  
  print(languageObject.comment())  
  
add_comment(language1) # // A Comment in JavaScript  
add_comment(language2) # # A comment in Python  
  
for language in [language1, language2]:  
  print(language.comment())  
# // A Comment in JavaScript  
# # A comment in Python  

在上面的代码块中，我创建了一个通用函数 add_comment，它接受一个编程语言对象并调用它的comment()方法。相同的注释方法，当使用不同的对象调用时，会根据它们对注释方法的实现产生不同的结果。

在第二种情况下，当循环遍历语言对象列表时，对它们调用相同的方法会产生不同的结果。

这就是多态。

虽然对于何时使用什么 OOP 原则没有具体的指导方针或规则，但这取决于问题陈述，并且可以通过应用 OOP 的概念以多种方式实现解决方案。

这就是今天的内容。我的心智模型可能正在逐渐演变，试图构建编程概念的网格。

明天我计划完成剩余的 OOP 概念并做一些有趣的编码练习，然后再跳入另一个令人兴奋的编程范式。