Purpose of encapsulation in Python - Time & Space Complexity

Time Complexity: Purpose of encapsulation

O(n)

Understanding Time Complexity

We want to understand how the time cost changes when using encapsulation in Python code.

Specifically, how does wrapping data and methods inside a class affect the number of operations as the program runs?

Scenario Under Consideration

Analyze the time complexity of the following Python class with encapsulation.

class Counter:
    def __init__(self):
        self.__count = 0

    def increment(self):
        self.__count += 1

    def get_count(self):
        return self.__count

counter = Counter()
for _ in range(1000):
    counter.increment()
print(counter.get_count())
    

This code defines a class that hides its count variable and provides methods to change and access it.

Identify Repeating Operations

Look for loops or repeated actions that affect time.

• Primary operation: The loop calls increment() 1000 times.
• How many times: 1000 times, each increasing the hidden count by 1.

How Execution Grows With Input

As the number of increments grows, the total operations grow in the same way.

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

Pattern observation: The time grows directly with the number of increments.

Final Time Complexity

Time Complexity: O(n)

This means the time to run grows in a straight line as the number of increments increases.

Common Mistake

[X] Wrong: "Encapsulation makes the code slower because it hides data."

[OK] Correct: Encapsulation just organizes code and controls access; it does not add extra loops or repeated work that slows down the program.

Interview Connect

Understanding how encapsulation affects time helps you write clear and efficient code, a skill valued in real projects and interviews.

Self-Check

"What if the increment method also printed the count each time? How would the time complexity change?"