Method invocation flow in Python - Time & Space Complexity

Time Complexity: Method invocation flow

O(1)

Understanding Time Complexity

When we call methods in a program, each call takes some time to run. Understanding how the total time grows when methods call other methods helps us write faster code.

We want to know: how does the time to finish change as the program runs more method calls?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

class Calculator:
    def multiply(self, x, y):
        return x * y

    def square(self, n):
        return self.multiply(n, n)

result = Calculator().square(5)
print(result)

This code defines two methods: one multiplies two numbers, and the other calls multiply to square a number.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: The method call to multiply inside square.
• How many times: Exactly once per call to square.

How Execution Grows With Input

Each time we call square, it calls multiply once. The work done depends only on the number of calls, not the size of the numbers.

Input Size (n)	Approx. Operations
10	10 method calls, 10 multiplications
100	100 method calls, 100 multiplications
1000	1000 method calls, 1000 multiplications

Pattern observation: The total work grows directly with the number of method calls.

Final Time Complexity

Time Complexity: O(1)

This means if you call the method once, the total time is constant and does not grow with input size.

Common Mistake

[X] Wrong: "Calling one method inside another makes the program run much slower, like multiplying the time by n squared."

[OK] Correct: Each method call adds a fixed amount of work, so the total time grows linearly, not squared, unless there are nested loops or recursive calls.

Interview Connect

Understanding how method calls add up helps you explain how your code runs and scales. This skill shows you can think about program speed clearly and write efficient code.

Self-Check

"What if the multiply method called another method inside it? How would the time complexity change?"

Practice

1. What does method invocation flow describe in Python?

easy

A. The order in which methods are called and executed

B. The way variables are declared inside methods

C. How to write comments inside methods

D. The syntax rules for defining methods

Solution

1. Step 1: Understand the term 'method invocation'

   Method invocation means calling a method to run its code.

2. Step 2: Understand 'flow' in this context

   Flow means the order or sequence in which these method calls happen.

3. Final Answer:

   The order in which methods are called and executed -> Option A

4. Quick Check:

   Method invocation flow = method call order [OK]

Hint: Think: When you call methods, what order do they run? [OK]

Common Mistakes:

• Confusing method flow with variable declaration
• Thinking it means method syntax rules
• Mixing it up with comments inside methods

2. Which of the following is the correct way to call a method named greet on an object person?

easy

A. greet.person()

B. person.greet()

C. person->greet()

D. greet(person)

Solution

1. Step 1: Recall Python method call syntax

   In Python, to call a method on an object, use dot notation: object.method()

2. Step 2: Check each option

   person.greet() uses correct dot notation with parentheses. Others use invalid syntax or function call style.

3. Final Answer:

   person.greet() -> Option B

4. Quick Check:

   Object.method() is correct call syntax [OK]

Hint: Remember: object.method() calls a method in Python [OK]

Common Mistakes:

• Using arrow (->) like other languages
• Reversing object and method order
• Calling method without parentheses

3. What is the output of this code?

class A:
    def first(self):
        print('First')
        self.second()
    def second(self):
        print('Second')

obj = A()
obj.first()

medium

A. Second

B. Second\nFirst

C. First\nSecond

D. First

Solution

1. Step 1: Trace method calls

   Calling obj.first() prints 'First' then calls self.second(), which prints 'Second'.

2. Step 2: Determine output order

   Output is 'First' then 'Second' on separate lines.

3. Final Answer:

   First\nSecond -> Option C

4. Quick Check:

   Method calls run in order called [OK]

Hint: Follow method calls step-by-step to find output order [OK]

Common Mistakes:

• Assuming second() runs before first()
• Missing the call to second() inside first()
• Thinking only first print runs

4. Find the error in this code:

class B:
    def start(self):
        self.middle()
    def middle(self):
        self.end()
    def end(self):
        print('Done')

b = B()
b.middle()

medium

A. No output because start() is not called

B. AttributeError because end() is not defined

C. TypeError due to missing arguments

D. No error, prints 'Done'

Solution

1. Step 1: Check method definitions

   All methods are defined correctly with self parameter.

2. Step 2: Check method call

   b.middle() calls self.end(), which prints 'Done'. So output is 'Done' with no error.

3. Final Answer:

   No error, prints 'Done' -> Option D

4. Quick Check:

   Calling middle() runs end() correctly [OK]

Hint: Trace calls from the method you invoke to see output [OK]

Common Mistakes:

• Expecting start() must be called first
• Thinking end() is undefined
• Confusing missing arguments error

5. Given this code, what will be printed?

class C:
    def a(self):
        print('A')
        self.b()
    def b(self):
        print('B')
        self.c()
    def c(self):
        print('C')

c = C()
c.a()

hard

A. A\nB\nC

B. A\nC\nB

C. C\nB\nA

D. B\nC\nA

Solution

1. Step 1: Follow method calls starting from c.a()

   c.a() prints 'A' then calls self.b()

2. Step 2: Trace self.b() and self.c()

   self.b() prints 'B' then calls self.c(), which prints 'C'.

3. Step 3: Combine outputs in order

   Output is 'A' then 'B' then 'C' each on new lines.

4. Final Answer:

   A\nB\nC -> Option A

5. Quick Check:

   Method calls chain in order a->b->c [OK]

Hint: Follow each method call in order to find print sequence [OK]

Common Mistakes:

• Mixing order of method calls
• Skipping intermediate method calls
• Assuming methods run independently