Вызов super () .__ init __ (** kwargs) и множественное наследование?

Это должно работать

class Employee:
    def __init__(self, firstname='', lastname='', age='', dob=''):
        self.firstname = firstname
        self.lastname = lastname
        self.age = age 
        self.dob = dob 

Тогда у вас есть дочерний класс

class Hourly2(Employee):
    def __init__(self,*args, **kwargs):
        super(Hourly2,self).__init__(*args, **kwargs)

    def get_rate(self,rate=None):
    self.data=rate
    print ('My hourly rate is {}'.format(self.data))

Теперь давайте создадим пример

bob = Hourly2('Bob', 'Bar', '23', '12/1/2019')

Мы можем проверить атрибуты

dir(bob)
['__class__',
 '__delattr__',
 '__dict__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__gt__',
 '__hash__',
 '__init__',
 '__init_subclass__',
 '__le__',
 '__lt__',
 '__module__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 '__weakref__',
 'age',
 'dob',
 'firstname',
 'get_rate',
 'lastname']

Ну наконец то

bob.age
'23'

А также

bob.get_rate('$12')
My hourly rate is $12

Проблема, которую вы здесь видите, на самом деле не специфична для super, а более специфична для kwargs. Если мы выбросим большую часть вашего кода и удалим супер, это будет выглядеть так:

class Hourly(Employee):

    def __init__(self, rate=''):
        self.rate = rate
        some_crazy_function(**kwargs)

hourlystaff1 = Hourly('Bob', 'Foo', '23', 'M', '12/1/1980', '$15', '30')

Есть две очевидные проблемы: функция __init__ получает больше аргументов, чем ожидалось, а в теле функции __init__ есть ссылка на kwargs, которая нигде не определена. Хотя здесь понимания **kwargs (и его брата *args) достаточно, чтобы решить проблему, здесь super и **kwargs очень полезны вместе. Давайте сначала посмотрим, чем полезен super. Давайте представим, что мы пишем несколько оболочек для подпроцессов с некоторыми хорошими вспомогательными методами (архитектура, возможно, не наилучшим образом подходит для проблемы, но только когда-либо видеть животных с наследованием также не очень полезно. Множественное наследование - действительно редкий случай, поэтому это сложно чтобы придумать хорошие примеры, которые не являются животными, GameEntities или GUIwidgets):

class Process:
    def __init__(self, exe):
        self.exe = exe
        self.run()

class DownloadExecutableBeforeProcess(Process):
    def __init__(self, exe):
        self.download_exe(exe)
        Process.__init__(self, exe)

Здесь мы выполняем наследование, и нам даже не нужно использовать super - мы можем просто явно использовать имя суперкласса и иметь желаемое поведение. Мы могли бы переписать здесь, чтобы использовать super, но это не изменило бы поведения. Если вы наследуете только один класс, вам не обязательно super, хотя это может помочь вам не повторять имя класса, от которого вы наследуете. Давайте добавим к нашему классу иерархию и включим наследование от более чем одного класса:

class AuthenticationCheckerProcess(Process):
    def __init__(self, exe, use_sha=True):
        self.check_if_authorized(exe, use_sha)
        Process.__init__(self, exe)

class DownloadAndCheck(DownloadExecutableBefore, AuthenticationCheckerProcess):
    def __init__(self, exe):
        DownloadExecutableBefore.__init__(exe)
        AuthenticationCheckerProcess.__init__(exe, use_sha=False)

Если мы проследим за инициализацией DownloadAndCheck, мы увидим, что Process.__init__ вызывается дважды: один раз через DownloadExecutableBefore.__init__ и один раз через AuthenticationCheckerProcess.__init__! Итак, наш процесс, который мы хотим обернуть, также запускается дважды, а это не то, что нам нужно. Здесь, в этом примере, мы могли бы легко исправить это, не вызывая self.run() в инициализации процесса, но в реальных случаях это не всегда так легко исправить, как здесь. В данном случае вызов Process.__init__ кажется неправильным. Можно как-то это исправить?

class DownloadAndCheck(DownloadExecutableBefore, AuthenticationCheckerProcess):
    def __init__(self, exe):
        super().__init__(exe, use_sha=False)
        # also replace the Process.__init__ cals in the other classes with super

super устраняет эту проблему и вызывает Process.__init__ только один раз. Он также позаботится о порядке, в котором должна выполняться функция, но здесь это не является большой проблемой. У нас все еще есть проблема: use_sha=False будет передан инициализаторам все, но на самом деле он нужен только одному. На самом деле мы не можем передать переменную только тем функциям, которые в ней нуждаются (потому что выяснить это было бы кошмаром), но мы можем научить другие __init__ просто игнорировать клавиатуру:

class Process:
    def __init__(self, exe, **kwargs):
        # accept arbitrary keywoards but ignore everything but exe
        # also put **kwargs in all other initializers
        self.exe = exe
        self.run()

class DownloadExecutableBeforeProcess(Process):
    def __init__(self, exe, **kwargs):
        self.download_exe(exe)
        # pass the keywoards into super so that other __init__s can use them
        Process.__init__(self, exe, **kwargs)

Теперь вызов super().__init__(exe, use_sha=False) будет успешным, каждый инициализатор берет только те клавиатуры, которые он понимает, и просто передает остальные ниже.

Итак, если у вас есть множественное наследование и вы используете разные (ключевые) аргументы, super и kwargs могут решить вашу проблему. Но супер- и множественное наследование - это сложно, особенно если у вас больше слоев наследования, чем здесь. Иногда порядок, в котором должны вызываться функции, даже не определен (и тогда python должен выдать ошибку, см., Например, объяснение изменения алгоритма ТОиР). Примеси могут даже потребовать вызова super().__init__(), хотя они даже не наследуются ни от одного класса. В целом, вы усложняете свой код, если используете множественное наследование, поэтому, если оно вам действительно не нужно, часто лучше подумать о других способах моделирования вашей проблемы.