Inheritance and Overriding __init__ in python

Question

I was reading 'Dive Into Python' and in the chapter on classes it gives this example:

class FileInfo(UserDict):
    "store file metadata"
    def __init__(self, filename=None):
        UserDict.__init__(self)
        self["name"] = filename

The author then says that if you want to override the __init__ method, you must explicitly call the parent __init__ with the correct parameters.

1. What if that FileInfo class had more than one ancestor class?
   • Do I have to explicitly call all of the ancestor classes' __init__ methods?
2. Also, do I have to do this to any other method I want to override?

Lp

Note that Overloading is a separate concept from Overriding. – Peddle

Answer 1

The book is a bit dated with respect to subclass-superclass calling. It's also a little dated with respect to subclassing built-in classes.

It looks like this nowadays:

class FileInfo(dict):
    """store file metadata"""
    def __init__(self, filename=None):
        super(FileInfo, self).__init__()
        self["name"] = filename

Note the following:

1. We can directly subclass built-in classes, like dict, list, tuple, etc.

2. The super function handles tracking down this class's superclasses and calling functions in them appropriately.

Wawro

should i look for a better book/tutorial? – Lp

So in the case of multiple inheritance, does super() track them all down on your behalf? – Permalloy

dict.__init__(self), actually, but nothing's wrong with it - the super(...) call just provides a more consistent syntax. (I'm not sure how it works for multiple inheritance, I think it may only find one superclass init) – Zipah

The intention of super() is that it handles multiple inheritance. The disadvantage is, that in practice multiple inheritance still breaks very easily (see <fuhm.net/super-harmful ). – Tensity

Yes, in case of multiple inheritance and base classes taking constructor arguments, you usually find yourself calling the constructors manually. – Vlad

@bullettime: you can try mine -- it might not be enough better -- but here it is: homepage.mac.com/s_lott/books/python.html – Wawro

@S.Lott: Http/1.1 Service Unavailable - correct your link and will remove this – Psychoanalysis

Is it correct to call super's __init__() with no parameters? I thought the correct would be super(FileInfo,self).__init__(self) – Alga

I tried such syntax to subclass another class, but it throws an attribute error saying my class object has not an attribute which is actually created in superclass. Can someone explain what's wrong there please? – Percolate

Answer 2

In each class that you need to inherit from, you can run a loop of each class that needs init'd upon initiation of the child class...an example that can copied might be better understood...

class Female_Grandparent:
    def __init__(self):
        self.grandma_name = 'Grandma'

class Male_Grandparent:
    def __init__(self):
        self.grandpa_name = 'Grandpa'

class Parent(Female_Grandparent, Male_Grandparent):
    def __init__(self):
        Female_Grandparent.__init__(self)
        Male_Grandparent.__init__(self)

        self.parent_name = 'Parent Class'

class Child(Parent):
    def __init__(self):
        Parent.__init__(self)
#---------------------------------------------------------------------------------------#
        for cls in Parent.__bases__: # This block grabs the classes of the child
             cls.__init__(self)      # class (which is named 'Parent' in this case), 
                                     # and iterates through them, initiating each one.
                                     # The result is that each parent, of each child,
                                     # is automatically handled upon initiation of the 
                                     # dependent class. WOOT WOOT! :D
#---------------------------------------------------------------------------------------#



g = Female_Grandparent()
print g.grandma_name

p = Parent()
print p.grandma_name

child = Child()

print child.grandma_name

Spoonful

It doesn't seem like the for loop in Child.__init__ is necessary. When I remove it from the example I child still prints "Grandma". Isn't grandparent init handled by the Parent class? – Giamo

I think granparents init's are already handled by Parent's init, aren't they? – Hardship

Answer 3

You don't really have to call the __init__ methods of the base class(es), but you usually want to do it because the base classes will do some important initializations there that are needed for rest of the classes methods to work.

For other methods it depends on your intentions. If you just want to add something to the base classes behavior you will want to call the base classes method additionally to your own code. If you want to fundamentally change the behavior, you might not call the base class' method and implement all the functionality directly in the derived class.

Tensity

For technical completeness, some classes, like threading.Thread, will throw gigantic errors if you ever try to avoid calling the parent's init. – Kashgar

I find all this "you don't have to call the base's constructor" talk extremely irritating. You don't have to call it in any language I know. All of them will screw up (or not) in much the same way, by not initializing members. Suggesting not to initialize base classes is just wrong in so many ways. If a class does not need initialization now it will need it in the future. The constructor is part of the interface of the class structure/language construct,and should be used correctly. It's correct use is to call it sometime in your derived's constructor. So do it. – Cochleate

"Suggesting not to initialize base classes is just wrong in so many ways." No one has suggested to not initialize the base class. Read the answer carefully. It's all about intention. 1) If you want to leave the base class' init logic as is, you don't override init method in your derived class. 2) If you want to extend the init logic from the base class, you define your own init method and then call base class' init method from it. 3) If you want to replace base class' init logic, you define your own init method while not calling the one from the base class. – Photocopier

@Cochleate retrobump, I know, but some languages force you to do it, notably Java. In Java, for example, the language implicitly calls super(); unless you explicitly call it or another constructor, and if it cannot it produces a compiler error. – Flop

Answer 4

If the FileInfo class has more than one ancestor class then you should definitely call all of their __init__() functions. You should also do the same for the __del__() function, which is a destructor.

Waspish

Answer 5

Yes, you must call __init__ for each parent class. The same goes for functions, if you are overriding a function that exists in both parents.

Backus

Answer 6

Even more easier, in 2023, if you don’t want to manually enter every argument in your __init__() calls, just use *args and **kwargs like this:

class MyClass(ParentClass):
    def __init__(self, *args, **kwargs):
        # Processing before init call
        super().__init__(*args, **kwargs)
        # Processing after init call

Kamkama