Python 中的 OOPs（面向对象编程）概念

2025年4月22日 | 阅读 7 分钟

在 Python 中，面向对象编程 (OOP) 是一种编程范式，它提供了一种构建程序的方式，将属性和行为打包到单独的对象中。它允许开发人员使用类（充当对象的蓝图）来模拟现实世界的实体。

OOPs (Object-Oriented Programming) Concepts in Python

面向对象编程鼓励模块化、可扩展性和可重用性，从而使复杂应用程序更易于管理。作为一种面向对象的语言，Python 通过对象交互有效地组织代码。这种方法通过以逻辑和分层的方式构建代码来增强代码的可维护性。OOP 广泛用于软件开发、游戏设计、GUI 应用程序和数据建模，确保编程的灵活性和效率。

以下是 Python 中面向对象编程的主要概念

类和对象
封装
继承
抽象
多态

让我们通过示例来讨论这些概念。

Python 中的类和对象

类 (Class): 类是创建对象的蓝图。它定义了一组属性，这些属性表征了类的任何对象。像数据成员（类变量和实例变量）和方法这样的属性通过点符号进行访问。

对象 (Object): 对象是类的实例。它象征着类的特定实现，并拥有自己的数据。例如，一个名为 car_one 的属于 Car 类的对象是该类的实例。由其类定义的数据结构的唯一实例。对象包含数据成员（类变量和实例变量）和方法。

现在让我们通过一个简单的例子来理解类和对象。

示例

# creating a class
class Employer:
  def __init__(self, name, industry):
    self.name = name          # attribute
    self.industry = industry  # attribute

  def display_info(self):     # method
    print(f"Employer: {self.name} - {self.industry}")

# Creating an object
employer_one = Employer("Tpoint Tech", "Education")
employer_one.display_info()

立即执行

输出

Employer: Tpoint Tech - Education

说明

在上面的例子中，我们创建了一个名为 Employer 的类。在该类中，我们创建了一个初始化 name 和 industry 两个属性的构造函数。然后，我们定义了一个名为 display_info() 的方法来打印 Employer 的详细信息。

然后，我们创建了 Employer 类的一个对象，为 name 和 industry 传递了值，并调用了 display_info() 方法来打印传入的 Employer 的详细信息。

要了解更多关于类和对象的信息，请访问：Python 对象和类 - Tpoint Tech

Python中的封装

封装是面向对象编程 (OOP) 的原则之一，它指的是将属性和方法捆绑到单个类中。

它限制了对数据的直接访问，并通过方法允许受控修改。这也有助于实现数据隐藏。

在 Python 中，我们可以通过私有属性（在变量前加上 __）来实现封装。

现在让我们看一个简单的例子，演示封装如何在 Python 中工作。

示例

# creating a class
class Employer:
    def __init__(self, employee_count):
        self.__employee_count = employee_count  # Private attribute (name mangling)

    def get_employee_count(self): # method
        return self.__employee_count  # Accessing private attribute via method

# creating an object
employer_one = Employer(1500)

print("No. of Employees:", employer_one.get_employee_count())
# print("No. of Employees:", employer_one.__employee_count) # Trying to access private attribute directly (returns Error)

# Name Mangling
print("No. of Employees (Accessing via Name Mangling):", employer_one._Employer__employee_count) # Accessing via name mangling

立即执行

输出

No. of Employees: 1500
No. of Employees (Accessing via Name Mangling): 1500

说明

在上面的例子中，我们创建了一个具有私有属性 __employee_count 的 Employer 类。然后，我们定义了一个返回员工计数的方法。接着，我们创建了 Employer 类的一个对象，并调用了类方法来打印员工计数。我们也尝试直接访问私有属性，但会返回一个错误。因此，我们使用了名称修饰 (name mangling) 来访问该属性。

要了解更多关于封装的信息，请访问：Python 中的封装 - Tpoint Tech

Python 中的继承

继承是面向对象编程 (OOP) 的另一个原则，它允许一个类（子类）重用另一个类（父类）的属性和方法。它支持层次分类并促进代码的可重用性。

让我们看一个简单的例子，演示继承在 Python 中是如何工作的。

示例

# creating a class (parent class)
class Vertebrate:
    def __init__(self, name):
        self.name = name
        self.spine = True

    def move(self):
        print(f"{self.name} is moving.")

# creating another class (child class)
class Mammal(Vertebrate):
    def __init__(self, name, fur_color):
        super().__init__(name)
        self.fur_color = fur_color

    def nurse(self):
        print(f"{self.name} is nursing its young.")

# creating another class (child class)
class Bird(Vertebrate):
    def __init__(self, name, wingspan):
        super().__init__(name)
        self.wingspan = wingspan
    def fly(self):
        print(f"{self.name} is soaring through the air.")

# creating an object of Mammal class
dog = Mammal("Bear", "brown")
dog.move()
dog.nurse()
print("Spine Exist?:", dog.spine)

# creating an object of Bird class
eagle = Bird("Eagle", 2)
eagle.move()
eagle.fly()
print("Spine Exist?:", eagle.spine)

立即执行

输出

Bear is moving.
Bear is nursing its young.
Spine Exist?: True
Eagle is moving.
Eagle is soaring through the air.
Spine Exist?: True

说明

在上面的例子中，我们创建了一个名为 Vertebrate 的基类，它具有公共属性 name 和 spine（设置为 True）。我们还定义了一个 move() 方法。然后，我们创建了两个子类 Mammal 和 Bird，它们继承了 Vertebrate 类的属性和方法。然后，我们定义了子类的不同方法。

最后，我们创建了子类的对象，并尝试访问不同的属性和方法。结果是，这两个对象都可以轻松访问子类以及父类的属性和方法。

要了解更多关于继承的信息，请访问：Python 中的继承 - Tpoint Tech

抽象

抽象是面向对象编程 (OOP) 的另一个原则，它允许我们隐藏内部实现细节，只展示必要的功能。抽象的主要目标是让我们专注于“做什么”，而不是“如何做”。

让我们看一个简单的例子，演示抽象在 Python 中是如何工作的。

示例

# importing the ABC class and abstractmethod decorator from abc module
from abc import ABC, abstractmethod

# creating a class
class Three_Dimensional_Shapes(ABC):
  @abstractmethod
  def calc_volume(self):
    pass

# creating another class to implement abstraction
class Cube(Three_Dimensional_Shapes):
  def __init__(self, side_length):
    self.side_length = side_length

  def calc_volume(self):
    return self.side_length ** 3

# creating an object of Cube class
side_length = 6
cube = Cube(side_length)

# printing the results
print("Cube's Side:", side_length)
print("Cube's Volume:", cube.calc_volume())

立即执行

输出

Cube's Side: 6
Cube's Volume: 216

说明

在上面的例子中，我们从 abc 模块导入了 ABC 类和 abstractmethod 装饰器。然后，我们定义了一个继承了 ABC 类属性的类，并在其中定义了一个抽象方法。然后，我们定义了另一个继承了基类属性的类，并重写了该方法以返回期望的输出。

要了解更多关于抽象的信息，请访问：Python 中的抽象 - Tpoint Tech

Python 中的多态性

多态是面向对象编程 (OOP) 的另一个重要原则，它简单地意味着“多种形式”。多态允许方法具有相同的名称；但是，它们的行为因对象上下文的不同而异。我们可以通过方法重写或方法重载来实现多态。

让我们看下面的例子，演示多态在 Python 中是如何工作的。

示例

# creating a base class
class Vertebrate:
    def __init__(self, name):
        self.name = name

    def move(self):
        print(f"{self.name} moves in a generic way.")

# creating a child class
class Mammal(Vertebrate):
    def move(self):   # method overriding
        print(f"{self.name} walks.")

# creating a child class
class Bird(Vertebrate):
    def move(self):   # method overriding
        print(f"{self.name} flies.")

# creating object as a list
animals = [Vertebrate("Generic Vertebrate"), Mammal("Dog"), Bird("Eagle")]

for animal in animals:
    animal.move()

立即执行

输出

Generic Vertebrate moves in a generic way.
Dog walks.
Eagle flies.

说明

在上面的例子中，我们创建了一个名为 Vertebrate 的基类，它具有公共属性 name。我们还定义了一个 move() 方法。然后，我们创建了两个子类 Mammal 和 Bird，它们继承了 Vertebrate 类的属性和方法。在这里，我们为这两个类都重写了 move() 方法，以打印期望的输出。

要了解更多关于多态的信息，请访问：Python 中的多态 - Tpoint Tech

OOPs 相对于过程式编程的优势

面向对象编程 (OOP) 相对于面向过程编程具有许多优势。下面将讨论其中一些。

OOP 使开发和维护更加容易；而在过程式编程中，随着项目规模的增长，管理代码会变得困难。
OOP 实现了数据隐藏；而在过程式编程中，全局数据可以从任何地方访问。
OOP 提供了更有效地模拟现实世界事件的能力。我们可以使用 OOP 来解决现实世界的问题。

结论

在本教程中，我们了解到 Python 中的面向对象编程 (OOP) 是一种强大的范例，它有助于使用类和对象等现实世界概念来组织和构建代码。它通过封装、抽象、继承和多态等关键原则，促进了模块化、代码可重用性和更好的数据安全性。通过将程序建模为交互式对象，OOP 使代码更易于维护、扩展和升级（尤其是在大型复杂应用程序中）。

Python OOPs 概念 - 选择题

1. 在 Python 中，以下哪项用于创建对象？

class()
object()
ClassName()
new ClassName()

答案： c) ClassName()

2. 当子类继承父类的特性时，遵循的是哪种 OOP 原则？

继承
多态
抽象
封装

答案： a) 继承

3. Python 中的封装是什么？

隐藏类本身
限制对对象一部分的访问
创建许多对象
使用多个类

答案： b) 限制对对象一部分的访问

4. 在 Python 中，哪个关键字用于定义一个类？

class
define
object
功能

答案： a) class

5. 在不同类中使用相同函数名但具有不同行为的术语是什么？

继承
重载
封装
多态

答案： d) 多态

下一主题Python-classes-and-objects

我们提供所有技术（如 Java 教程、Android、Java 框架）的教程和面试问题

联系信息

G-13, 2nd Floor, Sec-3, Noida, UP, 201301, India

hr@tpointtech.com

+91-9599086977

关注我们

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Python教程

Python变量和数据类型

Python控制语句

Python数据结构

Python函数

Python模块

Python OOP

Python异常处理

Python文件处理

Python搜索和排序

Python高级主题

Python MySQL

Python MongoDB

Python SQLite

Python MCQ

Python Tkinter (GUI)

Python Web Blocker

Python内置函数

Python字符串函数

Python列表

Python字典

Plotly

相关教程

Python 中的 OOPs（面向对象编程）概念

Python 中的类和对象

示例

Python中的封装

示例

Python 中的继承

示例

抽象

示例

Python 中的多态性

示例

OOPs 相对于过程式编程的优势

结论

Python OOPs 概念 - 选择题

相关帖子

Python类和对象

Python中的访问修饰符

Python构造函数

Python继承

Python中的方法重载

Python中的封装

Python中的抽象

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器