Python面向对象编程示例：类、继承与多态的代码注释讲解

唐可

发布时间：2026-11-06| 9人浏览过

原创

通过生产级消息通知系统示例，逐行深度注释解析Python面向对象编程中的类与对象定义、self机制、继承与super()协同，以及多态与鸭子类型调度原理，帮助读者彻底掌握OOP核心与避坑要点。

Python 核心技术专栏

面向对象编程 (OOP) 代码深度注释与执行拆解阅读时长约 10 分钟

Python面向对象编程示例：类、继承与多态的代码注释讲解 — 图 1：Python 面向对象编程三大支柱（类与对象、继承、多态）知识全景示意

面向对象编程（OOP）的核心目标，是将现实世界的业务实体及其交互规律，抽象为软件工程中结构严密、易于维护和复用的代码模型。在 Python 中，类提供了构造实体的图纸规范，继承建立了代码复用与层次分工的通道，而多态则赋予了系统无须关心底层具体类型即可统一调度的高扩展性。本文通过一套贯穿始终的消息通知系统实际案例，逐行提供详尽的代码注释，讲透其语法机制、执行流转与生产实战中的避坑准则。

一、类与对象：结构定义、实例化与 self 的底层逻辑

在 Python 中，类（Class）是创建对象的模版与蓝图，而对象（Object）则是类在内存中生成的具体实体。要理解类，首先要理解两个至关重要的概念：用于初始化实例的 __init__ 构造方法，以及贯穿所有实例方法的 self 关键字。

初学者常困惑于“为什么每个实例方法的第一个参数都必须写 self？”。实际上，当通过 obj.method() 调用时，Python 解释器在底层会自动将其转换为 Class.method(obj)。因此，self 的本质就是当前被操作对象在内存中的显式引用。通过它，我们才能在实例自己的命名空间字典（__dict__）中存取状态，保证不同实例之间数据互不干扰。

base_notification.py (基类定义与完整逐行注释) Python

# -*- coding: utf-8 -*-
# 基础通知抽象类定义：封装公共状态与标准操作行为
import datetime

class BaseNotification:
    # 类属性（Class Attribute）：所有实例共享的元数据，不随单独实例的变动而改变
    channel_type = "generic_base"
    max_retry_times = 3

    def __init__(self, sender: str):
        # 构造函数：当外部执行 BaseNotification(sender) 实例化时自动触发
        # self 代表当前刚刚在堆内存中开辟出来的空白实例对象指针
        
        # 实例属性（Instance Attribute）：每个实例专有的属性，写入到当前实例的 __dict__ 字典中
        self.sender = sender                              # 发信方标识（如系统服务名称）
        self.created_at = datetime.datetime.now()         # 实例初始化创建的时间戳
        self.is_sent = False                              # 发送状态标识，初始为未发出
        self.retry_count = 0                              # 当前已重试次数记录

    def log_record(self, detail: str) -> str:
        # 实例公共方法：用于格式化打印通知运行日志
        # 只要是继承自该类的子类，都可以无缝直接复用此方法
        time_str = self.created_at.strftime("%Y-%m-%d %H:%M:%S")
        log_msg = f"[{time_str}] [发件人: {self.sender}] {detail}"
        return log_msg

    def send(self, message: str) -> bool:
        # 行为契约虚方法：基类本身不具备具体渠道的发信能力
        # 显式抛出 NotImplementedError 强制要求所有子类必须重写并实现本方法
        raise NotImplementedError("子类必须重写并实现 send() 方法以完成具体发信！")

原理解析关于 self 与 __new__ / __init__ 的执行先后顺序

许多开发者误以为 __init__ 是真正的“构造器”，实际上 Python 创建对象时首先调用 __new__ 在内存堆中分配出对象空间，然后将这块空间的引用作为第一个实参赋给 self，再调用 __init__ 为该对象挂载初始字段。

二、继承机制：代码复用与 super() 协同工作

继承（Inheritance）是面向对象的核心复用机制。通过继承，子类可以直接获得父类的属性和方法，同时可以在不修改父类的前提下增加专属属性，或覆盖（Override）父类的方法逻辑。

在 Python 的子类设计中，最关键的技术点在于 super()。当子类拥有自己的专有初始化参数时，必须在子类的 __init__ 中显式调用 super().__init__(...)。这一步的作用是将父类所需的公共状态（如发信方、创建时间）正常初始化完成，避免子类对象出现属性缺失异常。

derived_notifications.py (邮件与短信子类的继承实现与逐行注释) Python

# -*- coding: utf-8 -*-
# 子类化实现：通过继承复用 BaseNotification 并特化各自渠道逻辑

class EmailNotification(BaseNotification):
    # 括号内写入父类名 BaseNotification，表示 EmailNotification 继承自该基类
    channel_type = "email"  # 重写类属性，特化渠道名称

    def __init__(self, sender: str, receiver_email: str, subject: str):
        # 1. 核心关键：通过 super() 调用父类 BaseNotification 的 __init__ 方法
        # 这样无需硬编码父类名，同时确保基类的 self.sender, self.created_at 等属性正常绑定
        super().__init__(sender=sender)
        
        # 2. 挂载邮件通道特有的独有属性
        self.receiver_email = receiver_email          # 接收者邮箱地址
        self.subject = subject                        # 邮件主题
        self.smtp_server = "smtp.enterprise.internal" # 内网邮件网关地址

    def send(self, message: str) -> bool:
        # 方法重写（Method Override）：覆盖父类的虚方法，实现具体的邮件发信行为
        email_payload = f"主题:<{self.subject}> 内容:{message}"
        
        # 调用从基类继承而来的通用日志方法 log_record
        log_text = self.log_record(f"向 [{self.receiver_email}] 发送邮件成功 | {email_payload}")
        print(log_text)
        
        self.is_sent = True
        return True


class SMSNotification(BaseNotification):
    # 短信渠道通知子类，同样继承自 BaseNotification
    channel_type = "sms"

    def __init__(self, sender: str, phone_number: str):
        # 调用父类初始化方法
        super().__init__(sender=sender)
        
        # 挂载短信特有属性
        self.phone_number = phone_number
        self.signature = "【系统监控中心】"

    def send(self, message: str) -> bool:
        # 针对短信特有的长度限制进行前置校验
        if len(message) > 70:
            formatted_msg = message[:67] + "..."
        else:
            formatted_msg = message
            
        full_sms = f"{self.signature}{formatted_msg}"
        log_text = self.log_record(f"向手机号 [{self.phone_number}] 下发短信 | {full_sms}")
        print(log_text)
        
        self.is_sent = True
        return True

注意细节为什么推荐 super() 而非 BaseNotification.__init__(self)？

使用 super() 能动态遵循 Python 的 MRO（方法解析顺序，Method Resolution Order） 列表进行寻址。在复杂的单继承或多继承体系中，直接硬写父类名会导致菱形继承时的重复调用，而 super() 则能确保继承链中的每一个初始化方法严格且仅被执行一次。

三、多态与动态分发：统一接口下的异构行为呈现

多态（Polymorphism）指“同一操作作用于不同的对象，可以产生不同的解释和执行结果”。在静态类型语言（如 Java、C++）中，多态通常需要严格的基类声明与类型强转；而在 Python 这类动态类型语言中，多态通过更加灵活优雅的“鸭子类型（Duck Typing）”来实现。

“如果一只鸟走起来像鸭子、游泳像鸭子、叫起来也像鸭子，那么它就可以被当作鸭子”。在 Python 中，只要一个对象实现了与目标契约一致的 send(message) 方法，无论它是否显式继承自 BaseNotification，消费方都可以对其一视同仁地进行调用。这使得系统拥有极高的开闭原则（对扩展开放，对修改封闭）特性。

polymorphism_dispatch.py (多态分发调用与第三方鸭子类型演示) Python

# -*- coding: utf-8 -*-
# 鸭子类型类：一个未显式继承 BaseNotification 的全新机器人推送类
class WebhookNotifier:
    def __init__(self, webhook_url: str):
        self.url = webhook_url

    def send(self, message: str) -> bool:
        # 只要具备入参为 message 的 send 方法，即满足调用协议契约
        print(f"[Webhook 推送] 请求网关: {self.url} | Payload: {{"alert": "{message}"}}")
        return True


# 统一多态调度函数：上层业务只依赖统一的 send() 方法协议
def broadcast_alert(notifiers: list, alert_message: str):
    # 遍历集合中的每一个通知器对象，统一触发 send() 方法
    # 调用方无需编写任何诸如 if isinstance(n, EmailNotification): ... 的分支判断！
    print(f"=== 开始全渠道多态广播：共 {len(notifiers)} 个渠道 ===")
    for index, notifier in enumerate(notifiers, start=1):
        print(f"正在执行通道 [{index}]...")
        # 运行时动态寻址：Python 根据当前实例实际指向的类型，调用属于它自己的 send 方法
        notifier.send(alert_message)
    print("=== 全部通道广播完毕 ===\n")


# 实例化不同的通知渠道对象
email_sender = EmailNotification(
    sender="OpsAlertService",
    receiver_email="sre_team@company.internal",
    subject="P1级系统告警"
)

sms_sender = SMSNotification(
    sender="OpsAlertService",
    phone_number="13800138000"
)

webhook_sender = WebhookNotifier(
    webhook_url="https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=abc-123"
)

# 将不同类实例放入同一列表容器
notification_channel_pool = [email_sender, sms_sender, webhook_sender]

# 执行多态调用
broadcast_alert(
    notifiers=notification_channel_pool,
    alert_message="核心数据库连接池已超过 90% 阈值，请立即排查！"
)

示例输出： === 开始全渠道多态广播：共 3 个渠道 ===
正在执行通道 [1]...
[2026-11-01 04:46:24] [发件人: OpsAlertService] 向 [sre_team@company.internal] 发送邮件成功 | 主题:<P1级系统告警> 内容:核心数据库连接池已超过 90% 阈值，请立即排查！
正在执行通道 [2]...
[2026-11-01 04:46:24] [发件人: OpsAlertService] 向手机号 [13800138000] 下发短信 | 【系统监控中心】核心数据库连接池已超过 90% 阈值，请立即排查！
正在执行通道 [3]...
[Webhook 推送] 请求网关: https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=abc-123 | Payload: {"alert": "核心数据库连接池已超过 90% 阈值，请立即排查！"}
=== 全部通道广播完毕 ===

四、生产级避坑指南与防御性编码规范

在实际编写面向对象的 Python 代码时，许多偶发 Bug 都源于对语言特性机制的细节忽视。以下列出四项最高频的生产隐患及应对准则：

陷阱 1切勿在类体中定义可变对象作为默认属性： 如果在 class 层级直接声明如 tags = [] 或字典，该列表属于类属性，所有实例共享同一指针。某个实例向其 append 数据，其他所有实例都会被意外串改。
防御准则：所有独立状态必须在 __init__ 内部以 self.tags = tags or [] 的方式绑定为实例属性。
陷阱 2子类重写构造方法时遗漏 super() 调用： 子类重写了 __init__ 却忘记执行 super().__init__()，导致基类的公共状态未注入。后续在调用基类方法（如 log_record）时会直接报 AttributeError: 'EmailNotification' object has no attribute 'created_at'。
陷阱 3破坏多态接口的参数签名： 如果父类协议约定 send(message)，而某个子类随意改为 send(message, receiver, timeout) 且无默认值，多态分发循环直接在运行时抛出 TypeError: missing required positional argument。
防御准则：子类扩展参数时应设默认值，或统一通过上下文对象参数传递。
陷阱 4滥用深层继承导致层次僵化： 继承层次超过 3 层以上时，改动顶层基类容易产生牵一发动全身的连锁崩坏。若仅需要功能复用而非严格的“is-a”分类关系，应当积极采用组合（Composition）而非继承。

五、全要素核心知识速查与架构总结

将面向对象的三大核心要素放在一起横向对比，可以清晰掌握它们各自扮演的架构职责与实现路径：

总结而言，在 Python 中进行面向对象设计时，类与对象解决了“零散数据与分散操作的高内聚封装”问题；继承通过 super() 委派链解决了“通用逻辑与差异特化的复用”问题；而多态则依托灵活的动态绑定与鸭子类型哲学，解决了“扩展新功能时不破坏原有消费逻辑”的问题。掌握这三者的协同机理，即可写出层次明晰、健壮且易于扩展的高质量 Python 工程代码。