Python 简明教程

Python - OOP Concepts

OOP 是一个缩写，表示 Object-oriented programming 范式。它被定义为一种编程模型，它使用了 objects 的概念，后者指的是具有状态和行为的现实世界实体。本章可帮助你成为在 Python 语言中使用面向对象编程支持的专家。

Python 是一种支持面向对象编程的编程语言。这使得可以简单地创建和使用类和对象。如果你之前没有面向对象编程的经验，那么你找对地方了。让我们通过讨论面向对象编程 (OOP) 的一个简短简介来帮助你入门。

Procedural Oriented Approach

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

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

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

与过程化方法相关的突出问题如下：

它的自顶向下方法使得程序难以维护。
它使用了许多全局数据项，这是不希望的。过多的全局数据项会增加内存开销。
它更重视过程，并且不考虑相同重要性的数据，并想当然地认为它在程序中自由移动。
跨函数的数据移动不受限制。在现实场景中，函数与数据有明确的关联，它会处理这些数据。

Python - OOP Concepts

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

Attributes

学生的姓名、班级、科目、成绩等。
雇员的姓名、职务、部门、工资等。
发票的发票号码、客户、产品代码和名称、价格和数量等。
汽车的登记号、所有者、公司、品牌、马力、速度等。

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

Behavior

处理与对象关联的属性。

计算学生的成绩百分比
计算应支付给雇员的奖金
将 GST 应用于发票价值
Measure speed of car

行为等同于函数。在现实生活中，属性和行为并非彼此独立，而是共存的。

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

面向对象编程中，类定义了它的对象拥有什么属性，以及它的行为。另一方面，对象是类的实例。

Principles of OOPs Concepts

面向对象编程范例具有以下原则特征：

Class
Object
Encapsulation
Inheritance
Polymorphism

Class & Object

类是对象的用户定义原型，它定义了一组表征类的任何对象的属性。属性是数据成员（类变量和实例变量）和方法，通过点表示法访问。

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

Example

以下示例说明如何用 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

Encapsulation

类的数据成员仅供类内定义的函数处理。另一方面，类函数可从类上下文外部访问。因此，对象数据对外部类环境隐藏。类函数（也称为方法）封装对象数据，防止对它的不当访问。

Example

在此示例中，我们使用封装概念来设定桌面的价格。

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

Inheritance

OOP 的软件建模方法，能让你扩展现有类的能力，以便建立新类，而不用从头开始创建。在 OOP 术语中，现有的类称为基类或父类，而新类称为子类。

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

Syntax

衍生类被声明的方式与他们的父类非常相似；但是，类名后面给出了要继承的基类的列表：

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

Example

以下示例展示了 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 中，当每个子类为基类中的抽象方法提供自己的实现时，就发生了多态。

你总是可以重写父类的函数。重写父函数的原因之一可能是你希望在子类中实现特殊或不同的功能。

Example

在此示例中，我们重写了父函数。

# 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

Base Overloading Methods in Python

下表列出了一些你可以在自己的类中重写的通用功能：

Sr.No.	方法、描述和示例调用
1	init ( self [,args…] ) 构造函数（带所有可选参数）示例调用：obj = className(args)
2	del( self ) 析构函数，删除一个对象示例调用：del obj
3	repr( self ) 可评估字符串表示示例调用：repr(obj)
4	str( self ) 可打印字符串表示示例调用：str(obj)
5	cmp ( self, x ) 对象比较示例调用：cmp(obj, x)

Overloading Operators in 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)