Python: множественное наследование, конструктор копирования, инициализация класса и () перегрузка

Question

Я искал способ инициализировать производный класс, используя конструктор копирования и оператор (), как в C++

class Rectangle {
    int width, height;
  public:
    Rectangle (int,int);
    int area () {return (width*height);}
};

Rectangle::Rectangle (int a, int b) {
  width = a;
  height = b;
}

r = Rectangle(2,3)
s = Rectangle(r) /* <--using copy constructor to initialize*/

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

class MyBase1(object):
    def __init__(self, *args, **kwargs):
        self.x = kwargs.get('x')
        self.y = kwargs.get('y')
        print("mybase1 {}".format(kwargs))

    def print_base1(self):
        pass


class MyBase2(object):
    def __init__(self, *args, **kwargs):
        self.s = kwargs.get('s')
        self.p = kwargs.get('p')
        print("mybase2 {}".format(kwargs))

    def print_base2(self):
        pass


class MyChild(MyBase1, MyBase2):

    def __init__(self, **kwargs):
        MyBase1.__init__(self, **kwargs)
        MyBase2.__init__(self, **kwargs)
        self.function_name = kwargs.get('function')


    def __call__(self, my_base1, my_base2, **kwargs):
        initialization_dictionary = dict(vars(my_base1), **vars(my_base2))
        initialization_dictionary = dict(initialization_dictionary, **kwargs)
        newInstance = MyChild(**initialization_dictionary)
        return newInstance

звоню потом:

base1 = MyBase1(x=1, y=2)
base2 = MyBase2(s=3, p=4)

child = MyChild()(base1, base2, function='arcsine') #<--initialising 

[stm for stm in dir(child) if not stm.startswith('__')]
# gives:['function_name', 'p', 'print_base1', 'print_base2', 's', 'x', 'y']

vars(child)
# gives:{'function_name': 'arcsine', 'p': 4, 's': 3, 'x': 1, 'y': 2}

Так что мне было интересно, насколько это непитонический способ? И если есть лучший способ (или нет) сделать то же самое?

Answer 1

Ну, вы бы не хотели создавать экземпляр для создания нового экземпляра, поэтому, вы, вероятно, хотите classmethod или же staticmethod, Это не место для использования __call__ или.

Я мог бы сделать это:

class MyChild(MyBase1, MyBase2):
    @classmethod
    def build_from_bases(klass, base1, base2, **kwargs):
        kwargs.update(base1.__dict__)
        # Note if base2 has values for x and y, they will clobber what was in base1
        kwargs.update(base2.__dict__)
        return klass(**kwargs)

Но использование экземпляров Base1 и Base2 для создания экземпляра MyChild не похоже на то, что я делал бы в python. Гораздо вероятнее использовать очевидное:

mychild = MyChild(x=base1.x, y=base1.y, s=base2.s, p=base2.p, function='foo')

На самом деле, я бы предпочел это, теперь мне не нужно беспокоиться о том, чтобы сбить с толку ценности или другие странности.

Вы могли бы объединить оба, если вы действительно хотите использовать метод сокращения:

class MyChild(MyBase1, MyBase2):
    @classmethod
    def build_from_bases(klass, base1, base2, **kwargs):
       return klass(x=base1.x, y=base1.y, s=base2.s, p=base2.p, **kwargs)

В Python менее "умный" часто "лучше"