Super function usage in Python - Time & Space Complexity

Time Complexity: Super function usage

O(n)

Understanding Time Complexity

We want to understand how using the super() function affects the time it takes for a program to run.

Specifically, we ask: does calling super() add extra work as the program grows?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

class Base:
    def process(self, data):
        return [x * 2 for x in data]

class Child(Base):
    def process(self, data):
        result = super().process(data)
        return [x + 1 for x in result]

items = list(range(1000))
child = Child()
output = child.process(items)

This code doubles each number in a list using the base class, then adds one to each number in the child class.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Two list comprehensions that each go through the entire list.
• How many times: Each list comprehension runs once, but each touches every item in the input list.

How Execution Grows With Input

As the input list gets bigger, the program does more work because it processes every item twice.

Input Size (n)	Approx. Operations
10	About 20 operations (10 doubled, 10 added)
100	About 200 operations
1000	About 2000 operations

Pattern observation: The work grows roughly twice as fast as the input size because of two passes over the data.

Final Time Complexity

Time Complexity: O(n)

This means the time to run grows in a straight line with the size of the input list, even with super() calls.

Common Mistake

[X] Wrong: "Using super() makes the program slower by a lot because it adds extra hidden loops."

[OK] Correct: super() just calls the parent method once; it does not add extra loops beyond what the parent method already does.

Interview Connect

Understanding how super() affects time helps you explain your code clearly and shows you know how inheritance impacts performance.

Self-Check

What if the parent method also called super() in a longer inheritance chain? How would that affect the time complexity?

Practice

1. What is the main purpose of using super() in a child class?

easy

A. To call a method from the parent class

B. To create a new instance of the child class

C. To delete the parent class

D. To override the child class method completely

Solution

1. Step 1: Understand what super() does

   super() is used to access methods from the parent class inside a child class.

2. Step 2: Identify the correct purpose

   Calling a parent class method helps reuse code and extend functionality.

3. Final Answer:

   To call a method from the parent class -> Option A

4. Quick Check:

   super() calls parent method = A [OK]

Hint: Remember: super() means 'call parent method' [OK]

Common Mistakes:

• Thinking super() creates new objects
• Believing super() deletes classes
• Assuming super() overrides child methods fully

2. Which of the following is the correct syntax to call a parent class method greet inside a child class method using super()?

easy

A. super().greet()

B. super->greet()

C. super[greet]()

D. super.greet()

Solution

1. Step 1: Recall the syntax of super()

   The correct way to call a parent method is using super() followed by dot and method name.

2. Step 2: Match the correct option

   Only super().greet() uses the right parentheses and dot notation.

3. Final Answer:

   super().greet() -> Option A

4. Quick Check:

   Use parentheses with super() = D [OK]

Hint: super() always needs parentheses before method call [OK]

Common Mistakes:

• Omitting parentheses after super
• Using square brackets instead of parentheses
• Using arrow notation which is invalid in Python

3. What will be the output of this code?

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

class Child(Parent):
    def greet(self):
        return super().greet() + " and Child"

c = Child()
print(c.greet())

medium

A. Hello from Parent

B. Hello from Child

C. Hello from Parent and Child

D. Error: super() not used correctly

Solution

1. Step 1: Understand method calls in Child.greet()

   Child's greet calls super().greet() which runs Parent's greet returning Hello from Parent.

2. Step 2: Combine returned strings

   Child's greet adds and Child to the parent's string, so final output is Hello from Parent and Child.

3. Final Answer:

   Hello from Parent and Child -> Option C

4. Quick Check:

   super() calls parent method + extra text = A [OK]

Hint: super() returns parent result; child can add more [OK]

Common Mistakes:

• Expecting only parent's message without child addition
• Thinking super() causes error here
• Ignoring the string concatenation

4. Find the error in this code using super():

class Base:
    def show(self):
        print("Base show")

class Derived(Base):
    def show(self):
        super.show()
        print("Derived show")

d = Derived()
d.show()

medium

A. Derived class should not override show()

B. Base class method show() is missing

C. print statements are incorrect

D. super.show() should be super().show()

Solution

1. Step 1: Identify how super() is called

   The code uses super.show() which is invalid syntax; super must be called as a function.

2. Step 2: Correct the syntax

   It should be super().show() to properly call the parent method.

3. Final Answer:

   super.show() should be super().show() -> Option D

4. Quick Check:

   super() needs parentheses before method = C [OK]

Hint: Always use super() with parentheses before method call [OK]

Common Mistakes:

• Calling super without parentheses
• Thinking parent method is missing
• Believing overriding is not allowed

5. You want to extend a parent class __init__ method to add a new attribute in the child class. Which code correctly uses super() to do this?

class Animal:
    def __init__(self, name):
        self.name = name

class Dog(Animal):
    def __init__(self, name, breed):
        ???
        self.breed = breed

Choose the correct replacement for ???.

hard

A. super(Dog, self).__init__(breed)

B. super().__init__(name)

C. Animal.__init__(self, breed)

D. super().__init__(breed)

Solution

1. Step 1: Understand parent __init__ parameters

   Animal's __init__ takes name, so we must pass name to it.

2. Step 2: Use super() correctly in child __init__

   Calling super().__init__(name) runs Animal's __init__ properly, then child adds breed.

3. Final Answer:

   super().__init__(name) -> Option B

4. Quick Check:

   super() calls parent with correct args = B [OK]

Hint: Pass parent's expected args to super().__init__() [OK]

Common Mistakes:

• Passing wrong argument to super()
• Calling parent __init__ without self
• Using old super() syntax incorrectly