Lo sé, los argumentos de la función de comprobación de tipos generalmente son mal vistos en Python, pero creo que he encontrado una situación en la que tiene sentido hacerlo.

En mi proyecto tengo una clase base abstractaCoord, con una subclaseVector, que tiene más funciones como rotación, cambio de magnitud, etc. Las listas y tuplas de números también devolverán Verdadero paraisinstance(x, Coord). También tengo muchas funciones y métodos que aceptan estos tipos de Coord como argumentos. He creado decoradores para comprobar los argumentos de estos métodos. Aquí hay una versión simplificada:

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

Esta versión es muy simple, todavía tiene algunos errores. Solo está ahí para ilustrar el punto. Y se usaría como:

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

Nota: Solo estoy comparando los tipos de argumentos con Clases base abstractas.

¿Es esta una buena idea? ¿Hay una mejor manera de hacerlo sin tener que repetir un código similar en cada método?

Editar:

¿Qué pasaría si hiciera lo mismo, pero en lugar de verificar los tipos de antemano en el decorador, detecto las excepciones en el decorador?

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

¿Es eso mejor?