Python関数のオーバーロード

Question

Pythonはメソッドのオーバーロードをサポートしていないことは知っていますが、Nice Pythonの方法では解決できないように見える問題に遭遇しました。

キャラクターがさまざまな弾丸を撃つ必要があるゲームを作っていますが、これらの弾丸を作成するためのさまざまな機能をどのように作成すればよいですか？たとえば、ポイント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は、提示された「メソッドのオーバーロード」をサポートします。実際、あなたが記述したことは、非常に多くの異なる方法で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はこれらの引数のもっともらしいデフォルト値、またはNoneです。その後、関心のある引数のみでメソッドを呼び出すことができ、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 2

あなたが求めているものは、multiple dispatchと呼ばれます。さまざまなタイプのディスパッチを示す Julia 言語の例を参照してください。

ただし、それを見る前に、まずoverloadingが実際にpythonで必要なものではない理由に取り組みます。

なぜ過負荷にならないのですか？

最初に、オーバーロードの概念と、Pythonに適用できない理由を理解する必要があります。

コンパイル時にデータ型を区別できる言語を使用している場合、コンパイル時に代替の選択肢を選択できます。コンパイル時の選択のためにこのような代替関数を作成する行為は、通常、関数のオーバーロードと呼ばれます。 （ ウィキペディア ）

Pythonは 動的 型付き言語であるため、オーバーロードの概念は単純に適用されません。ただし、実行時にそのような代替関数を作成できるため、すべてが失われるわけではありません。

実行時までデータ型の識別を遅らせるプログラミング言語では、動的に決定された関数引数の型に基づいて、代替関数の選択が実行時に行われなければなりません。この方法で代替実装が選択される関数は、最も一般的にmultimethodsと呼ばれます。 （ ウィキペディア ）

そのため、Pythonでmultimethodsを実行できるか、あるいはmultiple dispatch。

複数発送

マルチメソッドは、multiple dispatchとも呼ばれます：

複数のディスパッチまたはマルチメソッドは、複数の引数の実行時（動的）タイプに基づいて関数またはメソッドを動的にディスパッチできるオブジェクト指向プログラミング言語の機能です。 （ ウィキペディア ）

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
>>> 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は現在 シングルディスパッチ をサポートしています}

_{2.マルチスレッド環境で multipledispatch を使用しないように注意してください。使用しないと、奇妙な動作が発生します。}

Answer 3

関数のオーバーロードには「独自のロール」ソリューションを使用できます。これは Guido van Rossumの記事 からマルチメソッドについてコピーされています（Pythonではmmとオーバーロードの間にほとんど違いがないため）：

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 4

可能なオプションは、ここで詳しく説明されているように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 5

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 6

このタイプの動作は、通常、ポリモーフィズムを使用して（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はone c関数のみを呼び出す必要があります。その1つのc関数は引数を見てから、他のc関数に適切に委任できます。

基本的に各サブクラスを異なるデータコンテナとして使用しているだけですが、基本クラスですべての潜在的な引数を定義することにより、サブクラスは何もしないサブクラスを自由に無視できます。

新しいタイプの箇条書きが登場したら、ベースにもう1つのプロパティを定義し、追加のプロパティを渡すように1つのpython関数を変更し、引数を適切に調べて委任する1つのc_functionを変更できます。音が悪くないでしょう.

Answer 7

キーワード引数を渡す 。

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

Answer 8

あなたの基本的な要件は、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 9

関連するポリモーフィズムを持つBulletクラス階層が進むべき方法だと思います。基本クラスを呼び出すと、適切なサブクラスオブジェクトが作成されるように、メタクラスを使用して、基本クラスコンストラクターを効果的にオーバーロードできます。以下は、私が言っていることの本質を説明するためのサンプルコードです。

更新済み

関連性を保つために、コードはPython 2と3の両方で実行されるように修正されました。これは、2つのバージョン間で異なるPythonの明示的なメタクラス構文の使用を回避する方法で行われました。

その目的を達成するために、BulletMetaBase基本クラスを作成するときにメタクラスを明示的に呼び出すことにより、BulletMetaクラスのBulletインスタンスが作成されます（__metaclass__=クラス属性を使用するのではなく、Pythonバージョンに応じてmetaclassキーワード引数を使用します）。

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__.__+ ".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__.__+ ".fire() method")
NotImplementedError: Bullet2.fire() method

Answer 10

@overloadデコレータにタイプヒントが追加されました（PEP 484）。これはpythonの動作を変更しませんが、何が起こっているかを理解しやすくし、mypyがエラーを検出できるようにします。
参照： タイプヒント および PEP 484

Answer 11

定義で複数のキーワード引数を使用するか、関数にインスタンスが渡されるBullet階層を作成します。

Answer 12

メソッドをオーバーロードすることは、Pythonでは扱いにくいです。ただし、dict、list、またはプリミティブ変数を渡す方法があります。

私は私のユースケースのために何かを試しましたが、これはメソッドをオーバーロードする人々を理解するのに役立ちます。

あなたの例を見てみましょう：

異なるクラスからメソッドを呼び出すクラスオーバーロードメソッド。

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}

OR

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

そのため、リスト、ディクショナリ、またはメソッドのオーバーロードからのプリミティブ変数の処理が実現されています。

あなたのコードで試してみてください。

Answer 13

デフォルトでキーワード引数を使用します。例えば。

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

まっすぐな弾丸と曲線的な弾丸の場合、2つの関数を追加します：add_bullet_straightとadd_bullet_curved。

Answer 14

シンプルなデコレーター

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)

ユースケースに合わせて変更します。

概念の明確化

• function dispatch：同じ名前の関数が複数あります。どちらを呼び出す必要がありますか？ 2つの戦略
• static/compile-time dispatch（aka。 "overloading"）。引数のcompile-timeタイプに基づいて呼び出す関数を決定します。すべての動的言語には、コンパイル時の型はないため、定義によりオーバーロードは不可能です。
• dynamic/run-time dispatch：引数のruntimeタイプに基づいて呼び出す関数を決定します。これは、すべてのOOP言語が行うことです。複数のクラスには同じメソッドがあり、言語はself/this引数のタイプに基づいて呼び出すメソッドを決定します。ただし、ほとんどの言語はthis引数に対してのみそれを行います。上記のデコレーターは、アイデアを複数のパラメーターに拡張します。

クリアするには、静的言語を想定し、関数を定義します

void f(Integer x):
    print('number 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)

静的ディスパッチ（オーバーロード）を使用すると、xがNumberとして宣言されているため、「number called」が2回表示されます。動的ディスパッチでは、関数が呼び出された時点でxの実際の型であるため、 "integer called、float called"が表示されます。