Изменение баз объекта на основе аргументов на __init__

Я считаю, что мне удалось реализовать метакласс, о котором вы просили. Я не уверен, что это лучший возможный дизайн, но он работает. Каждый условный экземпляр C на самом деле является экземпляром «специализации» C, которая происходит от специализации B, которая происходит от специализированного класса A (классы A не должны быть связаны каким-либо образом). Все экземпляры данной специализации C будут иметь один и тот же тип, но другие типы, чем экземпляры с другой специализацией. Наследование работает так же, со специализациями, определяющими отдельные параллельные деревья классов.

Вот мой код:

Во-первых, нам нужно определить специализации класса A. Это можно сделать как угодно, но для своего тестирования я использовал понимание списка для создания группы классов с разными именами и разными значениями в переменной класса num.

As = [type('A_{}'.format(i), (object,), {"num":i}) for i in range(10)]

Затем у нас есть «фиктивный» неспециализированный класс A, который на самом деле является просто местом для подключения метакласса. Метакласс A AMeta выполняет поиск специализированных классов A в списке, который я определил выше. Если вы используете другой метод для определения специализированных A классов, измените AMeta._get_specialization, чтобы их можно было найти. Возможно, здесь даже будут созданы новые специализации A по запросу, если вы захотите.

class AMeta(type):
    def _get_specialization(cls, selector):
        return As[selector]

class A(object, metaclass=AMeta): # I'm using Python 3 metaclass declarations
    pass # nothing defined in A is ever used, it is a pure dummy

Теперь мы подошли к классу B и его метаклассу BMeta. Именно здесь происходит фактическая специализация наших подклассов. Метод __call__ метакласса использует метод _get_specialization для построения специализированной версии класса на основе аргумента selector. _get_specialization кэширует свои результаты, поэтому для каждой специализации на данном уровне дерева наследования создается только один класс.

Вы можете немного изменить это, если хотите (используйте несколько аргументов для вычисления selector или что-то еще), и вы можете передать селектор конструктору класса, в зависимости от того, что это на самом деле. Текущая реализация метакласса допускает только одиночное наследование (один базовый класс), но, вероятно, его можно расширить для поддержки множественного наследования в маловероятном случае, когда вам это понадобится.

Обратите внимание, что хотя класс B здесь пуст, вы можете указать ему методы и переменные класса, которые будут появляться в каждой специализации (в виде неглубоких копий).

class BMeta(AMeta):
    def __new__(meta, name, bases, dct):
        cls = super(BMeta, meta).__new__(meta, name, bases, dct)
        cls._specializations = {}
        return cls

    def _get_specialization(cls, selector):
        if selector not in cls._specializations:
            name = "{}_{}".format(cls.__name__, selector)
            bases = (cls.__bases__[0]._get_specialization(selector),)
            dct = cls.__dict__.copy()
            specialization = type(name, bases, dct) # not a BMeta!
            cls._specializations[selector] = specialization
        return cls._specializations[selector]

    def __call__(cls, selector, *args, **kwargs):
        cls = cls._get_specialization(selector)
        return type.__call__(cls, *args, **kwargs) # selector could be passed on here

class B(A, metaclass=BMeta):
    pass

С помощью этой настройки ваши пользователи могут определить любое количество классов C, которые наследуются от B. За кулисами они действительно будут определять целое семейство классов специализации, которые наследуются от различных специализаций B и A.

class C(B):
    def print_num(self):
        return self.num

Важно отметить, что C никогда не используется как обычный класс. C на самом деле является фабрикой, которая создает экземпляры различных связанных классов, а не экземпляры самого себя.

>>> C(1)
<__main__.C_1 object at 0x00000000030231D0>
>>> C(2)
<__main__.C_2 object at 0x00000000037101D0>
>>> C(1).print_num()
1
>>> C(2).print_num()
2
>>> type(C(1)) == type(C(2))
False
>>> type(C(1)) == type(C(1))
True
>>> isinstance(C(1), type(B(1)))
True

Но вот, возможно, неочевидное поведение:

>>> isinstance(C(1), C)
False

Если вы хотите, чтобы неспециализированные типы B и C притворялись суперклассами своих специализаций, вы можете добавить к BMeta следующие функции:

def __subclasscheck__(cls, subclass):
    return issubclass(subclass, tuple(cls._specializations.values()))

def __instancecheck__(cls, instance):
    return isinstance(instance, tuple(cls._specializations.values()))

Это убедит встроенные функции isinstance и issubclass рассматривать экземпляры, возвращенные из B и C, как экземпляры своего "фабричного" класса.

Вот самое близкое, что я могу собрать на данный момент:

class A(object):
    pass

class Aimpl1(object):
    def foo(self):
        print "FOO"

class Aimpl2(object):
    def foo(self):
        print "BAR"

class B(object):
    @classmethod
    def makeIt(cls, whichA):
        if whichA == 1:
            impl = Aimpl1
        elif whichA == 2:
            impl = Aimpl2
        else:
            impl = A
        print "Instantiating", impl, "from", cls
        TmpC = type(b'TmpC', (cls,impl), dict(cls.__dict__))

        return TmpC(whichA)

    def __init__(self, whichA):
        pass

class C(B):
    def __init__(self, whichA):
        super(C, self).__init__(whichA)

Его можно использовать следующим образом:

>>> c = C.makeIt(1)
Instantiating <class '__main__.Aimpl1'> from <class '__main__.C'>
>>> c.__class__.__mro__
(<class '__main__.TmpC'>,
 <class '__main__.C'>,
 <class '__main__.B'>,
 <class '__main__.Aimpl1'>,
 <type 'object'>)
>>> c.foo()
FOO
>>> c = C.makeIt(2)
Instantiating <class '__main__.Aimpl2'> from <class '__main__.C'>
>>> c.__class__.__mro__
(<class '__main__.TmpC'>,
 <class '__main__.C'>,
 <class '__main__.B'>,
 <class '__main__.Aimpl2'>,
 <type 'object'>)
>>> c.foo()
BAR

Он отличается от вашей настройки несколькими способами:

1. Класс C должен быть создан с использованием метода класса makeIt, а не напрямую с помощью C(blah). Это сделано для того, чтобы избежать бесконечного цикла. Если __new__ используется в B для обработки делегирования, но волшебным образом созданный новый класс с переключенными базами должен наследовать от исходного C, тогда новый класс унаследует B.__new__, и попытка создать его внутри снова вызовет магию. Вероятно, это также можно было бы обойти, используя __new__ и добавив «секретный» атрибут к динамически созданному классу и проверив его, чтобы пропустить магию.

2. B не наследует от A, поэтому, когда C наследует от B, он не будет наследоваться и от A; вместо этого он наследует от правильно замененной базы реализации.

Обновление: возможной альтернативой является использование декоратора класса для выполнения текущей роли B:

(Это все еще требует немного работы, хотя).

class A1(object):
    def foo(self):
        print 'foo'
class A2(object):
    def foo(self):
        print 'bar'

from functools import wraps
def auto_impl_A(cls):
    @wraps(cls)
    def f(val, *args, **kwargs):
        base = {1: A1, 2: A2}.get(val, object)
        return type(cls.__name__, (cls, base,), dict(cls.__dict__))(*args, **kwargs)
    return f

@auto_impl_A
class MyC(object):
    pass

Таким образом, пользователи украшают свой класс вместо того, чтобы наследовать его, и пишут C как обычно, но его основой будет соответствующий A...

Исходное предложение: если я правильно понимаю, проще использовать фабричную функцию и с самого начала создать новую type с подходящими базами...

class A1(object): pass
class A2(object): pass
class ANOther(object): pass

def make_my_C_obj(someval, *args, **kwargs):
    base = {1: A1, 2: A2}.get(someval, ANOther)
    return type('C', (base,), {})(*args, **kwargs)

for i in xrange(3):
    print i, type(make_my_C_obj(i)).mro()

0 [<class '__main__.C'>, <class '__main__.ANOther'>, <type 'object'>]
1 [<class '__main__.C'>, <class '__main__.A1'>, <type 'object'>]
2 [<class '__main__.C'>, <class '__main__.A2'>, <type 'object'>]

Это эквивалентно:

class Aimpl1(object):
  def foo(self):
    print "FOO"

class Aimpl2(object):
  def foo(self):
    print "BAR"

def C_factory(base):
  class C(base):
    pass
  return C

for b in (Aimpl1, Aimpl2):
  c=C_factory(b)()
  c.foo()
  print type(c)

Вы можете сделать это с помощью обертки:

class Bwrapper(object):
    def __init__(self, impl):
        self._a = Aimpl2() if impl == 2 else Aimpl1()

    def foo(self):
        return self._a.foo()