OOP principles overview in Python - Time & Space Complexity

Time Complexity: OOP principles overview

O(n)

Understanding Time Complexity

When we use object-oriented programming (OOP), we organize code into objects and classes. It's important to understand how the time it takes to run our programs changes as we use these OOP ideas.

We want to see how the main actions in OOP affect the program's speed when the program grows bigger.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

class Item:
    def __init__(self, value):
        self.value = value

class Container:
    def __init__(self, items):
        self.items = items

    def total_value(self):
        total = 0
        for item in self.items:
            total += item.value
        return total
    

This code defines two classes. One holds a value, and the other holds many such items and sums their values.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Looping through the list of items in total_value.
• How many times: Once for each item in the container.

How Execution Grows With Input

As the number of items grows, the time to add their values grows too.

Input Size (n)	Approx. Operations
10	10 additions
100	100 additions
1000	1000 additions

Pattern observation: The work grows directly with the number of items. Double the items, double the work.

Final Time Complexity

Time Complexity: O(n)

This means the time to run total_value grows in a straight line with the number of items.

Common Mistake

[X] Wrong: "Using classes always makes the program slower because of extra steps."

[OK] Correct: Classes organize code but do not add hidden loops. The main time depends on what the code inside the methods does, like loops over data.

Interview Connect

Understanding how loops inside class methods affect time helps you explain your code clearly. It shows you know how your program grows and runs efficiently.

Self-Check

"What if the total_value method called another method inside each item that also loops over data? How would the time complexity change?"