Python - 面向对象概念

---

---

OOP 是一个缩写，代表面向对象编程范式。它被定义为一种编程模型，使用对象的概念，对象指的是具有状态和行为的现实世界实体。本章帮助您成为 Python 语言中使用面向对象编程支持的专家。

Python 是一种支持面向对象编程的编程语言。这使得创建和使用类和对象变得简单。如果您之前没有面向对象编程的经验，那么您来对地方了。让我们从讨论面向对象编程 (OOP) 的一个小介绍开始，以帮助您。

过程式方法

20 世纪 50 年代和 60 年代开发的早期编程语言被认为是过程式（或面向过程）语言。

计算机程序通过按逻辑顺序编写一系列指令来描述执行特定任务的过程。更复杂程序的逻辑被分解成更小但独立且可重用的语句块，称为函数。

每个函数都以这样一种方式编写，即它可以与程序中的其他函数交互。属于一个函数的数据可以轻松地以参数的形式与其他函数共享，并且被调用的函数可以将其结果返回给调用函数。

与过程式方法相关的主要问题如下：-

• 其自顶向下的方法使程序难以维护。

• 它使用了大量的全局数据项，这是不希望的。过多的全局数据项会增加内存开销。

• 它更重视过程，而没有将数据视为同等重要，并将其视为理所当然，从而使其在程序中自由移动。

• 数据在函数之间不受限制地移动。在现实生活中，期望函数与其要处理的数据之间存在明确的关联。

Python - 面向对象概念

在现实世界中，我们处理和处理对象，例如学生、员工、发票、汽车等。对象不仅是数据，也不仅是函数，而是两者的组合。每个现实世界的对象都与其相关的属性和行为。

属性

• 学生的姓名、班级、科目、分数等

• 员工的姓名、职位、部门、薪水等

• 发票号码、客户、产品代码和名称、价格和数量等，在一个发票中

• 汽车的注册号、车主、公司、品牌、马力、速度等

每个属性都将有一个与其关联的值。属性等同于数据。

行为

处理与对象关联的属性。

• 计算学生的平均成绩

• 计算应付给员工的奖金

• 对发票金额征收 GST

• 测量汽车的速度

行为等同于函数。在现实生活中，属性和行为不是相互独立的，而是共存的。

面向对象方法最重要的特征是将属性及其功能定义为一个称为类的单元。它作为所有具有相似属性和行为的对象的蓝图。

在 OOP 中，类定义了其对象具有的属性，以及其行为。另一方面，对象是类的实例。

OOPs 概念的原则

面向对象编程范式以以下原则为特征：-

• 类

• 对象

• 封装

• 继承

• 多态

类 & 对象

类（class）是用户自定义的对象原型，它定义了一组属性来描述该类任何对象的特征。这些属性包括数据成员（类变量和实例变量）和方法，可以通过点运算符访问。

对象（object）指的是某个类的实例。例如，名为 obj 且属于类 Circle 的对象就是该类的实例。它是根据其类定义的数据结构的唯一实例。对象包含数据成员（类变量和实例变量）和方法。

示例

以下示例演示了如何在 Python 中创建类及其对象。

# defining class
class Smartphone:
   # constructor    
   def __init__(self, device, brand):
      self.device = device
      self.brand = brand
   
   # method of the class
   def description(self):
      return f"{self.device} of {self.brand} supports Android 14"

# creating object of the class
phoneObj = Smartphone("Smartphone", "Samsung")
print(phoneObj.description()) 

执行上述代码后，将显示以下输出：

Smartphone of Samsung supports Android 14

封装

类的成员数据只能供类内部定义的函数处理。另一方面，类的函数可以从类上下文外部访问。因此，对象数据对类外部的环境是隐藏的。类函数（也称为方法）封装了对象数据，以防止对其进行未经授权的访问。

示例

在这个例子中，我们使用封装的概念来设置桌面的价格。

class Desktop:
   def __init__(self):
      self.__max_price = 25000

   def sell(self):
      return f"Selling Price: {self.__max_price}"

   def set_max_price(self, price):
      if price > self.__max_price:
         self.__max_price = price

# Object
desktopObj = Desktop()
print(desktopObj.sell()) 

# modifying the price directly
desktopObj.__max_price = 35000
print(desktopObj.sell()) 

# modifying the price using setter function
desktopObj.set_max_price(35000)
print(desktopObj.sell())        

执行上述代码后，将产生以下结果：

Selling Price: 25000
Selling Price: 25000
Selling Price: 35000

继承

面向对象编程（OOP）的软件建模方法能够扩展现有类的功能来构建新类，而不是从头开始构建。在 OOP 术语中，现有类称为 基类或父类，而新类称为 子类或派生类。

子类继承父类的数据定义和方法。这有助于重用已有的功能。子类可以添加一些新的定义或重新定义基类函数。

语法

派生类的声明方式与父类非常相似；但是，在类名之后需要提供要继承的基类列表：

class SubClassName (ParentClass1[, ParentClass2, ...]):
   'Optional class documentation string'
   class_suite

示例

以下示例演示了 Python 中继承的概念：

#!/usr/bin/python
# define parent class
class Parent:        
   parentAttr = 100
   def __init__(self):
      print ("Calling parent constructor")

   def parentMethod(self):
      print ("Calling parent method")

   def setAttr(self, attr):
      Parent.parentAttr = attr

   def getAttr(self):
      print ("Parent attribute :", Parent.parentAttr)

# define child class
class Child(Parent): 
   def __init__(self):
      print ("Calling child constructor")

   def childMethod(self):
      print ("Calling child method")

# instance of child
c = Child()  
# child calls its method        
c.childMethod() 
# calls parent's method     
c.parentMethod()  
# again call parent's method   
c.setAttr(200)  
# again call parent's method     
c.getAttr()          

执行上述代码后，将产生以下结果：

Calling child constructor
Calling child method
Calling parent method
Parent attribute : 200

同样，您可以从多个父类派生一个类，如下所示：

class A:        # define your class A
.....

class B:         # define your class B
.....

class C(A, B):   # subclass of A and B
.....

您可以使用 issubclass() 或 isinstance() 函数来检查两个类和实例之间的关系。

• issubclass(sub, sup) 布尔函数在给定的子类 sub 确实是超类 sup 的子类时返回 True。

• isinstance(obj, Class) 布尔函数在 obj 是类 Class 的实例或类 Class 的子类的实例时返回 True。

多态

多态性（Polymorphism）是一个希腊词，意思是具有多种形式。在 OOP 中，当每个子类都提供了自己在基类中抽象方法的实现时，就会发生多态性。

您可以随时覆盖父类的方法。覆盖父类方法的一个原因是您可能希望在子类中实现特殊或不同的功能。

示例

在这个例子中，我们覆盖了父类的方法。

# define parent class
class Parent:        
   def myMethod(self):
      print ("Calling parent method")

# define child class
class Child(Parent): 
   def myMethod(self):
      print ("Calling child method")

# instance of child
c = Child()
# child calls overridden method          
c.myMethod()         

执行上述代码后，将产生以下结果：

Calling child method

Python 中的基类重载方法

下表列出了一些您可以在自己的类中覆盖的一些通用功能：

Python 中的运算符重载

假设您创建了一个 Vector 类来表示二维向量，当您使用加号运算符来添加它们时会发生什么？很可能 Python 会报错。

但是，您可以在类中定义 __add__ 方法来执行向量加法，然后加号运算符将按预期工作：

示例

class Vector:
   def __init__(self, a, b):
      self.a = a
      self.b = b

   def __str__(self):
      return 'Vector (%d, %d)' % (self.a, self.b)
   
   def __add__(self,other):
      return Vector(self.a + other.a, self.b + other.b)

v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)

执行上述代码后，将产生以下结果：

Vector(7,8)