당신이 요구하는 것을 다중 디스패치 라고 합니다 . 다양한 유형의 디스패치를 ​​보여주는 Julia 언어 예제를 참조하십시오 .

그러나 그것을보기 전에 먼저 과부하 가 실제로 파이썬에서 원하는 것이 아닌 이유를 다루겠습니다 .

왜 과부하가되지 않습니까?

첫째, 과부하의 개념과 파이썬에 적용 할 수없는 이유를 이해해야합니다.

컴파일 타임에 데이터 유형을 식별 할 수있는 언어로 작업 할 때, 컴파일 타임에 대안 중에서 선택할 수 있습니다. 컴파일 타임 선택을위한 이러한 대체 함수를 작성하는 행위는 일반적으로 함수 오버로드라고합니다. ( 위키 백과 )

파이썬은 동적으로 입력되는 언어이므로 오버로딩의 개념은 단순히 적용되지 않습니다. 그러나 런타임에 이러한 대체 기능 을 만들 수 있기 때문에 모든 것이 손실되지는 않습니다 .

런타임까지 데이터 유형 식별을 지연시키는 프로그래밍 언어에서 동적으로 결정된 함수 인수 유형에 따라 런타임시 대체 기능 중에서 선택해야합니다. 이러한 방식으로 대체 구현이 선택된 함수를 가장 일반적으로 멀티 메소드 라고합니다 . ( 위키 백과 )

따라서 우리는 파이썬에서 멀티 메소드 를 수행 할 수 있어야합니다. 또는 다중 디스패치 라고도 합니다.

여러 파견

멀티 메소드는 다중 디스패치 라고도 합니다 .

다중 디스패치 또는 멀티 메소드는 일부 객체 지향 프로그래밍 언어의 기능으로, 함수 또는 메소드가 둘 이상의 인수의 런타임 (동적) 유형을 기반으로 동적으로 디스패치 될 수 있습니다. ( 위키 백과 )

파이썬은 상자의 밖으로 지원하지 않는 ^일을 그런 일이 같은 우수한 파이썬 패키지라는 존재,하지만 multipledispatch 정확히 않습니다.

해결책

다음은 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

<sub>1. 파이썬 3는 현재 지원하는 단일 파견


사용하지 2. 테이크 치료를 multipledispatch을 멀티 스레드 환경에서 또는 당신이 이상한 행동을 얻을 것이다.</sub>

답변

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

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 

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):
    # ...

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'

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

@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)

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..
}

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