Quiz: Object-Oriented Programming — Thinking in Objects

Test your understanding before moving on. Target: 70% or higher to proceed confidently.

Section 1: Multiple Choice (1 point each)

1. What is the relationship between a class and an object?

• A) A class is a variable; an object is a value
• B) A class is a blueprint; an object is an instance created from that blueprint
• C) A class is a function; an object is the return value
• D) A class and an object are the same thing

2. What does the __init__ method do?

• A) Destroys an object when it's no longer needed
• B) Initializes a new object's state when it's created
• C) Imports the class from a module
• D) Converts an object to a string

3. What does self refer to in a method?

• A) The class itself
• B) The current module
• C) The specific object the method is being called on
• D) The parent class

4. What happens when you run this code?

class Cat:
    lives = 9

    def __init__(self, name):
        self.name = name

whiskers = Cat("Whiskers")
mittens = Cat("Mittens")
print(whiskers.lives, mittens.lives)

• A) Error — lives is not defined
• B) 9 9
• C) None None
• D) 0 0

5. What is the output of this code?

class Dog:
    tricks = []

    def __init__(self, name):
        self.name = name

    def learn(self, trick):
        self.tricks.append(trick)

rex = Dog("Rex")
bella = Dog("Bella")
rex.learn("sit")
bella.learn("shake")
print(bella.tricks)

• A) ['shake']
• B) ['sit', 'shake']
• C) []
• D) Error

6. What is the purpose of __str__?

• A) To create a new string object
• B) To define how the object is displayed when printed or converted to a string
• C) To compare the object to a string
• D) To initialize the object's string attributes

7. What does the @property decorator do?

• A) Makes an attribute immutable
• B) Makes a method accessible like an attribute, with optional validation
• C) Makes an attribute private
• D) Creates a class attribute

8. What naming convention signals "this attribute is internal, don't access it from outside"?

• A) self.ATTRIBUTE
• B) self.attribute_
• C) self._attribute
• D) self.attribute__

9. What is name mangling in Python?

• A) Renaming a variable to avoid a syntax error
• B) Python automatically renames __attr to _ClassName__attr to discourage external access
• C) Converting variable names from camelCase to snake_case
• D) Obfuscating code to prevent reverse engineering

10. When should you prefer a procedural approach over OOP?

• A) When you have multiple related pieces of data that change together
• B) When you're writing utility functions or stateless data transformations
• C) When you need multiple instances of the same concept
• D) When state changes over time

Section 2: Code Reading (2 points each)

11. What is the output of this code?

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        return f"({self.x}, {self.y})"

    def __eq__(self, other):
        return self.x == other.x and self.y == other.y

p1 = Point(3, 4)
p2 = Point(3, 4)
p3 = p1
print(p1 == p2)
print(p1 is p2)
print(p1 is p3)

True
False
True

12. What is the output of this code?

class Tracker:
    count = 0

    def __init__(self, label):
        self.label = label
        Tracker.count += 1

    def __str__(self):
        return f"{self.label} (#{Tracker.count})"

a = Tracker("Alpha")
b = Tracker("Beta")
c = Tracker("Gamma")
print(a)
print(Tracker.count)

Alpha (#3)
3

13. What error does this code produce and why?

class Circle:
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14159 * self.radius ** 2

    def bigger_than(other):
        return self.area() > other.area()

c1 = Circle(5)
c2 = Circle(3)
c1.bigger_than(c2)

TypeError: Circle.bigger_than() takes 1 positional argument but 2 were given

14. What is the output of this code?

class Inventory:
    def __init__(self):
        self._items = {}

    def add(self, item, quantity=1):
        self._items[item] = self._items.get(item, 0) + quantity

    def __len__(self):
        return sum(self._items.values())

    def __str__(self):
        parts = [f"{item}: {qty}" for item, qty in self._items.items()]
        return "Inventory(" + ", ".join(parts) + ")"

inv = Inventory()
inv.add("sword")
inv.add("potion", 3)
inv.add("potion", 2)
print(inv)
print(f"Total items: {len(inv)}")

Inventory(sword: 1, potion: 5)
Total items: 6

Section 3: Short Answer (2 points each)

15. A student writes this class and is confused by the output. Explain the bug and provide the fix.

class Team:
    members = []

    def __init__(self, name):
        self.name = name

    def add_member(self, person):
        self.members.append(person)

red = Team("Red")
blue = Team("Blue")
red.add_member("Alice")
blue.add_member("Bob")
print(f"Red: {red.members}")   # Expected: ['Alice']
print(f"Blue: {blue.members}") # Expected: ['Bob']
# Actual: both show ['Alice', 'Bob']

class Team:
    def __init__(self, name):
        self.name = name
        self.members = []  # Each team gets its own list

16. Explain why the following __eq__ method is incomplete:

def __eq__(self, other):
    return self.name == other.name

What problem could arise, and how should it be fixed?

def __eq__(self, other):
    if not isinstance(other, Student):
        return NotImplemented
    return self.name == other.name

17. What is the difference between __str__ and __repr__? Write both for a Color class that stores r, g, b values.

class Color:
    def __init__(self, r, g, b):
        self.r = r
        self.g = g
        self.b = b

    def __str__(self):
        return f"rgb({self.r}, {self.g}, {self.b})"

    def __repr__(self):
        return f"Color({self.r}, {self.g}, {self.b})"

Section 4: Design Questions (3 points each)

18. You're building a library management system. List the attributes and methods you would give a Book class and a Library class. Include at least 4 attributes and 4 methods for each.

19. A colleague writes a single GameManager class with 40 methods that handles player movement, combat, inventory, saving/loading, rendering, and sound. What OOP principle are they violating, and how would you refactor it?

20. Consider this scenario: you need to process a list of student records (name, grades, major) to calculate class averages and produce a summary report. Would you use OOP, a procedural approach, or a mix? Justify your answer by listing the pros and cons for this specific problem.

class Student:
    # ... attributes and methods per student

def calculate_class_average(students):
    # standalone function — no state to maintain
    return sum(s.gpa for s in students) / len(students)

def generate_report(students, output_path):
    # standalone function — input-to-output transformation
    ...