Super function usage in Python - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of super() in multiple inheritance

What is the output of this Python code using super() in multiple inheritance?

Python

class A:
    def greet(self):
        return "Hello from A"

class B(A):
    def greet(self):
        return super().greet() + " and B"

class C(A):
    def greet(self):
        return super().greet() + " and C"

class D(B, C):
    def greet(self):
        return super().greet() + " and D"

obj = D()
print(obj.greet())

A "Hello from A and B and C and D"

B "Hello from A and C and D"

C "Hello from A and B and D"

D "Hello from A and C and B and D"

💡 Hint

Remember that super() follows the method resolution order (MRO) in multiple inheritance.

The method resolution order for class D is D → B → C → A. Each greet method calls super().greet(), so the calls chain through A, then C, then B, then D, concatenating strings as "Hello from A and B and C and D".

❓ Predict Output

intermediate

Using super() with arguments

What will be printed when running this code that uses super() with arguments?

Python

class Base:
    def __init__(self, x):
        self.x = x

class Child(Base):
    def __init__(self, x, y):
        super(Child, self).__init__(x)
        self.y = y

obj = Child(5, 10)
print(obj.x, obj.y)

A 10 5

B 5 10

C TypeError

D AttributeError

💡 Hint

Check how super() is called with explicit arguments and how the base class constructor is called.

The Child class calls super(Child, self).__init__(x), which correctly calls the Base constructor with x. So obj.x is 5 and obj.y is 10.

❓ Predict Output

advanced

Effect of missing super() call in override

What is the output of this code where a subclass overrides a method but does NOT call super()?

Python

class Parent:
    def action(self):
        return "Parent action"

class Child(Parent):
    def action(self):
        return "Child action"

obj = Child()
print(obj.action())

A TypeError

B "Parent action"

C "Child action"

D AttributeError

💡 Hint

If a method is overridden without calling super(), the base method is not executed.

The Child class overrides action and returns its own string without calling super(). So the output is "Child action".

❓ Predict Output

advanced

super() in diamond inheritance pattern

What will this code print when using super() in a diamond inheritance pattern?

Python

class Top:
    def process(self):
        return "Top"

class Left(Top):
    def process(self):
        return super().process() + "->Left"

class Right(Top):
    def process(self):
        return super().process() + "->Right"

class Bottom(Left, Right):
    def process(self):
        return super().process() + "->Bottom"

obj = Bottom()
print(obj.process())

A "Top->Right->Left->Bottom"

B "Top->Left->Bottom"

C "Top->Right->Bottom"

D "Top->Left->Right->Bottom"

💡 Hint

Check the method resolution order (MRO) for Bottom and how super() calls chain.

The MRO for Bottom is Bottom → Left → Right → Top. Each process calls super().process(), so the string builds as "Top->Left->Right->Bottom".

🧠 Conceptual

expert

Why use super() instead of direct parent class call?

Which is the best reason to use super() instead of directly calling a parent class method in Python?

A super() automatically follows the method resolution order, supporting multiple inheritance correctly.

B super() is faster than direct parent class calls.

C super() allows calling private methods of the parent class.

D super() can only be used in single inheritance, making code simpler.

💡 Hint

Think about how Python handles multiple inheritance and method calls.

super() respects the method resolution order (MRO), which is essential for multiple inheritance to work correctly. Direct calls to parent classes can skip other classes in the MRO, causing bugs.