Extending parent behavior in Python - Time & Space Complexity

Time Complexity: Extending parent behavior

O(n)

Understanding Time Complexity

When we extend parent behavior in programming, we often add new actions on top of existing ones.

We want to see how this affects the time it takes for the program to run as the input grows.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

class Parent:
    def process(self, data):
        for item in data:
            print(item)

class Child(Parent):
    def process(self, data):
        super().process(data)
        for item in data:
            print(item * 2)

This code shows a child class extending a parent's method by first running the parent's loop, then adding its own loop over the same data.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Two separate loops over the input list.
• How many times: Each loop runs once over all items in the input.

How Execution Grows With Input

As the input list gets bigger, the program runs two loops, each touching every item once.

Input Size (n)	Approx. Operations
10	About 20 operations (2 loops x 10 items)
100	About 200 operations
1000	About 2000 operations

Pattern observation: The total work grows roughly twice as fast as the input size, but still in a straight line.

Final Time Complexity

Time Complexity: O(n)

This means the time to run grows directly in proportion to the size of the input list.

Common Mistake

[X] Wrong: "Because there are two loops, the time complexity is squared, like O(n²)."

[OK] Correct: The loops run one after another, not inside each other, so their times add up, not multiply.

Interview Connect

Understanding how extending behavior affects time helps you explain your code clearly and shows you can think about efficiency in real projects.

Self-Check

"What if the child class added a nested loop inside its process method? How would the time complexity change?"

Practice

1. What does super() do in a child class method?

easy

A. It overrides the child class method completely.

B. It calls the parent class method to reuse its behavior.

C. It deletes the parent class method.

D. It creates a new instance of the child class.

Solution

1. Step 1: Understand the role of super()

   super() is used to call a method from the parent class inside a child class method.

2. Step 2: Recognize code reuse

   By calling the parent method, the child can reuse existing behavior and add new features without rewriting code.

3. Final Answer:

   It calls the parent class method to reuse its behavior. -> Option B

4. Quick Check:

   super() calls parent method = D [OK]

Hint: Remember: super() runs parent method inside child [OK]

Common Mistakes:

• Thinking super() creates new instances
• Believing super() deletes methods
• Assuming super() overrides without calling parent

2. Which of the following is the correct syntax to call a parent class method greet inside a child class method in Python?

easy

A. super().greet()

B. super.greet()

C. parent.greet()

D. self.super.greet()

Solution

1. Step 1: Recall correct super() syntax

   In Python, super() is a function and must be called with parentheses before accessing methods.

2. Step 2: Identify correct method call

   The correct way to call the parent method is super().greet(), not super.greet() or others.

3. Final Answer:

   super().greet() -> Option A

4. Quick Check:

   super() needs parentheses = A [OK]

Hint: Use parentheses with super() to call parent methods [OK]

Common Mistakes:

• Omitting parentheses after super
• Using parent instead of super
• Trying to access super as an attribute

3. What will be the output of this code?

class Parent:
    def greet(self):
        print('Hello from Parent')

class Child(Parent):
    def greet(self):
        super().greet()
        print('Hello from Child')

c = Child()
c.greet()

medium

A. Hello from Child

B. Error: super() not defined

C. Hello from Parent

D. Hello from Parent
Hello from Child

Solution

1. Step 1: Trace the child greet() method

   The child method calls super().greet() first, which prints 'Hello from Parent'.

2. Step 2: Continue child method execution

   After calling the parent method, it prints 'Hello from Child'. So both lines print in order.

3. Final Answer:

   Hello from Parent Hello from Child -> Option D

4. Quick Check:

   super() calls parent then child prints = B [OK]

Hint: super() runs parent code first, then child adds more [OK]

Common Mistakes:

• Ignoring the parent print
• Expecting only child output
• Thinking super() causes error

4. Find the error in this code that tries to extend the parent method:

class Parent:
    def show(self):
        print('Parent show')

class Child(Parent):
    def show(self):
        super.show()
        print('Child show')

medium

A. super.show() should be super().show()

B. Child class must not override show()

C. Parent class method show() is missing self

D. print statements must be inside __init__

Solution

1. Step 1: Check super() usage

   The code uses super.show() which is incorrect 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 A

4. Quick Check:

   super() needs parentheses to call methods = A [OK]

Hint: Always use super() with parentheses to call parent methods [OK]

Common Mistakes:

• Forgetting parentheses after super
• Thinking parent method needs no self
• Believing print must be in __init__

5. You want to extend a parent class method calculate so that the child class adds 10 to the parent's result. Which code correctly does this?

class Parent:
    def calculate(self):
        return 5

class Child(Parent):
    def calculate(self):
        # Fill here

hard

A. return Parent.calculate() + 10

B. return calculate() + 10

C. return super().calculate() + 10

D. return self.calculate() + 10

Solution

1. Step 1: Use super() to call parent method

   To get the parent's result, call super().calculate() inside the child method.

2. Step 2: Add 10 to the parent's result

   Return the parent's value plus 10 as super().calculate() + 10.

3. Final Answer:

   return super().calculate() + 10 -> Option C

4. Quick Check:

   super() calls parent, add 10 = C [OK]

Hint: Use return super().method() + extra to extend result [OK]

Common Mistakes:

• Calling calculate() without super causes recursion
• Calling Parent.calculate() without instance
• Using self.calculate() causes infinite loop