Ich weiß, dass Argumente für Typprüfungsfunktionen in Python im Allgemeinen verpönt sind, aber ich denke, ich habe eine Situation gefunden, in der dies sinnvoll ist.

In meinem Projekt habe ich eine abstrakte BasisklasseCoordmit einer UnterklasseVector, die mehr Funktionen wie Rotation, Änderung der Größe usw. enthält. Listen und Tupel von Zahlen geben auch True für zurückisinstance(x, Coord). Ich habe auch viele Funktionen und Methoden, die diese Coord-Typen als Argumente akzeptieren. Ich habe Dekorateure eingerichtet, um die Argumente dieser Methoden zu überprüfen. Hier ist eine vereinfachte Version:

class accepts(object):
    def __init__(self, *types):
        self.types = types

    def __call__(self, func):
        def wrapper(*args):
            for i in len(args):
                if not isinstance(args[i], self.types[i]):
                    raise TypeError

            return func(*args)

        return wrapper

Diese Version ist sehr einfach, sie hat immer noch einige Fehler. Es ist nur da, um den Punkt zu veranschaulichen. Und es würde verwendet werden wie:

@accepts(numbers.Number, numbers.Number)
def add(x, y):
    return x + y

Hinweis: Ich überprüfe Argumenttypen nur anhand von abstrakten Basisklassen.

Ist das eine gute Idee? Gibt es einen besseren Weg, dies zu tun, ohne bei jeder Methode ähnlichen Code wiederholen zu müssen?

Bearbeiten:

Was wäre, wenn ich dasselbe tun würde, aber anstatt die Typen vorher im Dekorateur zu überprüfen, fange ich die Ausnahmen im Dekorateur ab:

class accepts(object):
    def __init__(self, *types):
        self.types = types

    def __call__(self, func):
        def wrapper(*args):

            try:
                return func(*args)
            except TypeError:
                raise TypeError, message
            except AttributeError:
                raise AttributeError, message

        return wrapper

Ist das noch besser