Procedural vs object-oriented approach in Python - Practice Questions

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of procedural code for area calculation

What is the output of this procedural Python code that calculates the area of a rectangle?

Python

def area(length, width):
    return length * width

result = area(5, 3)
print(result)

A TypeError

B 8

C 53

D 15

💡 Hint

Multiply length by width to get the area.

The function multiplies 5 by 3, resulting in 15.

❓ Predict Output

intermediate

Output of object-oriented code for area calculation

What is the output of this object-oriented Python code that calculates the area of a rectangle?

Python

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

rect = Rectangle(5, 3)
print(rect.area())

A 15

B TypeError

C 8

D None

💡 Hint

The method area multiplies length and width stored in the object.

The Rectangle object stores 5 and 3, and area() returns 15.

🧠 Conceptual

advanced

Difference in data handling between procedural and OOP

Which statement best describes how data is handled differently in procedural vs object-oriented programming?

A Procedural programming groups data and functions together; OOP separates them.

B Procedural programming uses objects to store data; OOP uses global variables.

C OOP groups data and functions together inside objects; procedural programming keeps them separate.

D OOP does not use functions; procedural programming only uses functions.

💡 Hint

Think about where data and behavior live in each approach.

OOP bundles data and related functions inside objects, while procedural programming keeps data and functions separate.

❓ Predict Output

advanced

Output of mixed procedural and OOP code

What is the output of this code mixing procedural and object-oriented styles?

Python

class Counter:
    def __init__(self):
        self.count = 0
    def increment(self):
        self.count += 1

def increment_counter(counter):
    counter.increment()
    return counter.count

c = Counter()
print(increment_counter(c))
print(c.count)

A TypeError

B

1
1

C

0
1

D

1
0

💡 Hint

The function calls the object's method to increase count.

increment_counter calls increment(), increasing count to 1, then returns 1. The object's count is also 1.

🧠 Conceptual

expert

Advantages of object-oriented approach over procedural

Which of the following is the main advantage of using object-oriented programming over procedural programming?

A It allows bundling data and behavior, making code easier to manage and reuse.

B It requires fewer lines of code for all programs.

C It always runs faster than procedural code.

D It eliminates the need for functions.

💡 Hint

Think about how OOP helps organize code.

OOP bundles data and related functions inside objects, improving code organization and reuse.

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