0 Fork 0

Files

T

xixu-me e1fb2929c0 chore: clean repository history

2026-06-05 21:13:11 +08:00

10 KiB

Raw Blame History

doc_type, full_text

doc_type	full_text
short	sources/02_Inheritance.md

02_Inheritance 总结

核心主题

本文介绍 Python 中的继承机制，以及如何用继承编写可扩展、可定制的程序。重点不仅在语法本身，还在于通过继承定义稳定接口，让应用代码与具体实现解耦，形成可插拔的设计。相关主题可连接到 python inheritance、object oriented programming、polymorphism、extensible design。

继承基础

继承用于基于已有类创建更专门的新类：

class Parent:
    ...

class Child(Parent):
    ...

其中：

Child 是派生类或子类。
Parent 是基类或父类。
父类写在类名后的括号中。

继承的核心用途是扩展已有代码，包括：

添加新方法。
重定义已有方法。
为实例添加新属性。

例如已有 Stock 类：

class Stock:
    def __init__(self, name, shares, price):
        self.name = name
        self.shares = shares
        self.price = price

    def cost(self):
        return self.shares * self.price

    def sell(self, nshares):
        self.shares -= nshares

可以通过继承创建 MyStock，添加新行为：

class MyStock(Stock):
    def panic(self):
        self.sell(self.shares)

也可以重定义已有方法：

class MyStock(Stock):
    def cost(self):
        return 1.25 * self.shares * self.price

重定义的方法会替代父类中的同名方法，而其他未重定义的方法仍然来自父类。

方法覆盖与 `super()`

当子类希望扩展父类方法，而不是完全替换它时，应使用 super() 调用父类版本：

class MyStock(Stock):
    def cost(self):
        actual_cost = super().cost()
        return 1.25 * actual_cost

super() 表示“调用继承链中的上一个实现”。这让子类可以复用父类逻辑，并在其基础上添加额外行为。

在 Python 2 中写法更繁琐：

actual_cost = super(MyStock, self).cost()

`init` 与继承

如果子类重定义了 __init__()，通常必须显式调用父类的 __init__()，否则父类负责初始化的属性不会被创建：

class MyStock(Stock):
    def __init__(self, name, shares, price, factor):
        super().__init__(name, shares, price)
        self.factor = factor

    def cost(self):
        return self.factor * super().cost()

这体现了继承中的一个常见模式：

父类初始化通用状态。
子类通过 super().__init__() 复用父类初始化。
子类再初始化自身新增的状态。

继承的用途

继承有两类常见用途。

1. 表达类型层次结构

例如：

class Shape:
    ...

class Circle(Shape):
    ...

class Rectangle(Shape):
    ...

这表达了“Circle 是一种 Shape”的关系，即典型的 is-a 关系。

可以使用 isinstance() 检查实例是否属于父类类型：

c = Circle(4.0)
isinstance(c, Shape)   # True

重要原则：理想情况下，凡是能处理父类实例的代码，也应该能处理子类实例。这与 polymorphism 和面向对象替换原则相关。

2. 编写可扩展代码

更实用的用途是框架式扩展。例如框架提供一个基类，用户继承它并重写部分方法：

class CustomHandler(TCPHandler):
    def handle_request(self):
        ...

父类包含通用逻辑，子类只负责定制特定行为。这是很多库和框架使用继承的主要原因。

`object` 基类

Python 中所有类最终都继承自 object。

有时会看到：

class Shape(object):
    ...

在现代 Python 中，即使不显式写 object，类也会隐式继承自 object。显式写法主要是 Python 2 时代遗留下来的习惯。

多重继承

Python 允许一个类同时继承多个父类：

class Mother:
    ...

class Father:
    ...

class Child(Mother, Father):
    ...

Child 会继承两个父类的功能。但多重继承涉及复杂的方法解析顺序等细节，文中提醒：除非清楚自己在做什么，否则不要轻易使用。

练习主题：用继承解决可扩展输出格式问题

练习部分围绕 report.py 中的 print_report() 函数展开。原始函数只能输出固定的纯文本表格：

def print_report(reportdata):
    headers = ('Name','Shares','Price','Change')
    print('%10s %10s %10s %10s' % headers)
    print(('-'*10 + ' ')*len(headers))
    for row in reportdata:
        print('%10s %10d %10.2f %10.2f' % row)

问题是：如果希望支持纯文本、HTML、CSV、XML 等多种输出格式，把所有逻辑都写进一个巨大函数会导致代码难以维护。继承提供了更好的可扩展方案。

抽象基类：`TableFormatter`

练习首先要求创建 tableformat.py，定义一个表格格式化器基类：

class TableFormatter:
    def headings(self, headers):
        '''
        Emit the table headings.
        '''
        raise NotImplementedError()

    def row(self, rowdata):
        '''
        Emit a single row of table data.
        '''
        raise NotImplementedError()

这个类本身不实现具体功能，而是规定接口：

headings(headers)：输出表头。
row(rowdata)：输出一行数据。

它相当于一个“设计规范”或抽象基类。具体格式化器通过继承它并实现这些方法。

随后 print_report() 被改写为接收一个 formatter 对象：

def print_report(reportdata, formatter):
    formatter.headings(['Name','Shares','Price','Change'])
    for name, shares, price, change in reportdata:
        rowdata = [ name, str(shares), f'{price:0.2f}', f'{change:0.2f}' ]
        formatter.row(rowdata)

这样，print_report() 不再关心输出格式，只依赖统一接口。这是 loose coupling 的体现。

具体格式化器实现

纯文本格式：`TextTableFormatter`

class TextTableFormatter(TableFormatter):
    '''
    Emit a table in plain-text format
    '''
    def headings(self, headers):
        for h in headers:
            print(f'{h:>10s}', end=' ')
        print()
        print(('-'*10 + ' ')*len(headers))

    def row(self, rowdata):
        for d in rowdata:
            print(f'{d:>10s}', end=' ')
        print()

它产生与原始程序相同的固定宽度表格输出。

CSV 格式：`CSVTableFormatter`

class CSVTableFormatter(TableFormatter):
    '''
    Output portfolio data in CSV format.
    '''
    def headings(self, headers):
        print(','.join(headers))

    def row(self, rowdata):
        print(','.join(rowdata))

它通过逗号连接字段，输出 CSV 格式。

HTML 格式：`HTMLTableFormatter`

练习要求实现一个 HTML 表格行格式化器，输出形式类似：

<tr><th>Name</th><th>Shares</th><th>Price</th><th>Change</th></tr>
<tr><td>AA</td><td>100</td><td>9.22</td><td>-22.98</td></tr>

这说明新增格式只需要新增一个继承 TableFormatter 的类，而无需修改 print_report() 的核心逻辑。

多态：同一接口，不同对象

练习 4.7 强调 polymorphism：如果程序期望一个 TableFormatter 对象，那么无论传入的是 TextTableFormatter、CSVTableFormatter 还是 HTMLTableFormatter，程序都可以正常工作。

关键在于所有子类都实现了同一组方法：

headings()
row()

因此 print_report() 可以写成面向接口的代码，而不是面向具体类的代码。

工厂函数：`create_formatter(name)`

为了避免在 portfolio_report() 中写大量 if/elif 判断，练习要求把格式选择逻辑移动到 tableformat.py 中：

def create_formatter(name):
    ...

它根据 'txt'、'csv'、'html' 等简短名称创建相应格式化器。

然后 portfolio_report() 变为：

def portfolio_report(portfoliofile, pricefile, fmt='txt'):
    portfolio = read_portfolio(portfoliofile)
    prices = read_prices(pricefile)
    report = make_report_data(portfolio, prices)

    formatter = tableformat.create_formatter(fmt)
    print_report(report, formatter)

这样，报表生成逻辑与格式对象创建逻辑分离，代码更清晰，也更容易扩展。

命令行集成

练习 4.8 要求让 report.py 支持从命令行指定输出格式：

python3 report.py Data/portfolio.csv Data/prices.csv csv

这使程序可以按用户输入输出不同格式，例如 CSV：

Name,Shares,Price,Change
AA,100,9.22,-22.98
IBM,50,106.28,15.18

“拥有自己的抽象”

讨论部分提出一个重要设计思想：拥有自己的抽象。

即使已有第三方表格格式化库，也不意味着应用代码应该直接依赖该库。更好的做法是：

应用代码依赖自己定义的 TableFormatter 接口。
具体实现可以使用自定义代码，也可以调用第三方库。
将来如果替换第三方库，只要保持 TableFormatter 接口不变，应用代码就无需修改。

这体现了：

松耦合。
可替换实现。
面向接口编程。
框架和库中常见的扩展模式。

相关概念可连接到 interface design、abstraction、design patterns。

关键收获

继承允许子类扩展父类：添加方法、重写方法、增加属性。
super() 用于调用父类实现，尤其适合扩展而非完全替换父类行为。
子类重写 __init__() 时，通常应调用 super().__init__() 完成父类初始化。
继承可以表达“is-a”类型关系，但更常见的实践价值是构建可扩展框架。
抽象基类可以定义接口，具体子类负责实现。
多态让同一段代码可以处理不同具体类型的对象。
工厂函数可以把对象创建逻辑从业务逻辑中分离出来。
“拥有自己的抽象”能让应用代码与具体实现、第三方库保持松耦合。

与后续内容的关系

本文是面向对象编程章节的一部分，承接类的基础知识，并为后续特殊方法、多态、接口设计和框架式编程打基础。它展示了继承不只是语法机制，更是一种组织可扩展程序结构的设计工具。

10 KiB Raw Blame History