Temel sınıftan dinamik olarak nasıl türetilmiş sınıflar oluşturabilirim

Örneğin aşağıdaki gibi bir temel sınıfım var:

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

Bu sınıftan birkaç başka sınıf türetiyorum, örneğin

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

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

Yeni sınıfı şu anki kapsamıma yerleştiren bir işlev çağrısı ile bu sınıfları dinamik olarak oluşturmanın güzel, pitonik bir yolu var mı, örneğin:

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

Buna neden ihtiyacım olduğuna dair yorumlar ve sorular olacağından: Türetilen sınıfların tümü, kurucunun önceden tanımlanmamış bir dizi argüman aldığı farkla aynı iç yapıya sahiptir. Yani, örneğin, MyClassanahtar kelimeler alır asınıfın yapıcı ederken TestClassalır bve c.

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

Ancak sınıfın türünü ASLA giriş argümanı olarak kullanmamalıdırlar.

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

Bunu çalıştırdım ama diğer yolu tercih ederim, yani dinamik olarak oluşturulmuş sınıf nesneleri.

Bu kod parçası, dinamik adlar ve parametre adları ile yeni sınıflar oluşturmanıza olanak tanır. Parametre doğrulaması, __init__bilinmeyen parametrelere izin vermez, tür gibi başka doğrulamalara ihtiyacınız varsa veya bunların zorunlu olduğunu, sadece mantığı buraya ekleyin:

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

Ve bu şu şekilde çalışır, örneğin:

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

Dinamik isimleri adlandırma kapsamına eklemeyi istediğinizi görüyorum - şimdi, bu Python'da iyi bir uygulama olarak görülmüyor - ya kodlama zamanında bilinen değişken isimleriniz ya da verileriniz var - ve çalışma zamanında öğrenilen isimler daha fazla " veriler "değişkenlerden" -

Yani, sınıflarınızı bir sözlüğe ekleyebilir ve oradan kullanabilirsiniz:

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

Ve tasarımınız kesinlikle adların kapsamına ihtiyaç duyuyorsa, sadece aynısını yapın, ancak globals() rastgele bir sözlük yerine çağrı tarafından döndürülen sözlüğü kullanın :

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

(Sınıf fabrikası işlevinin adı dinamik olarak arayanın genel kapsamına eklemesi gerçekten mümkün olabilir - ancak bu daha da kötü bir uygulamadır ve Python uygulamalarıyla uyumlu değildir. Bunu yapmanın yolu, arayanın yürütme çerçevesi, sys._getframe (1) aracılığıyla ve sınıf adını çerçevenin genel sözlüğünde f_globalsözniteliğinde ayarlama).

update, tl; dr: Bu cevap popüler hale geldi, hala soru gövdesine özgü. Python'da "bir temel sınıftan dinamik olarak türetilmiş sınıfların nasıl oluşturulacağına " ilişkin genel yanıt type, yeni sınıf adını, temel sınıf (lar) ı içeren bir demet ve yeni sınıf için gövdeyi iletmeye yönelik basit bir çağrıdır __dict__- buna benzer:

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

update Buna
ihtiyaç duyan herkes dereotu projesini de kontrol etmelidir - tıpkı sıradan nesnelere turşunun yaptığı gibi sınıfları turşu yapıp çözebildiğini iddia ediyor ve bazı testlerimde bunu yaşamıştı.

type() sınıfları (ve özellikle alt sınıfları) oluşturan işlevdir:

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

Dinamik öznitelik değerine sahip bir sınıf oluşturmak için aşağıdaki kodu kontrol edin. NB. Bu, python programlama dilindeki kod parçacıklarıdır

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*