Python如何指定类方法的参数类型为当前类并实现方法重载

一、类型标注报错的解决方法 #

你遇到的类未定义报错是Python类型标注的前向引用问题，有三种常用解决方式：

1. 延迟注解解析（推荐，Python3.7+支持）
   在代码文件最开头添加导入：

from __future__ import annotations

添加后所有类名类型标注都会被延迟到类定义完成后解析，不会再报未定义错误。
2. 字符串包裹类型
把还没完成定义的类名用引号包裹即可，静态类型检查工具会自动识别：

def myfunc(self, s: 'Parent') -> int:

3. 用Self指代当前类类型（Python3.11+支持）
   如果要标注参数类型为当前类本身，可以导入typing.Self直接使用，无需手动写类名：

from typing import Self

class Parent:
    def myfunc(self, s: Self) -> int:
        return self.a + s.a

二、实现按参数类型分发的方法逻辑 #

Python原生不支持基于参数类型的方法重载，子类重写方法后默认会完全覆盖父类实现，要实现你需要的逻辑有两种方案：

方案1：用singledispatchmethod自动分发（无需手动类型检查） #

functools模块提供的singledispatchmethod装饰器可以根据第一个非self参数的类型，自动匹配对应的实现逻辑，完全不需要手动写isinstance判断：

from __future__ import annotations
from functools import singledispatchmethod

class Parent(object):
    __slots__ = ['a','b']

    def __init__(self, a:int, b:int):
        self.a = a
        self.b = b
    
    @singledispatchmethod
    def myfunc(self, s: Parent) -> int:
        # 默认实现，参数为Parent类型时走这个逻辑
        return self.a + s.a

class Child(Parent):
    __slots__ = ['c']

    def __init__(self, a:int, b:int, c:int):
        super().__init__(a,b)
        self.c = c

    # 注册参数为Child类型时的实现
    @Parent.myfunc.register
    def _(self, s: Child) -> int:
        return self.a + s.a + s.c

def main():
    dad = Parent(1,2)
    son = Child(4,8,16)

    print(dad.myfunc(son)) # 输出5
    print(son.myfunc(son)) # 输出24
    print(son.myfunc(dad)) # 参数是Parent，走默认实现，输出5

if __name__ == "__main__":
    main()

运行后会直接输出你预期的结果。

方案2：手动类型检查+调用父类方法 #

如果你不想用装饰器，也可以在子类方法中加类型判断，需要调用父类同名方法时直接用super().myfunc(s)即可：

from __future__ import annotations

class Parent(object):
    __slots__ = ['a','b']

    def __init__(self, a:int, b:int):
        self.a = a
        self.b = b
    
    def myfunc(self, s: Parent) -> int:
        return self.a + s.a

class Child(Parent):
    __slots__ = ['c']

    def __init__(self, a:int, b:int, c:int):
        super().__init__(a,b)
        self.c = c

    def myfunc(self,s: Parent) -> int:
        if isinstance(s, Child):
            return self.a + s.a + s.c
        # 不是Child类型，调用父类实现
        return super().myfunc(s)

def main():
    dad = Parent(1,2)
    son = Child(4,8,16)

    print(dad.myfunc(son))
    print(son.myfunc(son))
    print(son.myfunc(dad))

if __name__ == "__main__":
    main()

这个方案运行结果和上面完全一致，逻辑更直观。

内容的提问来源于stack exchange，提问作者Cukee8