类（二）：继承、特殊方法与模块

geometry.py

class Position:
    def __init__(self, x=0, y=0):
        self.x, self.y = x, y

    def __add__(self, other):
        if not isinstance(other, Position):
            return NotImplemented
        x = self.x + other.x
        y = self.y + other.y
        return Position(x, y)

    def __eq__(self, other):
        if not isinstance(other, Position):
            return NotImplemented
        return (self.x == other.x
                and self.y == other.y)

    def __repr__(self):
        return f"Position({self.x}, {self.y})"

backpack.py

class Backpack:
    def __init__(self, items=()):
        self._items = list(items)

    def add(self, item):
        self._items.append(item)

    def __len__(self):
        return len(self._items)

    def __getitem__(self, index):
        return self._items[index]

    def __contains__(self, item):
        return item in self._items

    def __repr__(self):
        return f"Backpack({self._items!r})"

rover.py

from geometry import Position
from backpack import Backpack


class Rover:
    def __init__(self, name, x=0, y=0):
        self.name = name
        self.x, self.y = x, y
        self._coins = 100
        self.bag = Backpack()

    def move(self, dx, dy):
        self.x += dx
        self.y += dy

    def pick(self, item):
        self.bag.add(item)

    def spend(self, amount):
        if type(amount) is not int or amount <= 0 or amount > self._coins:
            return False
        self._coins -= amount
        return True

    def coins_left(self):
        return self._coins

    def position(self):
        return Position(self.x, self.y)

    def symbol(self):
        return "R"

    def describe(self):
        return f"{self.symbol()} {self.name} at ({self.x}, {self.y})"

    def __str__(self):
        return self.describe()

    def __repr__(self):
        return f"{type(self).__name__}({self.name!r}, {self.x}, {self.y})"


class ScoutRover(Rover):
    def __init__(self, name, x=0, y=0, scan_range=2):
        super().__init__(name, x, y)
        self.scan_range = scan_range

    def symbol(self):
        return "S"

    def describe(self):
        return super().describe() + f", scan range {self.scan_range}"


class CargoRover(Rover):
    def symbol(self):
        return "C"

    def describe(self):
        return super().describe() + f", items {len(self.bag)}"

main.py

from rover import Rover, ScoutRover, CargoRover
from geometry import Position


def main():
    team = [Rover("Ada"), ScoutRover("Lin", 3, 4), CargoRover("Sam", 5, 1)]
    team[1].move(1, 0)
    team[2].pick("apple")
    for rover in team:
        print(rover)
    print(team[1].position() + Position(0, 1))
    print(len(team[2].bag), "apple" in team[2].bag)


if __name__ == "__main__":
    main()

python main.py

R Ada at (0, 0)
S Lin at (4, 4), scan range 2
C Sam at (5, 1), items 1
Position(4, 5)
1 True

迁移到Shape接口

用同一套继承与多态机制，可以组织不同图形的area。示例约定尺寸有效，只演示方法组织；实验的输入校验仍按题面完成。普通Shape可以创建，调用其area时才抛NotImplementedError。

import math

class Shape:
    def area(self) -> float:
        raise NotImplementedError("area")

class Circle(Shape):
    def __init__(self, r: float) -> None:
        self.r = r
    def area(self) -> float:
        return math.pi * self.r ** 2

class Square(Shape):
    def __init__(self, side: float) -> None:
        self.side = side
    def area(self) -> float:
        return self.side ** 2

class Rectangle(Shape):
    def __init__(self, w: float, h: float) -> None:
        self.w, self.h = w, h
    def area(self) -> float:
        return self.w * self.h

shapes = [Circle(1), Square(2), Rectangle(2, 3)]
total = 0.0
for shape in shapes:
    total += shape.area()
print(f"{total:.4f}")

13.1416

增强赋值与别名

本例的__iadd__修改self并返回self，普通加法产生新对象。其他实现可以选择新结果；缺失或返回NotImplemented时，增强赋值还可能回退到普通加法。

class Value:
    def __init__(self, n: int) -> None:
        self.n = n
    def __add__(self, other: "Value") -> "Value":
        return Value(self.n + other.n)
    def __iadd__(self, other: "Value") -> "Value":
        self.n += other.n
        return self

a = Value(1)
b = a
a += Value(2)
print(a.n, b.n, a is b)
a = a + Value(3)
print(a.n, b.n, a is b)

3 3 True
6 3 False

Person与Manager

class Person:
    def __init__(self, name: str, job: str, pay: float) -> None:
        self.name, self.job, self.pay = name, job, pay
    def get_last_name(self) -> str:
        return self.name.split()[-1]
    def give_raise(self, fraction: float) -> None:
        self.pay *= 1 + fraction
    def __repr__(self) -> str:
        return f"Person({self.name!r}, {self.job!r}, {self.pay:.2f})"

class Manager(Person):
    def __init__(self, name: str, pay: float) -> None:
        super().__init__(name, "manager", pay)
    def give_raise(self, fraction: float, bonus: float = 0.1) -> None:
        super().give_raise(fraction + bonus)

m = Manager("Alex Chen", 100)
m.give_raise(0.05)
print(m.get_last_name(), f"{m.pay:.2f}")

Person保存name、job、pay，提供姓氏查询和薪资更新；Manager重写薪资更新方法。这里的fraction和bonus约定用于教学，业务有效域应另外定义。同一命名空间第二个同名def会重新绑定名称，不是按参数重载。

合作式多继承与C3

class Root:
    def visit(self):
        return ["Root"]
class Left(Root):
    def visit(self):
        return ["Left"] + super().visit()
class Right(Root):
    def visit(self):
        return ["Right"] + super().visit()
class Combined(Left, Right):
    def visit(self):
        return ["Combined"] + super().visit()

print([c.__name__ for c in Combined.__mro__])
print(Combined().visit())

Combined/Left/Right/Root形成线性化顺序，super沿它继续，因此Left后面可以是Right而非直接父Root。只安排查找顺序不会自动调用所有方法，合作式实现必须协调super。

class A: pass
class B(A): pass
class C: pass
class D(B, C): pass
print([c.__name__ for c in D.__mro__])

结果D/B/A/C/object表明不是BFS。下面相互冲突的基类先后约束使类创建失败：

class X: pass
class Y: pass
class A(X, Y): pass
class B(Y, X): pass
class C(A, B): pass

继承选择还涉及行为替换：一个可独立更新宽高的Rectangle接口，未必适合Square子类保持相等边长。组合与委托也是有效方式。

名称改写与子类签名

class Mapping:
    def __init__(self, values):
        self.items = []
        self.__update(values)
    def update(self, values):
        self.items.extend(values)
    __update = update

class Child(Mapping):
    def update(self, keys, values):
        self.items.extend(zip(keys, values))

m = Child([1, 2])
m.update(["a"], [3])
print(m.items)

基类__update实际为_Mapping__update，保留基类函数，子类不同签名的update不破坏初始化。名称改写仍可显式外部访问，不是权限控制。

内省及其适用范围

class Animal: pass
class Dog(Animal): pass
d = Dog()
d.name = "Rex"
print(isinstance(d, Animal), type(d) is Animal)
print(issubclass(Dog, Animal))
print(d.__dict__)
print([c.__name__ for c in Dog.__mro__])
print([n for n in dir(d) if not n.startswith("_")])

还可查看实例__class__、类__name__、__bases__与__mro__。不是全部对象都有__dict__，dir也不保证完整支持接口。L09普通字段的实例优先模型有数据描述符等例外；本讲只说明边界，不展开描述符实现。

def add(a, b):
    return a + b

print(add.__name__)
print(add.__code__.co_varnames)
print(add.__code__.co_names)
print(add.__code__.co_consts)

函数是对象，可绑定名字或作为参数。co_varnames为局部名，co_names为非局部引用名，co_consts为常量；它们是code object属性，不代表整个运行状态。

比较与特殊方法分派

右操作数是子类型且提供不同反射实现时可能优先；同类型不保证再次尝试反射。eq没有__req__形式，通常可尝试对方eq，两方哨兵后回退身份。定义eq的可变类通常变不可哈希，若设计hash要与相等规则一致。

隐式特殊操作通常通过类型及继承链查找，而不是普通实例字段：

class Box: pass
def length():
    return 3
b = Box()
b.__len__ = length
print(b.__len__())
print(len(b))

直接调用b.__len__打印3，但len(b)预期TypeError。这与普通属性调用有区别。

几何、复数与同构字符串

class Triangle:
    def __init__(self, a: float, b: float, c: float) -> None:
        if min(a, b, c) <= 0 or not (a+b>c and a+c>b and b+c>a):
            raise ValueError("invalid edges")
        self.edges = [a, b, c]
    def area(self) -> float:
        a, b, c = self.edges
        s = (a+b+c)/2
        return (s*(s-a)*(s-b)*(s-c))**0.5
    def __lt__(self, other: "Triangle") -> bool:
        if not isinstance(other, Triangle):
            return NotImplemented
        return self.area() < other.area()
    def __getitem__(self, index: int) -> float:
        return self.edges[index]
    def __setitem__(self, index: int, value: float) -> None:
        candidate = self.edges.copy()
        candidate[index] = value
        Triangle(*candidate)
        self.edges = candidate

a, b = Triangle(3, 4, 5), Triangle(3, 3, 3)
print(b < a, a[0])
a[0] = 4
print(a[0])

本例明确以面积定义Triangle的<，下标选三边，非法边赋值保留旧边。不能将任意Triangle相加或大小关系称为普遍几何定义。

class ComplexNumber:
    def __init__(self, real: float, imag: float) -> None:
        self.real, self.imag = real, imag
    def __add__(self, other: "ComplexNumber") -> "ComplexNumber":
        if not isinstance(other, ComplexNumber):
            return NotImplemented
        return ComplexNumber(self.real + other.real, self.imag + other.imag)
    def __repr__(self) -> str:
        return f"ComplexNumber({self.real}, {self.imag})"

print(ComplexNumber(1, 2) + ComplexNumber(3, -1))

Point2D记录两个坐标，nDPoint可存一份标量坐标列表，维度需要明确；L09的Vector、方向角及HappyNumber保留完整定义。本讲二维Vector运算协议与上一讲n维向量接口分开命名。

def isomorphic(s: str, t: str) -> bool:
    if len(s) != len(t):
        return False
    forward, reverse = {}, {}
    for a, b in zip(s, t):
        if a in forward and forward[a] != b:
            return False
        if b in reverse and reverse[b] != a:
            return False
        forward[a], reverse[b] = b, a
    return True

print(isomorphic("egg", "add"))
print(isomorphic("foo", "bar"))

正反两张表共同保证一一对应：既不能让同一字符映到不同字符，也不能让不同字符映到同一字符。

重载、循环导入与future

settings.py

print("load")
value = 1

main.py

import importlib
import settings
from settings import value
settings.value = 9
print(value, settings.value)
importlib.reload(settings)
print(value, settings.value)

实际 Python 3.13 输出：

load
1 9
load
1 1

使用importlib.reload，不使用已过时的imp。重载重新执行模块代码，先前from的引用不自动改绑；它不是生产并发热更新保证。

a.py

import b
value = 1

b.py

from a import value

main.py

import a

实际 Python 3.13 输出：

ImportError: cannot import name 'value' from 'a' (consider renaming '/privatea.py' if it has the same name as a library you intended to import)

两个模块循环访问尚未建立的字段可以报错。调整职责或延后访问比“换IDE”更有意义，不能把Notebook缓存行为当语义标准。

from __future__ import annotations

class Node:
    def copy(self) -> Node:
        return Node()

print(Node().copy().__class__.__name__)

future是编译指令，不是任意普通导入；允许合法的文档/注释等前置，不要求物理第一行。annotations从3.7可选，在3.13仍须显式启用，不提供类型校验。

金额转换的标准库规则

Lab10 的 Money 骨架已提供 to_cents()，本段供希望了解辅助函数的同学选读。金额采用明确十进制舍入：Decimal 从字符串建立十进制值，quantize(Decimal(“1”)) 量化到整数单位；ROUND_HALF_UP 在恰好半个单位时向远离零的方向舍入。这里单位已经乘成分，不把浮点乘法再截断。

from decimal import Decimal, ROUND_HALF_UP
for yuan in [1.005, -1.005]:
    value = Decimal(str(yuan)) * 100
    cents = value.quantize(Decimal("1"), rounding=ROUND_HALF_UP)
    print(int(cents))

实际101、−101分。规则针对传入值的str，不恢复此前浮点运算丢失的信息。实验通过已提供的 to_cents() 完成转换，学生重点实现 Money 的表示、运算和比较。

包、路径和发行工具

路径查找可能涉及PYTHONPATH、site/.pth、site-packages及zip路径；sys.path项不全都是普通目录。__all__影响星号导出，普通包、namespace包、相对导入和-m是不同机制。

NumPy提供数组、广播及数值操作；Matplotlib绘图；SciPy提供科学算法；pandas处理表格；pytest用于测试。Scrapy、Beautiful Soup用于网页处理，Pygame用于游戏程序。官网用途不要求本讲安装这些依赖。

CPython、PyPy、Jython为不同实现；Cython和Nuitka等编译工具不全部归为解释器。CPython源码阅读使用当前仓库，不照抄旧版本文件行号。

显式编译与可信执行

source = "answer = 2 + 3"
code = compile(source, "trusted.py", "exec")
namespace = {}
exec(code, namespace)
print(namespace["answer"])

compile得到code object，再在指定命名空间exec，仅执行课程自己写的可信源码。

python -m py_compile module_a.py module_b.py
python -m compileall selected_project_directory

只选择自己的教学目录，不扫描整个机器；编译不保证缓存可写或跨版本适用。dis/缓存/源码阅读是观察工具，不是新的安全边界。

大整数：第12周的主题预告

本周按统一日历启动素数计数五法，大整数将在第12周启动。大整数可以采用如下表示与接口：从十进制字符串构造BigInt，单独符号与分组数字，str/repr、eq/lt、add/sub/mul；不能把整个输入转int来代替实现，但可以用int作为测试参考。

须考虑零、前导零、负数、不等长、负差、进位借位和竖式乘法。报告不超过一页，说明表示选择、符号处理及具体边界/随机对拍证据。后续任务的具体接口和评分以届时题面为准。