¿Cómo puedo crear dinámicamente clases derivadas a partir de una clase base?

Por ejemplo, tengo una clase base de la siguiente manera:

class BaseClass(object):
    def __init__(self, classtype):
        self._type = classtype

De esta clase obtengo varias otras clases, p. Ej.

class TestClass(BaseClass):
    def __init__(self):
        super(TestClass, self).__init__('Test')

class SpecialClass(BaseClass):
    def __init__(self):
        super(TestClass, self).__init__('Special')

¿Existe una forma agradable y pitónica de crear esas clases dinámicamente mediante una llamada de función que coloca la nueva clase en mi alcance actual, como:

foo(BaseClass, "My")
a = MyClass()
...

Como habrá comentarios y preguntas, ¿por qué necesito esto? Todas las clases derivadas tienen exactamente la misma estructura interna con la diferencia de que el constructor toma una serie de argumentos previamente no definidos. Entonces, por ejemplo, MyClasstoma las palabras clave amientras que el constructor de la clase TestClasstoma by c.

inst1 = MyClass(a=4)
inst2 = MyClass(a=5)
inst3 = TestClass(b=False, c = "test")

Pero NUNCA deben usar el tipo de la clase como argumento de entrada como

inst1 = BaseClass(classtype = "My", a=4)

Conseguí que esto funcionara, pero preferiría lo contrario, es decir, objetos de clase creados dinámicamente.

Este bit de código le permite crear nuevas clases con nombres dinámicos y nombres de parámetros. La verificación de parámetros en __init__simplemente no permite parámetros desconocidos, si necesita otras verificaciones, como el tipo, o si son obligatorias, simplemente agregue la lógica allí:

class BaseClass(object):
    def __init__(self, classtype):
        self._type = classtype

def ClassFactory(name, argnames, BaseClass=BaseClass):
    def __init__(self, **kwargs):
        for key, value in kwargs.items():
            # here, the argnames variable is the one passed to the
            # ClassFactory call
            if key not in argnames:
                raise TypeError("Argument %s not valid for %s" 
                    % (key, self.__class__.__name__))
            setattr(self, key, value)
        BaseClass.__init__(self, name[:-len("Class")])
    newclass = type(name, (BaseClass,),{"__init__": __init__})
    return newclass

Y esto funciona así, por ejemplo:

>>> SpecialClass = ClassFactory("SpecialClass", "a b c".split())
>>> s = SpecialClass(a=2)
>>> s.a
2
>>> s2 = SpecialClass(d=3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 8, in __init__
TypeError: Argument d not valid for SpecialClass

Veo que está pidiendo insertar los nombres dinámicos en el ámbito de denominación; ahora, eso no se considera una buena práctica en Python; tiene nombres de variables, conocidos en el momento de la codificación o datos, y los nombres aprendidos en tiempo de ejecución son más " datos "que" variables "-

Por lo tanto, puede agregar sus clases a un diccionario y usarlas desde allí:

name = "SpecialClass"
classes = {}
classes[name] = ClassFactory(name, params)
instance = classes[name](...)

Y si su diseño necesita absolutamente que los nombres entren en el alcance, simplemente haga lo mismo, pero use el diccionario devuelto por la globals() llamada en lugar de un diccionario arbitrario:

name = "SpecialClass"
globals()[name] = ClassFactory(name, params)
instance = SpecialClass(...)

(De hecho, sería posible que la función de fábrica de clases insertara el nombre dinámicamente en el alcance global de la persona que llama, pero esa es una práctica aún peor y no es compatible con todas las implementaciones de Python. La forma de hacerlo sería obtener el nombre de la persona que llama marco de ejecución, a través de sys._getframe (1) y estableciendo el nombre de la clase en el diccionario global del marco en su f_globalsatributo).

update, tl; dr: esta respuesta se ha vuelto popular, aún es muy específica para el cuerpo de la pregunta. La respuesta general sobre cómo "crear dinámicamente clases derivadas a partir de una clase base" en Python es una simple llamada a typepasar el nombre de la nueva clase, una tupla con la (s) clase (s) base (s) y el __dict__cuerpo de la nueva clase, como esta:

>>> new_class = type("NewClassName", (BaseClass,), {"new_method": lambda self: ...})

actualización
Cualquiera que necesite esto también debería verificar el proyecto eneldo : afirma ser capaz de encurtir y desacoplar clases tal como lo hace pickle con objetos ordinarios, y lo había cumplido en algunas de mis pruebas.

type() es la función que crea clases (y en particular subclases):

def set_x(self, value):
    self.x = value

SubClass = type('SubClass', (BaseClass,), {'set_x': set_x})
# (More methods can be put in SubClass, including __init__().)

obj = SubClass()
obj.set_x(42)
print obj.x  # Prints 42
print isinstance(obj, BaseClass)  # True

Para crear una clase con un valor de atributo dinámico, consulte el siguiente código. NÓTESE BIEN. Estos son fragmentos de código en el lenguaje de programación Python

def create_class(attribute_data, **more_data): # define a function with required attributes
    class ClassCreated(optional extensions): # define class with optional inheritance
          attribute1 = adattribute_data # set class attributes with function parameter
          attribute2 = more_data.get("attribute2")

    return ClassCreated # return the created class

# use class

myclass1 = create_class("hello") # *generates a class*