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?