Python抽象类静态方法继承：多态场景下的等效实现问询

你的用法是合理且有实际价值的：

• 核心需求是「强制子类实现一个不依赖实例状态的方法」，同时需要「基于类本身的多态调用」，@staticmethod + @abc.abstractmethod的组合刚好能满足这两个要求：
  1. 通过ABC的抽象机制，确保任何子类必须实现该方法，否则实例化（甚至引用类）时会抛出错误；
  2. 静态方法不需要实例，直接通过类即可调用，完美适配你给出的类级多态场景。
• 谷歌风格指南不推荐静态方法是针对「无必要封装到类中的工具函数」，但你的场景是用类作为契约载体，属于合理的封装和约束，不在禁用范围内。

方案1：使用抽象类方法（@classmethod + @abc.abstractmethod） #

这是最接近你现有写法的替代方案，类方法虽然会接收cls参数，但如果方法本身不需要使用类状态，完全可以忽略。它同样能实现强制子类实现+类级多态调用的需求：

from abc import ABC, abstractmethod
from typing import List

class SomeAbsClass(ABC):
    @classmethod
    @abstractmethod
    def func_to_implement(cls):
        raise NotImplementedError()

class Child1(SomeAbsClass):
    @classmethod
    def func_to_implement(cls):
        print("Child1 implementation")

class Child2(SomeAbsClass):
    @classmethod
    def func_to_implement(cls):
        print("Child2 implementation")

# 多态调用逻辑完全不变
def polymorphism_on_class(classes: List[SomeAbsClass]):
    for inherit_class in classes:
        inherit_class.func_to_implement()

polymorphism_on_class([Child1, Child2])

方案2：使用Protocol（Python 3.8+） #

如果你不想依赖继承关系，Python的typing.Protocol可以实现结构化类型检查，只要类实现了指定方法，就会被视为符合协议，同样能做类型提示和多态调用：

from typing import Protocol, List

class SomeProtocol(Protocol):
    @staticmethod
    def func_to_implement():
        ...  # 仅做类型声明，无需实现

class Child1:
    @staticmethod
    def func_to_implement():
        print("Child1 implementation")

class Child2:
    @staticmethod
    def func_to_implement():
        print("Child2 implementation")

# 函数参数指定为Protocol类型
def polymorphism_on_class(classes: List[SomeProtocol]):
    for inherit_class in classes:
        inherit_class.func_to_implement()

polymorphism_on_class([Child1, Child2])

这种方案的优势是更灵活，子类不需要显式继承任何类，只要方法签名匹配即可。

方案3：顶层函数+注册机制（无静态检查约束） #

如果不需要强制约束，只是想统一调用逻辑，可以用注册器来绑定类和对应的函数，但这种方式没有静态检查，需要手动维护：

from typing import List, Dict

# 注册器字典，存储类到函数的映射
func_registry: Dict[type, callable] = {}

def register_func(cls: type):
    def decorator(func):
        func_registry[cls] = func
        return func
    return decorator

class Child1:
    pass

class Child2:
    pass

# 注册子类的实现
@register_func(Child1)
def child1_func():
    print("Child1 implementation")

@register_func(Child2)
def child2_func():
    print("Child2 implementation")

def polymorphism_on_class(classes: List[type]):
    for cls in classes:
        func_registry[cls]()

polymorphism_on_class([Child1, Child2])

这种方案适合不需要强约束的场景，但无法在开发阶段提前发现未实现的问题。

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