首页 > 编程语言 >Python 继承、多态、封装、抽象

Python 继承、多态、封装、抽象

时间：2024-11-06 13:20:52浏览次数：3  
标签：__ 封装 name Python self 多态 继承 class def

面向对象编程（OOP）是 Python 中的一种重要编程范式，它通过类和对象来组织代码。OOP 的四个核心概念是继承（Inheritance）、多态（Polymorphism）、封装（Encapsulation）和数据抽象（Data Abstraction）。下面将详细介绍这四个概念。

继承（Inheritance）

继承是面向对象编程（OOP）的一个基本概念，它允许一个类（子类或派生类）继承另一个类（基类或父类）的属性和方法。继承促进了代码的重用，并有助于在类之间建立层次结构。在 Python 中，可以通过继承现有的基类来创建新的派生类。

继承的类型

1. 单继承（Single Inheritance）
  • 派生类从单个基类继承。

示例：

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return f"{self.name} says Woof!"

dog = Dog("Buddy")
print(dog.speak())  # 输出: Buddy says Woof!
2. 多继承（Multiple Inheritance）
  • 派生类从多个基类继承。

示例：

class Animal:
    def __init__(self, name):
        self.name = name

class Canine:
    def bark(self):
        return "Woof!"

class Dog(Animal, Canine):
    def speak(self):
        return f"{self.name} says {self.bark()}"

dog = Dog("Buddy")
print(dog.speak())  # 输出: Buddy says Woof!
3. 多级继承（Multilevel Inheritance）
  • 派生类从另一个派生类继承。

示例：

class Animal:
    def __init__(self, name):
        self.name = name

class Mammal(Animal):
    def __init__(self, name, has_fur):
        super().__init__(name)
        self.has_fur = has_fur

class Dog(Mammal):
    def speak(self):
        return f"{self.name} says Woof!"

dog = Dog("Buddy", True)
print(dog.speak())  # 输出: Buddy says Woof!
4. 层次继承（Hierarchical Inheritance）
  • 多个派生类从单个基类继承。

示例：

class Animal:
    def __init__(self, name):
        self.name = name

class Dog(Animal):
    def speak(self):
        return f"{self.name} says Woof!"

class Cat(Animal):
    def speak(self):
        return f"{self.name} says Meow!"

dog = Dog("Buddy")
cat = Cat("Whiskers")
print(dog.speak())  # 输出: Buddy says Woof!
print(cat.speak())  # 输出: Whiskers says Meow!
5. 混合继承（Hybrid Inheritance）
  • 两种或多种继承类型的组合。通常涉及层次继承、多级继承和多继承的混合。

示例：

class Animal:
    def __init__(self, name):
        self.name = name

class Canine(Animal):
    def bark(self):
        return "Woof!"

class Feline(Animal):
    def meow(self):
        return "Meow!"

class Dog(Canine):
    def speak(self):
        return f"{self.name} says {self.bark()}"

class Cat(Feline):
    def speak(self):
        return f"{self.name} says {self.meow()}"

dog = Dog("Buddy")
cat = Cat("Whiskers")
print(dog.speak())  # 输出: Buddy says Woof!
print(cat.speak())  # 输出: Whiskers says Meow!

详细解释

  1. 单继承：

    • 最简单的继承形式，派生类从单个基类继承。
    • 适用于简单的类层次结构。

  2. 多继承：

    • 派生类可以从多个基类继承。
    • 适用于需要从多个来源继承功能的场景。
    • 使用 super() 方法可以避免多重继承中的方法冲突。

  3. 多级继承：

    • 派生类从另一个派生类继承，形成多级层次结构。
    • 适用于需要逐步细化功能的场景。

  4. 层次继承：

    • 多个派生类从单个基类继承。
    • 适用于需要多个子类共享同一基类功能的场景。

  5. 混合继承：

    • 两种或多种继承类型的组合。
    • 适用于复杂的类层次结构，需要灵活地组合多种继承方式。

注意事项

  • 方法解析顺序（MRO）：

    • 在多继承中，Python 使用 C3 线性化算法来确定方法解析顺序（MRO）。
    • 可以使用 mro() 方法查看类的 MRO。
    • 例如：
      print(Dog.mro())

  • 使用 super()：

    • super() 函数用于调用父类的方法，特别是在多继承中避免方法冲突。
    • 例如：
      class Mammal(Animal):
    def __init__(self, name, has_fur):
        super().__init__(name)
        self.has_fur = has_fur

多态（Polymorphism）

多态是面向对象编程（OOP）的一个核心概念，它允许不同类的对象被视为单一超类的成员。多态通过单一接口表示多种底层形式（数据类型），使得不同类可以提供同名但根据对象类具有不同行为的方法。多态通过方法重载和方法重写实现，促进了代码的灵活性和集成，使得编写通用、可重用的代码变得更加容易。

多态的基本概念

  1. 方法重写（Method Overriding）：

    • 子类可以重写父类的方法，以提供不同的实现。
    • 通过方法重写，可以在子类中扩展或修改父类的行为。

  2. 方法重载（Method Overloading）：

    • 同一个类中可以定义多个同名但参数不同的方法。
    • Python 本身不直接支持方法重载，但可以通过默认参数和可变参数等技术实现类似的效果。

示例

以下是一个展示多态的 Python 示例：

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

def make_animal_speak(animal):
    print(animal.speak())

dog = Dog()
cat = Cat()

make_animal_speak(dog)  # 输出: Woof!
make_animal_speak(cat)  # 输出: Meow!

封装（Encapsulation）

封装是面向对象编程（OOP）的一个核心概念，它将方法（函数）和数据（属性）组织成一个类单元。封装还防止未经授权访问对象的某些部分，从而保护数据不被误用和无意干扰。通常，这是通过使用前导下划线或双下划线将某些属性或方法设为私有来实现的。封装通过公共方法提供受控访问，鼓励模块化并帮助维护对象数据的完整性。

封装的基本概念

  1. 私有属性和方法：

    • 使用单个前导下划线 _ 表示“受保护”（protected）属性或方法，通常不应在类外部直接访问。
    • 使用双前导下划线 __ 表示“私有”（private）属性或方法，Python 会对其进行名称改写（name mangling），使其更难以在类外部访问。

  2. 公共方法：

    • 提供公共方法来访问和修改私有属性，确保数据的完整性和安全性。

示例

以下是一个展示 Python 封装的示例：

class BankAccount:
    def __init__(self, owner, balance):
        self.owner = owner
        self.__balance = balance  # 私有属性

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            print(f"Deposited {amount}. New balance: {self.__balance}")
        else:
            print("Deposit amount must be positive.")

    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount
            print(f"Withdrew {amount}. New balance: {self.__balance}")
        else:
            print("Invalid withdrawal amount.")

    def get_balance(self):
        return self.__balance

# 创建 BankAccount 类的对象
account = BankAccount("Alice", 1000)

# 调用公共方法
account.deposit(500)  # 输出: Deposited 500. New balance: 1500
account.withdraw(200)  # 输出: Withdrew 200. New balance: 1300

# 尝试直接访问私有属性（不推荐）
# print(account.__balance)  # 这将引发 AttributeError

# 通过公共方法访问私有属性
print(account.get_balance())  # 输出: 1300

数据抽象（Data Abstraction）

数据抽象是面向对象编程（OOP）的一个重要原则，其目的是隐藏系统的复杂实现细节，只向用户展示必要和相关的信息。数据抽象通过提供简单和直观的接口，有助于提高效率和减少复杂性。它使程序员能够处理简化的系统表示，并管理复杂的操作。在 Python 中，可以使用抽象基类（Abstract Base Classes, ABC）和接口来实现数据抽象。

抽象基类（Abstract Base Classes, ABC）

抽象基类是定义了一组抽象方法的类，这些方法必须由派生类实现。抽象方法是没有具体实现的方法，只有方法签名。通过使用抽象基类，可以确保所有派生类都实现特定的方法，从而保证标准化和一致的交互。

示例

以下是一个使用抽象基类实现数据抽象的 Python 示例：

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

    @abstractmethod
    def perimeter(self):
        pass

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

    def perimeter(self):
        return 2 * (self.width + self.height)

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius ** 2

    def perimeter(self):
        return 2 * 3.14 * self.radius

# 创建 Rectangle 和 Circle 对象
rect = Rectangle(10, 20)
circ = Circle(15)

# 访问 area 和 perimeter 方法
print(f"Rectangle Area: {rect.area()}")       # 输出: Rectangle Area: 200
print(f"Rectangle Perimeter: {rect.perimeter()}")  # 输出: Rectangle Perimeter: 60
print(f"Circle Area: {circ.area()}")          # 输出: Circle Area: 706.5
print(f"Circle Perimeter: {circ.perimeter()}")     # 输出: Circle Perimeter: 94.2

详细解释

  1. 定义抽象基类 Shape：

    • Shape 类继承自 ABC 类，并定义了两个抽象方法 area 和 perimeter。
    • 抽象方法使用 @abstractmethod 装饰器声明，表示这些方法必须在派生类中实现。

  2. 定义具体类 Rectangle 和 Circle：

    • Rectangle 类继承自 Shape 类，并实现了 area 和 perimeter 方法。
    • Circle 类继承自 Shape 类，并实现了 area 和 perimeter 方法。

  3. 创建对象并调用方法：

    • 创建 Rectangle 和 Circle 对象。
    • 调用 area 和 perimeter 方法，计算并输出矩形和圆形的面积和周长。

数据抽象的好处

  1. 隐藏复杂性：

    • 通过抽象基类，可以隐藏具体的实现细节，只向用户提供必要的接口。
    • 例如，用户不必了解如何计算矩形和圆形的面积和周长，只需调用相应的方法即可。

  2. 标准化接口：

    • 抽象基类确保所有派生类都实现特定的方法，从而提供标准化的接口。
    • 例如，所有形状类都必须实现 area 和 perimeter 方法，这使得处理不同形状的代码更加一致和简洁。

  3. 提高可维护性：

    • 通过数据抽象，代码更加模块化，易于维护和扩展。
    • 例如，如果需要添加新的形状类（如 Triangle），只需实现 area 和 perimeter 方法，而无需修改现有代码。

  4. 简化交互：

    • 用户可以使用相同的接口与不同类型的对象进行交互，而不必了解每个对象的具体实现。
    • 例如，可以编写一个通用函数来处理任何 Shape 对象，而无需关心它是 Rectangle 还是 Circle。

总结

面向对象编程的核心概念：

  • 继承（Inheritance）：允许一个类（子类）继承另一个类（父类）的属性和方法。
  • 多态（Polymorphism）：允许不同类的对象被视为单一超类的成员，通过方法重写和重载实现。
  • 封装（Encapsulation）：将数据和操作数据的方法绑定在一起，通过私有属性和公共方法保护数据。
  • 数据抽象（Data Abstraction）：隐藏系统的复杂实现细节，只向用户展示必要和相关的信息，通过抽象基类和接口实现。

标签：__,封装,name,Python,self,多态,继承,class,def
From： https://blog.csdn.net/woshichenpi/article/details/143495347

相关文章

  • [记录]安装 Python 中SPAM库失败
    报错信息：×pythonsetup.pyegg_infodidnotrunsuccessfully.│exitcode:1╰─>[41linesofoutput]runningegg_infocreating/private/var/folders/l9/f9rjm65s07bdf55y5xyk9f2c0000gn/T/pip-pip-egg-info-o3ic4gdp/progressbar.egg-infowriting/private/var/fo......
  • 如何通过Python SDK更新Collection中已存在的Doc
    本文介绍如何通过PythonSDK更新Collection中已存在的Doc。说明若更新Doc时指定id不存在，则本次更新Doc操作无效如只更新部分属性fields，其他未更新属性fields默认被置为NonePythonSDK1.0.11版本后，更新Doc时vector变为非必填项前提条件已创建Cluster：创建Cluster。......
  • 基于大数据 Python 校园食堂订餐数据分析系统(源码+LW+部署讲解+数据库+ppt)
    ！！！！！！！！！选题不知道怎么选不清楚自己适合做哪块内容都可以免费来问我避免后期給自己答辩找麻烦增加难度（部分学校只有一次答辩机会没弄好就延迟毕业了）会持续一直更新下去有问必答一键收藏关注不迷路源码获取：https://pan.baidu.com/s/1aRpOv3f2sdtVYOogQjb8jg?pwd=jf1d提取码:......
  • 100种算法【Python版】第51篇——希尔排序
    本文目录1算法步骤2算法示例3python代码3.1代码说明3.2复杂度分析4算法优化4.1Shell原始增量序列4.2Hibbard增量序列4.3Knuth增量序列4.4Sedgewick增量序列4.5Tokuda增量序列4.6Pratt增量序列5不同的增量序列的效率对比希尔......
  • Python socket传输图像文件
    客户端发送图像文件importsocketdata=numpy.frombuffer(stringData,numpy.uint8)#将获取到的字符流数据转换成1维数组#decimg=cv2.imdecode(data,cv2.COLOR_BGR2GRAY)#将数组解码成图像#cv2.imwrite("./test.jpg",decimg)#imencode()将图片格式转换（编码）成流数据，......
  • Python（logging.getLogger().info()）
    目录1.getLogger()函数2.info()方法3.配置日志级别4.示例代码5.其他日志级别方法6.使用场景logging.getLogger().info()是Python的logging模块中用于记录信息级别（infolevel）日志的函数。logging是一个Python内置模块，提供了日志记录功能。它支持不同的日志级别，不......
  • Python进程管理：创建和协调多进程的深入指南
    在Python中，进程是操作系统进行资源分配和调度的一个独立单位。与线程相比，进程拥有独立的内存空间，这使得它们在执行多任务时更加稳定，但也带来了更高的资源消耗。本文将深入探讨如何在Python中创建和管理进程，包括详细的代码示例，帮助你掌握多进程编程的技巧。1.理解进程进程......
  • Python多线程编程：创建和管理线程的详细指南
    在现代编程中，多线程是一种常见的并发执行技术，它允许程序同时执行多个任务。Python作为一种高级编程语言，提供了多种方式来实现多线程编程。本文将详细介绍如何在Python中创建和管理线程，包括必要的代码示例，以帮助你更好地理解和应用多线程技术。1.理解线程线程是操作系统能......
  • Python Turtle：绚丽多彩的烟花动画
    以下是一个使用Python的turtle库实现的烟花动画程序示例：收起python复制importturtleimportrandomimporttime#创建画布screen=turtle.Screen()screen.bgcolor("black")screen.title("FireworksAnimation")#烟花颜色列表colors=["red","orange&q......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99