Можно ли наследовать от класса, заданного в качестве параметра?

Question

У меня есть несколько классов, которые я воспринимаю как контейнеры для моих данных (представление рисунков). Все они имеют одинаковые @staticmethod с, например get_edges(), get_vertices(). Я хочу импортировать указанный класс фигуры по заданному параметру. Что я делаю сейчас:

class Figure:
    def __init__(self, figure_type):
        exec('import figures.' + figure_type.lower())
        self.element = eval('figures.' + figure_type.lower() + '.' + figure_type)()

    def create(self, vertices):
        glBegin(GL_LINES)
        for edge in self.element.get_edges():
            for vertex in edge:
                glColor3fv((0.5,0,0))
                glVertex3fv(vertices[vertex])
        glEnd()

class Cube:

    @staticmethod
    def get_edges():
        return ((0, 1),(0, 3),(0, 4),(2, 1),(2, 3),(2, 7),(6, 3),(6, 4),(6, 7),(5, 1),(5, 4),(5, 7))

Интересно, есть ли способ получить что-то вроде:

class Figure(figure_type):
    def __init__(self, figure_type):

Чтобы можно было использовать, например, self.get_edges() вместо self.element.get_edges(). Как я могу получить это? Это вообще возможно?

Answer 1

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

---

figure.py

data = ((0, 1),(0, 3),(0, 4),(2, 1),(2, 3),(2, 7),(6, 3))

class FT:
    @staticmethod
    def ge():
        return data

class FT1:
    @staticmethod
    def ge():
        return [(x*x,y*y) for x,y in data]

def compose(ftype):
    '''Returns a class composed of F and ftype.'''
    return type(f'F_{ftype.__name__}',(F,ftype),{})

---

some_module.py:

import importlib

class F:
    def __init__(self):
        self.x = 'foo'
    def a(self):
        s = '|'.join(f'{thing}' for thing in self.ge())
        return s
    def b(self):
        return 'baz'

def compose(ftype):
    cls = getattr(importlib.import_module('figures'),ftype)
    return type(f'F_{ftype}',(F,cls),{})


z = compose('FT')()
y = compose('FT1')()

---

Оба объекта имеют одинаковые b методы.

>>> z.b(), y.b()
('baz', 'baz')

Оба имеют одинаковые a методы, использующие данные из определенных ge методов

>>> print(z.a())
(0, 1)|(0, 3)|(0, 4)|(2, 1)|(2, 3)|(2, 7)|(6, 3)
>>> y.a()
'(0, 1)|(0, 9)|(0, 16)|(4, 1)|(4, 9)|(4, 49)|(36, 9)'

Каждый объектимеет определенные ge методы

>>> z.ge()
((0, 1), (0, 3), (0, 4), (2, 1), (2, 3), (2, 7), (6, 3))
>>> y.ge()
[(0, 1), (0, 9), (0, 16), (4, 1), (4, 9), (4, 49), (36, 9)]
>>> 

z и y являются экземплярами различных классов.

>>> z.__class__, y.__class__
(<class '__main__.F_FT'>, <class '__main__.F_FT1'>)
>>> 

Несколько экземпляров составного класса.

>>> One = compose(FT)
>>> q,r,s = One(),One(),One()
>>> q,r,s
(<__main__.F_FT object at 0x0000000003163860>,
 <__main__.F_FT object at 0x000000000D334198>,
 <__main__.F_FT object at 0x000000000D334828>)
>>>

---

Если все находится в одном модуле, тогда compose становится

def compose(ftype):
    return type(f'F_{ftype.__name__}',(F,ftype),{})

z = compose(FT)
y = compose(FT1)

---

В чем разница между миксином и наследованием?

---

Аналогичное решение с использованием абстрактного базового класса. - G не может быть создан, пока ge не будет переопределено.

import importlib
import abc

class G(abc.ABC):
    def __init__(self):
        self.x = 'foo'
    def a(self):
        s = '|'.join(f'{thing}' for thing in self.ge())
        return s
    def b(self):
        return 'baz'

    @staticmethod
    @abc.abstractmethod
    def ge():
        pass

# either of these work
def new(ftype):
    cls = getattr(importlib.import_module('figures'),ftype)
    return type(cls.__name__,(cls,G),{})
#def new(ftype):
#    cls = getattr(importlib.import_module('figures'),ftype)
#    return type(cls.__name__,(G,),{'ge':staticmethod(cls.ge)})
#usage
# A = new('FT')

---

Аналогично, за исключением того, что конкретные методы static являются просто обычными функциями и используют ABC сверху

def FT_ge():
    return ((0, 1),(0, 3),(0, 4),(2, 1),(2, 3),(2, 7),(6, 3))
def other_new(f):
    return type(f.__name__.split('_')[0],(G,),{'ge':staticmethod(f)})
# usage
# B = other_new(FT_ge)

Answer 2

Вы можете использовать importlib.import_module для импорта модуля. Однако было бы рекомендовано наследовать эти классы от базового класса, который использует метакласс, чтобы отслеживать его подклассы и отображать их, скажем, в словаре. Затем вы можете использовать этот базовый класс в качестве абстракции для взаимодействия со всеми дочерними классами Отслеживать подклассы в python