Python-Funktion überladen

Können Sie "roll-your-own" - Lösung für das überladen von Funktionen. Dies ist kopiert von Guido van Rossum ist der Artikel über multimethods (da gibt es wenig Unterschied zwischen mm und überlastung in 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

Die Verwendung wäre

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

Meisten Einschränkungen im moment sind:

• Methoden werden nicht unterstützt, nur die Funktionen, sind Klasse nicht-Mitglieder;
• Vererbung ist nicht behandelt;
• kwargs werden nicht unterstützt;
• registrieren von neuen Funktionen getan werden sollte beim import etwas ist nicht thread-safe

InformationsquelleAutor der Antwort Alexander Poluektov

Eine mögliche option ist die Verwendung der multipledispatch Modul wie hier beschrieben:
http://matthewrocklin.com/blog/work/2014/02/25/Multiple-Dispatch

Statt dies zu tun:

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

Können Sie dies tun:

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)

Mit der daraus resultierenden Verwendung:

>>> add(1, 2)
3

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

InformationsquelleAutor der Antwort Dave C

Diese Art von Verhalten ist in der Regel gelöst (in OOP-Sprachen) - Polymorphismus. Jede Art von Kugel wäre dafür verantwortlich, zu wissen, wie Sie sich bewegt. Zum Beispiel:

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

Passieren so viele Argumente, um die c_function, die es gibt, dann tun die Aufgabe zu ermitteln, welche c-Funktion aufrufen, basierend auf den Werten in der ersten c-Funktion. So, python sollte immer nur den Aufruf der c-Funktion. Dass eine c-Funktion sucht sich die Argumente, und dann delegieren können andere c-Funktionen angemessen.

Sind Sie im wesentlichen nur mit jeder Unterklasse als eine andere Daten-container, aber durch die Festlegung aller möglichen Argumente auf der Basis der Klasse, die Unterklassen sind frei, Sie zu ignorieren diejenigen, die Sie tun, nichts mit.

Wenn eine neue Art von Kugel kommt, können Sie einfach definieren Sie eine weitere Eigenschaft, die auf der Basis ändern, das eine python-Funktion, so dass es durchläuft die zusätzliche Eigenschaft, und die eine c_function, untersucht die Argumente und die Delegierten entsprechend. Klingt nicht allzu schlecht, denke ich.

InformationsquelleAutor der Antwort Josh Smeaton

Durch vorbei Schlüsselwort args.

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

InformationsquelleAutor der Antwort Nick Radford

Ich denke, einBulletKlassen-Hierarchie mit den zugehörigen Polymorphismus ist der Weg zu gehen. Sie können effektiv die überlastung der Basisklasse Konstruktor mithilfe einer Metaklasse, so dass die Basisklasse aufrufen die Ergebnisse bei der Schaffung der entsprechenden Unterklasse-Objekt. Nachfolgend finden Sie einige Beispiel-code, verdeutlichen die Essenz dessen, was ich meine.

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 == 'Bullet':  # base class definition?
            classobj.registry = {}  # initialize class 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

    # instance factory for subclasses
    # subclasses should only be instantiated by calls to the base class
    # with their subclass's alias as the first arg
    def __call__(cls, alias, *args, **kwargs):
        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(object):
    __metaclass__ = BulletMeta
    # 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__(),
    # then then it might 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)             # creating Bullet1 object
b2 = Bullet('B2', Sprite(), (-30,17,94), (1,-1,-1), 600, 10) # creating Bullet2 object
b3 = Bullet('B3', Sprite(), 'bullet42.script')               # creating Bullet3 object
b4 = Bullet('B4', Sprite(), Curve(), 720)                    # creating Bullet4 object
b1.fire('uniform gravity') # Bullet1 object fired with uniform gravity trajectory
b2.fire('uniform gravity') # NotImplementedError: Bullet2.fire() method

InformationsquelleAutor der Antwort martineau

überladen von Methoden ist schwierig, in python. Es kann jedoch vorkommen, Verwendung der Weitergabe der dict, list oder primitiven Variablen.

Habe ich versucht etwas für meine Anwendungsfälle, könnte dies hier helfen, Menschen zu verstehen, um eine überlastung der Methoden.

Nehmen wir dein Beispiel:

einer Klasse überlast-Methode mit Aufruf der Methoden aus der anderen Klasse.

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

übergeben Sie die Argumente aus der remote-Klasse:

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

ODER

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

So, die Handhabung ist auf der Liste, Dictionary oder primitiven Variablen von Methode überladen.

probieren Sie es aus für Ihre codes.

InformationsquelleAutor der Antwort shashankS