Wie kann ich abgeleitete Klassen dynamisch aus einer Basisklasse erstellen?

Zum Beispiel habe ich eine Basisklasse wie folgt:

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

Aus dieser Klasse leite ich mehrere andere Klassen ab, z

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

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

Gibt es eine schöne, pythonische Möglichkeit, diese Klassen dynamisch durch einen Funktionsaufruf zu erstellen, der die neue Klasse in meinen aktuellen Bereich einfügt, wie z.

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

Da es Kommentare und Fragen geben wird, warum ich das brauche: Die abgeleiteten Klassen haben alle genau die gleiche interne Struktur mit dem Unterschied, dass der Konstruktor eine Reihe von zuvor undefinierten Argumenten verwendet. So nimmt zum Beispiel MyClassdie Schlüsselwörter, awährend der Konstruktor der Klasse und TestClassnimmt .bc

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

Sie sollten jedoch NIEMALS den Typ der Klasse als Eingabeargument verwenden

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

Ich habe das zum Laufen gebracht, würde aber den anderen Weg bevorzugen, dh dynamisch erstellte Klassenobjekte.

Mit diesem Code können Sie neue Klassen mit dynamischen Namen und Parameternamen erstellen. Die Parameterüberprüfung in __init__just erlaubt keine unbekannten Parameter. Wenn Sie andere Überprüfungen wie den Typ benötigen oder diese obligatorisch sind, fügen Sie einfach die Logik dort hinzu:

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

Und das funktioniert zum Beispiel so:

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

Ich sehe, dass Sie darum bitten, die dynamischen Namen in den Namensbereich einzufügen - das wird in Python nicht als gute Vorgehensweise angesehen - Sie haben entweder Variablennamen, die zur Codierungszeit bekannt sind, oder Daten - und Namen, die zur Laufzeit gelernt wurden, sind mehr " Daten "als" Variablen "-

Sie können Ihre Klassen also einfach einem Wörterbuch hinzufügen und von dort aus verwenden:

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

Und wenn Ihr Design unbedingt die Namen benötigt, um in den Geltungsbereich zu gelangen, machen Sie dasselbe, aber verwenden Sie das vom globals() Aufruf zurückgegebene Wörterbuch anstelle eines beliebigen Wörterbuchs:

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

(Es wäre in der Tat möglich, dass die Klassenfactory-Funktion den Namen dynamisch in den globalen Bereich des Aufrufers einfügt. Dies ist jedoch eine noch schlechtere Vorgehensweise und nicht für alle Python-Implementierungen kompatibel. Der Weg dazu besteht darin, den Namen des Aufrufers abzurufen Ausführungsrahmen über sys._getframe (1) und Festlegen des Klassennamens im globalen Wörterbuch des Rahmens in seinem f_globalsAttribut).

update, tl; dr: Diese Antwort war populär geworden, immer noch sehr spezifisch für den Fragetext. Die allgemeine Antwort zum "dynamischen Erstellen abgeleiteter Klassen aus einer Basisklasse" in Python ist ein einfacher Aufruf zum typeÜbergeben des neuen Klassennamens, ein Tupel mit den Basisklassen und dem __dict__Hauptteil für die neue Klasse - wie folgt :

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

Update
Jeder, der dies benötigt, sollte auch das Dill- Projekt überprüfen - es behauptet, in der Lage zu sein, Klassen zu beizen und zu entfernen, genau wie es Beizen bei normalen Objekten tut, und hat es in einigen meiner Tests gelebt.

type() ist die Funktion, die Klassen (und insbesondere Unterklassen) erstellt:

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

Überprüfen Sie den folgenden Code, um eine Klasse mit einem dynamischen Attributwert zu erstellen. NB. Dies sind Codefragmente in der Programmiersprache 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*