Eu sei, os argumentos de função de verificação de tipo geralmente são desaprovados no Python, mas acho que descobri uma situação em que faz sentido fazê-lo.

No meu projeto eu tenho uma classe base abstrataCoord, com uma subclasseVector, que tem mais recursos como rotação, alteração de magnitude, etc. Listas e tuplas de números também retornarão True paraisinstance(x, Coord). Eu também tenho muitas funções e métodos que aceitam esses tipos de Coord como argumentos. Eu configurei decoradores para verificar os argumentos desses métodos. Aqui está uma versão 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 versão é muito simples, ainda tem alguns bugs. Está ali apenas para ilustrar o ponto. E seria usado como:

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

Nota: Estou apenas verificando os tipos de argumento em relação às classes base abstratas.

isso é uma boa ideia? Existe uma maneira melhor de fazer isso sem ter que repetir código semelhante em todos os métodos?

Editar:

E se eu fizesse a mesma coisa, mas em vez de verificar os tipos de antemão no decorador, eu pego as exceções no 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

Isso é melhor?