Procedural vs object-oriented approach in Python - Performance Comparison

Time Complexity: Procedural vs object-oriented approach

O(n)

Understanding Time Complexity

We want to see how the way we organize code affects how long it takes to run.

Does using objects instead of simple steps change how the program grows with bigger input?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

def sum_list_procedural(numbers):
    total = 0
    for num in numbers:
        total += num
    return total

class NumberList:
    def __init__(self, numbers):
        self.numbers = numbers
    def sum(self):
        total = 0
        for num in self.numbers:
            total += num
        return total

This code shows two ways to sum numbers: one with simple steps, one using a class and method.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Looping through the list of numbers to add each one.
• How many times: Once for each number in the list (n times).

How Execution Grows With Input

As the list gets bigger, the number of additions grows the same way.

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, no matter the style used.

Final Time Complexity

Time Complexity: O(n)

This means the time to sum numbers grows in a straight line with how many numbers there are.

Common Mistake

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

[OK] Correct: Both ways do the same main work of adding numbers once each, so time grows the same way.

Interview Connect

Understanding how different coding styles affect time helps you explain your choices clearly and shows you know what really matters in performance.

Self-Check

"What if the sum method called another method inside the class for each number? How would that affect the time complexity?"

Practice

1. Which statement best describes the main difference between procedural and object-oriented programming in Python?

easy

A. Procedural programming is faster than object-oriented programming in all cases.

B. Procedural programming is only for small programs; object-oriented programming is for large programs.

C. Procedural programming cannot use variables; object-oriented programming can.

D. Procedural programming uses functions and step-by-step instructions; object-oriented programming uses classes and objects.

Solution

1. Step 1: Understand procedural programming basics

   Procedural programming organizes code as functions and instructions executed in order.

2. Step 2: Understand object-oriented programming basics

   Object-oriented programming organizes code using classes and objects that combine data and behavior.

3. Final Answer:

   Procedural programming uses functions and step-by-step instructions; object-oriented programming uses classes and objects. -> Option D

4. Quick Check:

   Procedural = functions, OOP = classes/objects [OK]

Hint: Procedural = steps; OOP = objects/classes [OK]

Common Mistakes:

• Thinking procedural can't use variables
• Believing OOP is always slower
• Confusing program size with programming style

2. Which of the following is the correct way to define a class in Python?

easy

A. def MyClass(): pass

B. class MyClass(): pass

C. function MyClass() {}

D. class MyClass[]: pass

Solution

1. Step 1: Recall Python class syntax

   In Python, classes are defined using the keyword class followed by the class name and parentheses.

2. Step 2: Check each option

   class MyClass(): pass uses correct Python syntax. def MyClass(): pass uses def which defines a function, not a class. function MyClass() {} uses JavaScript syntax. class MyClass[]: pass uses invalid brackets.

3. Final Answer:

   class MyClass(): pass -> Option B

4. Quick Check:

   Python classes start with 'class' keyword [OK]

Hint: Classes start with 'class' keyword in Python [OK]

Common Mistakes:

• Using def instead of class
• Using wrong brackets [] instead of ()
• Confusing Python with other languages syntax

3. What will be the output of this Python code?

def greet(name):
    return f"Hello, {name}!"

class Person:
    def __init__(self, name):
        self.name = name
    def greet(self):
        return greet(self.name)

p = Person("Anna")
print(p.greet())

medium

A. TypeError

B. Hello, name!

C. Hello, Anna!

D. AttributeError

Solution

1. Step 1: Understand the procedural function greet

   The function greet(name) returns the string "Hello, {name}!" with the given name.

2. Step 2: Understand the Person class and method call

   The Person class stores the name and its greet method calls the procedural greet function with self.name. Creating p with name "Anna" and calling p.greet() returns "Hello, Anna!".

3. Final Answer:

   Hello, Anna! -> Option C

4. Quick Check:

   Class method calls procedural function correctly [OK]

Hint: Class method calls function with self.name [OK]

Common Mistakes:

• Confusing variable name with string 'name'
• Expecting error due to mixing styles
• Forgetting to use self.name

4. Identify the error in this code that mixes procedural and object-oriented styles:

class Calculator:
    def add(self, a, b):
        return a + b

result = Calculator.add(3, 4)
print(result)

medium

A. Missing self argument when calling add method

B. Class Calculator is not defined

C. add method should not return a value

D. print statement syntax error

Solution

1. Step 1: Understand method call on class vs instance

   The add method is an instance method requiring a self parameter. Calling Calculator.add(3, 4) misses the self argument.

2. Step 2: Correct usage

   To fix, create an instance: calc = Calculator() then call calc.add(3, 4). This passes self automatically.

3. Final Answer:

   Missing self argument when calling add method -> Option A

4. Quick Check:

   Instance methods need self, call via instance [OK]

Hint: Call instance methods on object, not class [OK]

Common Mistakes:

• Calling instance method directly on class
• Ignoring self parameter
• Assuming methods are static by default

5. You want to convert this procedural code into an object-oriented style. Which class design correctly encapsulates the data and behavior?

# Procedural code
def area_rectangle(width, height):
    return width * height

w = 5
h = 3
print(area_rectangle(w, h))

hard

A. class Rectangle:
def __init__(self, width, height):
self.width = width
self.height = height
def area(self):
return self.width * self.height

B. class Rectangle:
def area(width, height):
return width * height

C. class Rectangle:
def __init__(self):
pass
def area(self):
return width * height

D. class Rectangle:
def __init__(self, width, height):
return width * height

Solution

1. Step 1: Identify data and behavior to encapsulate

   The procedural code uses width and height as data and area_rectangle as behavior. In OOP, these should be inside a class.

2. Step 2: Check class options for correct encapsulation

   class Rectangle: def __init__(self, width, height): self.width = width self.height = height def area(self): return self.width * self.height stores width and height as instance variables and defines area() method using them. Other options either miss self, lack data storage, or misuse return in constructor.

3. Final Answer:

   class Rectangle with __init__ storing width and height, and area method using them -> Option A

4. Quick Check:

   OOP encapsulates data and behavior in class [OK]

Hint: Store data in __init__, use methods for behavior [OK]

Common Mistakes:

• Not using self for instance variables
• Returning values from __init__
• Defining methods without self parameter