Python函数重载

Question

我知道 Python 不支持方法重载，但我遇到了一个问题，我似乎无法以一种很好的 Pythonic 方式解决它。

我正在制作一个游戏，其中一个角色需要射击各种子弹，但是如何编写不同的函数来创建这些子弹？例如，假设我有一个函数，可以创建一颗以给定速度从 A 点移动到 B 点的子弹。我会编写这样的函数：

def add_bullet(sprite, start, headto, speed):
    # Code ...

但我想编写其他函数来创建项目符号，例如：

def add_bullet(sprite, start, direction, speed):
def add_bullet(sprite, start, headto, spead, acceleration):
def add_bullet(sprite, script): # For bullets that are controlled by a script
def add_bullet(sprite, curve, speed): # for bullets with curved paths
# And so on ...

等等，有很多变体。有没有更好的方法来做到这一点而不使用这么多关键字参数导致它变得有点难看快。重命名每个函数也非常糟糕，因为您会得到 add_bullet1、add_bullet2 或 add_bullet_with_really_long_name。

要解决一些问题：

1. 不，我无法创建 Bullet 类层次结构，因为那太慢了。管理项目符号的实际代码是用 C 编写的，我的函数是 C API 的包装器。

2. 我了解关键字参数，但检查各种参数组合很烦人，但默认参数有助于分配，例如 acceleration=0

Answer 1

根据定义，在 python 中重载函数是不可能的（请继续阅读以了解详细信息），但是您可以使用简单的装饰器实现类似的功能

class overload:
    def __init__(self, f):
        self.cases = {}

    def args(self, *args):
        def store_function(f):
            self.cases[tuple(args)] = f
            return self
        return store_function

    def __call__(self, *args):
        function = self.cases[tuple(type(arg) for arg in args)]
        return function(*args)

您可以像这样使用它

@overload
def f():
    pass

@f.args(int, int)
def f(x, y):
    print('two integers')

@f.args(float)
def f(x):
    print('one float')


f(5.5)
f(1, 2)

修改它使其适应您的用例。

概念的澄清

• 函数调度：有多个同名函数。应该叫哪一个呢？两种策略
• 静态/编译时调度（又名“重载”）。根据参数的编译时类型决定调用哪个函数。在所有动态语言中，没有编译时类型，因此根据定义
• 动态/运行时调度是不可能重载的：根据运行时类型决定调用哪个函数的论点。所有 OOP 语言都是这样做的：多个类具有相同的方法，语言根据 self/this 参数的类型决定调用哪一个。但是，大多数语言仅针对 this 参数执行此操作。上面的装饰器将这个想法扩展到了多个参数。

为了澄清这一点，假设我们用假设的静态语言定义了函数，

void f(Integer x):
    print('integer called')

void f(Float x):
    print('float called')

void f(Number x):
    print('number called')


Number x = new Integer('5')
f(x)
x = new Number('3.14')
f(x)

通过静态分派（重载），您将看到“number called”两次，因为 x 已被声明为 Number< /code>，这就是重载所关心的。使用动态调度，您将看到“调用整数，调用浮点”，因为这些是调用函数时 x 的实际类型。

Answer 2

Python 3.8 添加了 functools.singledispatchmethod

将方法转换为单调度通用函数。

要定义泛型方法，请使用 @singledispatchmethod 对其进行修饰
装饰师。请注意，调度发生在第一个类型上
非 self 或非 cls 参数，相应地创建您的函数：

from functools import singledispatchmethod


class Negator:
    @singledispatchmethod
    def neg(self, arg):
        raise NotImplementedError("Cannot negate a")

    @neg.register
    def _(self, arg: int):
        return -arg

    @neg.register
    def _(self, arg: bool):
        return not arg


negator = Negator()
for v in [42, True, "Overloading"]:
    neg = negator.neg(v)
    print(f"{v=}, {neg=}")

输出

v=42, neg=-42
v=True, neg=False
NotImplementedError: Cannot negate a

@singledispatchmethod 支持与其他装饰器嵌套，例如
@类方法。请注意，为了允许dispatcher.register，
singledispatchmethod 必须是最外面的装饰器。这是
Negator 类，其 neg 方法是类绑定的：

from functools import singledispatchmethod


class Negator:
    @singledispatchmethod
    @staticmethod
    def neg(arg):
        raise NotImplementedError("Cannot negate a")

    @neg.register
    def _(arg: int) -> int:
        return -arg

    @neg.register
    def _(arg: bool) -> bool:
        return not arg


for v in [42, True, "Overloading"]:
    neg = Negator.neg(v)
    print(f"{v=}, {neg=}")

输出：

v=42, neg=-42
v=True, neg=False
NotImplementedError: Cannot negate a

相同的模式可以用于其他类似的装饰器：
静态方法、抽象方法等。

Answer 3

通过传递关键字参数。

def add_bullet(**kwargs):
    #check for the arguments listed above and do the proper things

Answer 4

您可以轻松地在Python中实现函数重载。下面是一个使用 floats 和 integers 的示例：

class OverloadedFunction:
    def __init__(self):
        self.router = {int : self.f_int   ,
                       float: self.f_float}
    
    def __call__(self, x):
        return self.router[type(x)](x)
    
    def f_int(self, x):
        print('Integer Function')
        return x**2
    
    def f_float(self, x):
        print('Float Function (Overloaded)')
        return x**3

# f is our overloaded function
f = OverloadedFunction()

print(f(3 ))
print(f(3.))

# Output:
# Integer Function
# 9
# Float Function (Overloaded)
# 27.0

代码背后的主要思想是一个类包含您想要实现的不同（重载）函数，以及一个字典作为路由器工作，根据输入type(x)将您的代码引导至正确的函数。

PS1。对于自定义类，例如 Bullet1，您可以按照类似的模式初始化内部字典，例如 self.D = {Bullet1: self.f_Bullet1, ...}。其余代码是相同的。

PS2。所提出的解决方案的时间/空间复杂度也很好，每个操作的平均成本为O(1)。

Answer 5

我认为你的基本要求是在 Python 中拥有类似 C/C++ 的语法，并且尽可能减少头痛。虽然我喜欢 Alexander Poluektov 的答案，但它不适用于课程。

以下应该适用于课程。它的工作原理是通过非关键字参数的数量来区分（但它不支持通过类型来区分）：

class TestOverloading(object):
    def overloaded_function(self, *args, **kwargs):
        # Call the function that has the same number of non-keyword arguments.
        getattr(self, "_overloaded_function_impl_" + str(len(args)))(*args, **kwargs)

    def _overloaded_function_impl_3(self, sprite, start, direction, **kwargs):
        print "This is overload 3"
        print "Sprite: %s" % str(sprite)
        print "Start: %s" % str(start)
        print "Direction: %s" % str(direction)

    def _overloaded_function_impl_2(self, sprite, script):
        print "This is overload 2"
        print "Sprite: %s" % str(sprite)
        print "Script: "
        print script

并且可以像这样简单地使用：

test = TestOverloading()

test.overloaded_function("I'm a Sprite", 0, "Right")
print
test.overloaded_function("I'm another Sprite", "while x == True: print 'hi'")

输出：

这是过载 3
雪碧：我是雪碧
开始: 0
方向：右

这是过载 2
雪碧：我是另一个雪碧
脚本：
while x == True: 打印 'hi'

Answer 6

您可以使用以下 Python 代码来实现此目的：

@overload
def test(message: str):
    return message

@overload
def test(number: int):
    return number + 1

Answer 7

在定义中使用多个关键字参数，或者创建一个 Bullet 层次结构，将其实例传递给函数。

Answer 8

如何在Python中重载？

我知道这是一个老问题，但这个主题仍然非常相关，而且我还没有读过一个清晰简洁的答案，所以我想我自己提供一个。

---

首先，安装包：

pip3 install overloading
pip3 install typing

然后，使用包中的 overload 装饰器来定义函数的多个实现：

from typing import Set, List
from overloading import overload

@overload
def process_data(data: List[str], join_string: str) -> str:
    return join_string.join(data)

@overload
def process_data(data: Set[str], join_string: str) -> str:
    return join_string.join(data)

@overload
def process_data(data: List[float], round_to: int) -> List[float]:
    return [round(x, round_to) for x in data]

# And so on ...

参数的数量和类型决定调用哪个版本的函数。

• 不幸的是，不支持基于参数名称的调度。

---

在这里您可以找到完整的文档。

Answer 9

我认为具有关联多态性的 Bullet 类层次结构是正确的选择。您可以使用元类有效地重载基类构造函数，以便调用基类导致创建适当的子类对象。下面是一些示例代码来说明我的意思的本质。

已更新

代码已修改为在 Python 2 和 3 下运行，以保持相关性。这样做的方式避免了使用 Python 的显式元类语法，该语法在两个版本之间有所不同。

为了实现该目标，在创建 Bullet 基类时显式调用元类（而不是使用__metaclass__= 类属性或通过 metaclass 关键字参数，具体取决于 Python 版本）。

class BulletMeta(type):
    def __new__(cls, classname, bases, classdict):
        """ Create Bullet class or a subclass of it. """
        classobj = type.__new__(cls, classname, bases, classdict)
        if classname != 'BulletMetaBase':
            if classname == 'Bullet':  # Base class definition?
                classobj.registry = {}  # Initialize subclass registry.
            else:
                try:
                    alias = classdict['alias']
                except KeyError:
                    raise TypeError("Bullet subclass %s has no 'alias'" %
                                    classname)
                if alias in Bullet.registry: # unique?
                    raise TypeError("Bullet subclass %s's alias attribute "
                                    "%r already in use" % (classname, alias))
                # Register subclass under the specified alias.
                classobj.registry[alias] = classobj

        return classobj

    def __call__(cls, alias, *args, **kwargs):
        """ Bullet subclasses instance factory.

            Subclasses should only be instantiated by calls to the base
            class with their subclass' alias as the first arg.
        """
        if cls != Bullet:
            raise TypeError("Bullet subclass %r objects should not to "
                            "be explicitly constructed." % cls.__name__)
        elif alias not in cls.registry: # Bullet subclass?
            raise NotImplementedError("Unknown Bullet subclass %r" %
                                      str(alias))
        # Create designated subclass object (call its __init__ method).
        subclass = cls.registry[alias]
        return type.__call__(subclass, *args, **kwargs)


class Bullet(BulletMeta('BulletMetaBase', (object,), {})):
    # Presumably you'd define some abstract methods that all here
    # that would be supported by all subclasses.
    # These definitions could just raise NotImplementedError() or
    # implement the functionality is some sub-optimal generic way.
    # For example:
    def fire(self, *args, **kwargs):
        raise NotImplementedError(self.__class__.__name__ + ".fire() method")

    # Abstract base class's __init__ should never be called.
    # If subclasses need to call super class's __init__() for some
    # reason then it would need to be implemented.
    def __init__(self, *args, **kwargs):
        raise NotImplementedError("Bullet is an abstract base class")


# Subclass definitions.
class Bullet1(Bullet):
    alias = 'B1'
    def __init__(self, sprite, start, direction, speed):
        print('creating %s object' % self.__class__.__name__)
    def fire(self, trajectory):
        print('Bullet1 object fired with %s trajectory' % trajectory)


class Bullet2(Bullet):
    alias = 'B2'
    def __init__(self, sprite, start, headto, spead, acceleration):
        print('creating %s object' % self.__class__.__name__)


class Bullet3(Bullet):
    alias = 'B3'
    def __init__(self, sprite, script): # script controlled bullets
        print('creating %s object' % self.__class__.__name__)


class Bullet4(Bullet):
    alias = 'B4'
    def __init__(self, sprite, curve, speed): # for bullets with curved paths
        print('creating %s object' % self.__class__.__name__)


class Sprite: pass
class Curve: pass

b1 = Bullet('B1', Sprite(), (10,20,30), 90, 600)
b2 = Bullet('B2', Sprite(), (-30,17,94), (1,-1,-1), 600, 10)
b3 = Bullet('B3', Sprite(), 'bullet42.script')
b4 = Bullet('B4', Sprite(), Curve(), 720)
b1.fire('uniform gravity')
b2.fire('uniform gravity')

输出：

creating Bullet1 object
creating Bullet2 object
creating Bullet3 object
creating Bullet4 object
Bullet1 object fired with uniform gravity trajectory
Traceback (most recent call last):
  File "python-function-overloading.py", line 93, in <module>
    b2.fire('uniform gravity') # NotImplementedError: Bullet2.fire() method
  File "python-function-overloading.py", line 49, in fire
    raise NotImplementedError(self.__class__.__name__ + ".fire() method")
NotImplementedError: Bullet2.fire() method

Answer 10

使用带有默认值的关键字参数。例如，

def add_bullet(sprite, start=default, direction=default, script=default, speed=default):

在直子弹与弯子弹的情况下，我会添加两个函数：add_bullet_straight 和 add_bullet_curved。

Answer 11

在 Python 中重载方法很棘手。然而，可以使用传递字典、列表或原始变量。

我已经为我的用例尝试了一些方法，这可以帮助理解人们重载这些方法。

让我们举个例子：

一个类重载方法，调用不同类的方法。

def add_bullet(sprite=None, start=None, headto=None, spead=None, acceleration=None):

传递来自远程类的参数：

add_bullet(sprite = 'test', start=Yes,headto={'lat':10.6666,'long':10.6666},accelaration=10.6}

或

add_bullet(sprite = 'test', start=Yes, headto={'lat':10.6666,'long':10.6666},speed=['10','20,'30']}

因此，通过方法重载实现了对列表、字典或基元变量的处理。

尝试一下您的代码。

Answer 12

Plum 以简单的 Python 方式支持它。从下面的自述文件中复制示例。

from plum import dispatch

@dispatch
def f(x: str):
    return "This is a string!"
    

@dispatch
def f(x: int):
    return "This is an integer!"

>>> f("1")
'This is a string!'

>>> f(1)
'This is an integer!'

Answer 13

我的解决方案

def _either(**kwargs):
    return len([True for _, v in kwargs.items() if v is not None]) == 1

def overload(func, _overloaded_args=None):
    """enable overloading toward all params
    Usage:
        @overload
        def overloaded_func(either1=None, either2=None, either3=None):
            pass
        @overload
        def overloaded_func(must1, must2, either1=None, either2=None):
            pass
    """
    def inner(*func_args, **func_kwargs):
        nonlocal _overloaded_args
        __overloaded_args = _overloaded_args
        if __overloaded_args is None:
            __overloaded_args = list(func_kwargs.keys())
        if __overloaded_args:
            __overloaded_kwargs = {k: v for k, v in func_kwargs.items()
                                  if k in __overloaded_args}
            assert _either(**__overloaded_kwargs), (
                'function overloading should contain a single overloaded param.'
                f' overloaded params: {__overloaded_args}. inputs: {func_kwargs}')
        return func(*func_args, **func_kwargs)
    return inner

def overload_args(*_overloaded_args):
    """enable overloading toward specified params
    Usage:
        @overload_args('either1', 'either2')
        def overloaded_func(either1=None, either2=None):
            pass
        @overload_args('either1', 'either2')
        def overloaded_func(either1=None, either2=None, optional1=None, optional2=123):
            pass
    """
    def inner(func):
        return overload(func, _overloaded_args=_overloaded_args)
    return inner

Answer 14

从 Python 3.10 开始，您可以使用 match-case 语句来执行此操作。
就像这样：

def add_bullet(arguments):
    match arguments:
        case (sprite, start, direction, speed):
            # your code here
        case (sprite, start, headto, spead, acceleration):
            # your code here
        case (sprite, script):
            # your code here
        case (sprite, curve, speed):
            # your code here

只需确保在元组或列表中输入参数即可。像这样：

new_bullet = add_bullet((mysprite, myscript))

Answer 15

您所要求的称为多重调度。请参阅 Julia 语言示例，其中演示了不同类型的调度。

然而，在了解这一点之前，我们首先要解决为什么重载在 Python 中并不是您真正想要的。

为什么不超载？

首先，需要了解重载的概念以及为什么它不适用于 Python。

当使用可以区分数据类型的语言时
编译时，可以在替代方案中进行选择
编译时。创建此类替代功能的行为
编译时选择通常称为重载
功能。 （维基百科）

Python 是一个 动态类型语言，所以重载的概念根本不存在适用于它。然而，一切并没有丢失，因为我们可以在运行时创建这样的替代函数：

在将数据类型识别推迟到的编程语言中
运行时在替代方案中进行选择
函数必须在运行时发生，基于动态确定的
函数参数的类型。其替代函数
以这种方式选择的实现被大多数人提及
一般为多方法。 （维基百科）

所以我们应该能够在 Python 中执行多种方法——或者，也称为：多重调度。

多重分派

多重方法也称为多重分派：

多重调度或多方法是某些
面向对象的编程语言，其中函数或方法
可以根据运行时（动态）类型动态调度
它的论点不止一个。 （维基百科）

Python 不支持开箱即用¹，但是，碰巧有一个名为 multipledispatch 的优秀 Python 包可以做到这一点。

解决方案

以下是我们如何使用 multipledispatch² 包来实现您的方法：

>>> from multipledispatch import dispatch
>>> from collections import namedtuple
>>> from types import *  # we can test for lambda type, e.g.:
>>> type(lambda a: 1) == LambdaType
True

>>> Sprite = namedtuple('Sprite', ['name'])
>>> Point = namedtuple('Point', ['x', 'y'])
>>> Curve = namedtuple('Curve', ['x', 'y', 'z'])
>>> Vector = namedtuple('Vector', ['x','y','z'])

>>> @dispatch(Sprite, Point, Vector, int)
... def add_bullet(sprite, start, direction, speed):
...     print("Called Version 1")
...
>>> @dispatch(Sprite, Point, Point, int, float)
... def add_bullet(sprite, start, headto, speed, acceleration):
...     print("Called version 2")
...
>>> @dispatch(Sprite, LambdaType)
... def add_bullet(sprite, script):
...     print("Called version 3")
...
>>> @dispatch(Sprite, Curve, int)
... def add_bullet(sprite, curve, speed):
...     print("Called version 4")
...

>>> sprite = Sprite('Turtle')
>>> start = Point(1,2)
>>> direction = Vector(1,1,1)
>>> speed = 100 #km/h
>>> acceleration = 5.0 #m/s**2
>>> script = lambda sprite: sprite.x * 2
>>> curve = Curve(3, 1, 4)
>>> headto = Point(100, 100) # somewhere far away

>>> add_bullet(sprite, start, direction, speed)
Called Version 1

>>> add_bullet(sprite, start, headto, speed, acceleration)
Called version 2

>>> add_bullet(sprite, script)
Called version 3

>>> add_bullet(sprite, curve, speed)
Called version 4

1. Python 3 目前支持 single dispatch
2. 注意不要在多线程环境中使用 multipledispatch 否则你会出现奇怪的行为。

Answer 16

正如您所介绍的，Python 确实支持“方法重载”。事实上，你刚才描述的内容在 Python 中以多种不同的方式实现是微不足道的，但我会选择：

class Character(object):
    # your character __init__ and other methods go here

    def add_bullet(self, sprite=default, start=default, 
                 direction=default, speed=default, accel=default, 
                  curve=default):
        # do stuff with your arguments

在上面的代码中， default 是这些参数的合理默认值，或者 <代码>无。然后，您可以仅使用您感兴趣的参数调用该方法，Python 将使用默认值。

您还可以这样做：

class Character(object):
    # your character __init__ and other methods go here

    def add_bullet(self, **kwargs):
        # here you can unpack kwargs as (key, values) and
        # do stuff with them, and use some global dictionary
        # to provide default values and ensure that ``key``
        # is a valid argument...

        # do stuff with your arguments

另一种选择是将所需的函数直接挂钩到类或实例：

def some_implementation(self, arg1, arg2, arg3):
  # implementation
my_class.add_bullet = some_implementation_of_add_bullet

另一种方法是使用抽象工厂模式：

class Character(object):
   def __init__(self, bfactory, *args, **kwargs):
       self.bfactory = bfactory
   def add_bullet(self):
       sprite = self.bfactory.sprite()
       speed = self.bfactory.speed()
       # do stuff with your sprite and speed

class pretty_and_fast_factory(object):
    def sprite(self):
       return pretty_sprite
    def speed(self):
       return 10000000000.0

my_character = Character(pretty_and_fast_factory(), a1, a2, kw1=v1, kw2=v2)
my_character.add_bullet() # uses pretty_and_fast_factory

# now, if you have another factory called "ugly_and_slow_factory" 
# you can change it at runtime in python by issuing
my_character.bfactory = ugly_and_slow_factory()

# In the last example you can see abstract factory and "method
# overloading" (as you call it) in action 

Answer 17

您可以使用“自己动手”的解决方案来实现函数重载。这篇文章是从 Guido van Rossum 的关于多方法的文章复制的（因为有Python 中的多方法和重载之间差别不大）：

registry = {}

class MultiMethod(object):
    def __init__(self, name):
        self.name = name
        self.typemap = {}
    def __call__(self, *args):
        types = tuple(arg.__class__ for arg in args) # a generator expression!
        function = self.typemap.get(types)
        if function is None:
            raise TypeError("no match")
        return function(*args)
    def register(self, types, function):
        if types in self.typemap:
            raise TypeError("duplicate registration")
        self.typemap[types] = function


def multimethod(*types):
    def register(function):
        name = function.__name__
        mm = registry.get(name)
        if mm is None:
            mm = registry[name] = MultiMethod(name)
        mm.register(types, function)
        return mm
    return register

不

from multimethods import multimethod
import unittest

# 'overload' makes more sense in this case
overload = multimethod

class Sprite(object):
    pass

class Point(object):
    pass

class Curve(object):
    pass

@overload(Sprite, Point, Direction, int)
def add_bullet(sprite, start, direction, speed):
    # ...

@overload(Sprite, Point, Point, int, int)
def add_bullet(sprite, start, headto, speed, acceleration):
    # ...

@overload(Sprite, str)
def add_bullet(sprite, script):
    # ...

@overload(Sprite, Curve, speed)
def add_bullet(sprite, curve, speed):
    # ...

目前最严格的限制是：

• 支持方法，仅支持非类成员的函数；
• 不处理继承；
• 不支持 kwargs；
• 注册新函数应该在导入时完成，这不是线程安全的

Answer 18

一个可能的选择是使用 multipledispatch 模块，如下所示：
http://matthewrocklin.com/blog/work/2014/02/25 /Multiple-Dispatch

使用

def add(self, other):
    if isinstance(other, Foo):
        ...
    elif isinstance(other, Bar):
        ...
    else:
        raise NotImplementedError()

您可以这样做：

from multipledispatch import dispatch
@dispatch(int, int)
def add(x, y):
    return x + y    

@dispatch(object, object)
def add(x, y):
    return "%s + %s" % (x, y)

结果用法：

>>> add(1, 2)
3

>>> add(1, 'hello')
'1 + hello'

Answer 19

在 Python 3.4 PEP-0443 中。添加了单调度通用函数。

以下是 PEP 的简短 API 描述。

要定义通用函数，请使用 @singledispatch 装饰器对其进行装饰。请注意，分派发生在第一个参数的类型上。相应地创建函数：

from functools import singledispatch
@singledispatch
def fun(arg, verbose=False):
    if verbose:
        print("Let me just say,", end=" ")
    print(arg)

要向函数添加重载实现，请使用通用函数的 register() 属性。这是一个装饰器，采用类型参数并装饰实现该类型操作的函数：

@fun.register(int)
def _(arg, verbose=False):
    if verbose:
        print("Strength in numbers, eh?", end=" ")
    print(arg)

@fun.register(list)
def _(arg, verbose=False):
    if verbose:
        print("Enumerate this:")
    for i, elem in enumerate(arg):
        print(i, elem)

Answer 20

添加了 @overload 装饰器带有类型提示（PEP 484）。

虽然这不会改变 Python 的行为，但它确实使理解正在发生的事情以及 mypy 检测错误变得更容易。

from typing import overload

@overload
def foo() -> int: ...
@overload
def foo(arg: int) -> int: ...
def foo(arg=None):
    if arg is None:
        return 0
    return arg + 1

请参阅：类型提示 和 PEP 484

Answer 21

这种类型的行为通常可以使用多态性来解决（在OOP语言中） 。每种类型的子弹都有责任了解它的行进方式。例如：

class Bullet(object):
    def __init__(self):
        self.curve = None
        self.speed = None
        self.acceleration = None
        self.sprite_image = None

class RegularBullet(Bullet):
    def __init__(self):
        super(RegularBullet, self).__init__()
        self.speed = 10

class Grenade(Bullet):
    def __init__(self):
        super(Grenade, self).__init__()
        self.speed = 4
        self.curve = 3.5

add_bullet(Grendade())

def add_bullet(bullet):
    c_function(bullet.speed, bullet.curve, bullet.acceleration, bullet.sprite, bullet.x, bullet.y)


void c_function(double speed, double curve, double accel, char[] sprite, ...) {
    if (speed != null && ...) regular_bullet(...)
    else if (...) curved_bullet(...)
    //..etc..
}

将尽可能多的参数传递给存在的c_function，然后根据初始c函数中的值确定要调用哪个c函数。因此，Python 应该只调用一个 c 函数。该 C 函数查看参数，然后可以适当地委托给其他 C 函数。

本质上，您只是将每个子类用作不同的数据容器，但是通过在基类上定义所有潜在的参数，子类可以自由地忽略它们不执行任何操作的参数。

当出现一种新类型的项目符号时，您只需在基础上再定义一个属性，更改一个 python 函数以使其传递额外的属性，以及一个适当检查参数和委托的 c_function 即可。我想听起来还不错。