Python: Inherit the superclass init

Question

I have a base class with a lot of __init__ arguments:

class BaseClass(object):
    def __init__(self, a, b, c, d, e, f, ...):
        self._a=a+b
        self._b=b if b else a
        ...

All the inheriting classes should run __init__ method of the base class.

I can write a __init__() method in each of the inheriting classes that would call the superclass __init__, but that would be a serious code duplication:

class A(BaseClass):
    def __init__(self, a, b, c, d, e, f, ...):
        super(A, self).__init__(a, b, c, d, e, f, ...)

class B(BaseClass):
    def __init__(self, a, b, c, d, e, f, ...):
        super(A, self).__init__(a, b, c, d, e, f, ...)

class C(BaseClass):
    def __init__(self, a, b, c, d, e, f, ...):
        super(A, self).__init__(a, b, c, d, e, f, ...)

...

What's the most Pythonic way to automatically call the superclass __init__?

score 61 · Accepted Answer · edited Jun 26 '13 at 14:25

61

super(SubClass, self).__init__(...)

Consider using *args and **kw if it helps solving your variable nightmare.

edited Jun 26 '13 at 14:25

felippo

5
2

answered Jun 30 '11 at 13:55

It helps, but is there a way to completely avoid explicitly calling the superclass __init__? – Adam Matan Jun 30 '11 at 13:58
4

@Adam Matan No, there isn't. See here why: [Why aren't Python's superclass __init__ methods automatically invoked?](http://stackoverflow.com/questions/3782827/why-arent-pythons-superclass-init-methods-automatically-invoked) – Paolo Moretti Jun 30 '11 at 14:01
@Cat Plus Plus correct, but it still requires the annoying code duplication for every base class. – Adam Matan Jun 30 '11 at 14:02
Are there any difference from BaseClass.__init__(self,*args,*kwargs) and super(BaseClass, self).__init__(*args,*kwargs) ? – Dog eat cat world Jun 30 '11 at 14:31
1

@Dogeatcatworld yes. If you called `BaseClass.__init__` inside of `BaseClass(): __init__:` you would get infinite recursion. `super` calls the parent class. – Nick Humrich Jul 22 '14 at 15:34
2

@CatPlusPlus Sorry, I have a very stupid question. In Python 3, how can I use the ellipsis to feed the __init__()? I kept getting errors. When you guys used "...", did you really mean ellipsis in the code or it was just meant to save typing? – astroboylrx Feb 13 '17 at 20:03
what if I want to pass new params in class A? – Kai Wang Nov 16 '18 at 20:37

score 45 · Answer 2 · edited Jun 26 '13 at 14:28

45

You have to write it explicitly, but on the other hand, if you have lots of args, you should probably use *args for positional args and **kwargs for keyword args.

class SubClass(BaseClass):
    def __init__(self, *args, **kwargs):
        super(SubClass, self).__init__(*args, **kwargs)
        # SubClass initialization code

Another technique you could use is to minimize the code in init and then at the end of init function, call another custom function. Then in the subclass, you just need to override the custom function

class BaseClass(object):
    def __init__(self, *args, **kwargs):
        # initialization code
        self._a = kwargs.get('a')
        ...
        # custom code for subclass to override
        self.load()

    def load():
        pass

class SubClass(BaseClass)
    def load():
        # SubClass initialization code
        ...

edited Jun 26 '13 at 14:28

felippo

5
2

answered Jun 30 '11 at 14:01

Ryan Ye

3,159
1
22
26

1

This is a technique I've used, in some cases going so far as to provide `preinit()` and `postinit()` hooks. The return value from `preinit()` can be saved in a local variable in `__init__` and passed to `postinit()`, which is convenient sometimes. – kindall Sep 21 '11 at 22:29
@kindall I want to write a superclass that does some modest, uniform member checking of subclass instances (viz., that needed member variables exist and have sane contents), as part of their `__init__` process. I think this sort of `postinit()` hook should work perfectly. – hBy2Py Sep 26 '15 at 16:40
2

improvement: kwargs.get('a', defaultvaluehere) instead of kwargs.get('a') – Massimo Variolo Dec 02 '15 at 10:28
I like this method, but for me it makes more sense to pass **kwargs to the loader as that way the positional args are reserved for the base class arguments that will exist in every implementation and keyword arguments can be used to pass in arguments specific to any given implementation. – Simon Notley Nov 25 '20 at 20:26

pillmuncher · Answer 3 · 2011-09-21T21:45:45.763

If the derived classes don't implement anything beyond what the base class __init__() already does, just omit the derived classes __init__() methods - the base class __init__() is then called automatically.

If, OTOH, your derived classes add some extra work in their __init__(), and you don't want them to explicitly call their base class __init__(), you can do this:

class BaseClass(object):
    def __new__(cls, a, b, c, d, e, f, ...):
        new = object.__new__(cls)
        new._a=a+b
        new._b=b if b else a
        ...
        return new

class A(BaseClass):
    ''' no __init__() at all here '''

class B(BaseClass):
    def __init__(self, a, b, c, d, e, f, ...):
        ''' do stuff with init params specific to B objects '''

Since __new__() is always called automatically, no further work is required in the derived classes.

Fine method, usefull to know. +1. - By the way, as in the question, the code needs to be corrected: _class BaseClass(object)_ instead of _def BaseClass(object)_ — eyquem, Sep 21 '11 at 12:43

score 15 · Answer 4 · answered Mar 31 '18 at 12:13

15

Perhaps a clearer implementation for your case is using **kwargs combined with new added arguments in your derived class as in:

class Parent:
    def __init__(self, a, b, c):
        self.a = a
        self.b = b
        self.c = c


class Child(Parent):
    def __init__(self, d, **kwargs):
        super(Child, self).__init__(**kwargs)
        self.d = d

By this method you avoid the code duplication but preserve the implicit addition of arguments in your derived class.

answered Mar 31 '18 at 12:13

avielbl

193
1
7

2

all solution should looks like this one. – Kai Wang Nov 16 '18 at 20:46
1

Running `Child(1, 2, 3, 4) ` I get `TypeError: __init__() takes 2 positional arguments but 5 were given`. I suspect this should be `*args` instead of `**kwargs` – JavNoor Aug 20 '19 at 19:33
by using args, you might mix between your arguments when calling to your child classes. This is why it is better practice in such situation to use **kw and named arguments – avielbl Aug 22 '19 at 04:41

score 14 · Answer 5 · answered Jun 30 '11 at 14:04

Unless you are doing something useful in the subclass __init__() methods, you don't have to override it.

def BaseClass(object):
    def __init__(self, a, b, c, d, e, f, ...):
        self._a=a+b
        self._b=b if b else a
        ...

def A(BaseClass):
    def some_other_method(self):
        pass

def B(BaseClass):
    pass

score 2 · Answer 6 · answered Jan 12 '17 at 11:58

2

In 2.6 and lower version to inherit init from base class, there is no super function, You can inherit below way:

class NewClass():
     def __init__():
         BaseClass.__init__(self, *args)

answered Jan 12 '17 at 11:58

Aashutosh jha

552
6
8

score 0 · Answer 7 · edited Jan 29 '16 at 16:24

0

Adding a Pythonic implementation. Assuming you want all attributes passed in, you can use the code below. (Can also keep/remove specific kwargs keys if you want a subset).

def A(BaseClass):
    def __init__(self, *args, **kwargs):
        for key, value in kwargs.items():
            setattr(self, key, value)

base = BaseClass(...)
new = A( **base.__dict__ )

edited Jan 29 '16 at 16:24

Adam Matan

128,757
147
397
562

answered Jan 29 '16 at 02:44

Ben

381
1
3
15

Python: Inherit the superclass init

7 Answers7

Linked

Related

Python: Inherit the superclass __init__

7 Answers7

Linked

Related

Python: Inherit the superclass init