Добавление динамической функции на основе критериев Python в класс

Как я уже сказал в комментарии к вопросу: вам, вероятно, вообще не нужны метаклассы.

Но поскольку вы не даете дополнительной информации, вот как то, что вы просите, можно сделать с помощью метаклассов:

class MetaX(type):

    def __add__(cls, other):
        name = '{}+{}'.format(cls.__name__, other.__name__)
        return type(cls)(name, (cls, other), dict())


class X(object):    # metaclass=MetaX in py3k

    __metaclass__ = MetaX

    def __add__(self, other):
        cls = type(self) + type(other)
        return cls

Вот и все, вам просто нужно наследовать от X.

Пример:

class A(X):
    def func_a(self):
        print "I'm in func_a"

class B(X):
    def func_b(self):
        print "I'm in func_b"

class C(X):
    def func_c(self):
        print "I'm in func_c"

L = A + B
l = L()
l.func_a()  # -> I'm in func_a
l.func_b()  # -> I'm in func_b

P = A + C
p = P()
p.func_a()  # -> I'm in func_a
p.func_c()  # -> I'm in func_c

Изменить: то, что вам действительно нужно, зависит от того, как выглядит ваш реальный код.

То, что вы описали в своем вопросе, - это динамическое наследование, если это то, что вам действительно нужно, тогда IMO метакласс - правильный инструмент, и переопределение __getattr__ было бы просто взломом.

Если вы не хотите строить целый метакласс, вы можете просто использовать какую-то фабрику классов:

def get_enhanced_A(typ)   # you can't use type as a keyword here
    dct = {'B': B, 'C': C}
    return type('A+{}'.format(typ), (A,dct[typ]), dict())

Я бы не знал, какой из двух вариантов выглядит лучше.

Похоже, ваш вопрос проблема XY, а решение вашей исходной проблемы "X" - множественное наследование. , нравиться:

class A(B, C):
    pass

Итак, теперь вы можете делать как A().fun1(), так и A().fun3().

Ответ Романа, наверное, самый разумный подход. Но давай забудем об этом и подумаем о каких-нибудь безумных вещах, которые ты мог бы сделать вместо этого!

Вы можете просто использовать функцию, но это слишком просто:

def A(type):
    if type == 'B':
        return B()
    elif type == 'C':
        return C

Вы можете переопределить __getattr__, чтобы отсутствующие атрибуты просматривались в экземпляре выбранного класса:

class A(object):
    def __init__(self, type):
        if type == 'B':
            self.type = B()
        if type == 'C':
            self.type = C()

    def __getattr__(self, name):
        if hasattr(self.type, name):
            return getattr(self.type, name)
        return AttributeError

Или вы можете переопределить __new__ и вернуть какой-то сумасшедший новый класс или экземпляр интересующего вас класса:

class A(object):
    bases = {'B': B, 'C': C}

    def __new__(cls, type):
        class Cls(A.bases[type]):
            pass
        return Cls()

И, наверное, много других заблуждений!