OOP Fundamentals

OOP Fundamentals Quiz

Quiz

Question 1 of 27 (0 answered)

Question 1

What is the primary purpose of the __init__ method in a Python class?

To create a new instance of the class in memory To initialize instance attributes when an object is created To define the string representation of the class To allocate memory for the class definition

✓

Correct!

__init__ is the initializer that runs automatically when an object is created. Its job is to set up the initial state by assigning instance attributes via self. Memory allocation is handled by __new__, which runs before __init__.

✗

Incorrect

Think about what happens immediately after Person("Alice", 30) is called.

Question 2

A class attribute defined outside __init__ is shared across all instances, while an instance attribute set via self.attr = value inside __init__ is unique to each object.

True False

✓

Correct!

Class attributes live on the class itself and are shared by all instances. Instance attributes are stored on each individual object. This distinction becomes critical with mutable class attributes (like lists), where one instance mutating the shared object affects all others.

✗

Incorrect

Consider where species = 'Homo sapiens' vs. self.name = name each live.

Question 3

A method decorated with @classmethod receives _____ as its first parameter instead of self, giving it access to the class rather than an instance.

✓

Correct!

Class methods use cls as the first parameter to refer to the class itself. This allows them to access class attributes and create instances via cls(...), making them ideal for alternative constructors.

✗

Incorrect

It’s a common abbreviation for ‘class’.

Question 4

Predict the output:

class Dog:
    tricks = []

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

d1 = Dog()
d2 = Dog()
d1.add_trick("roll over")
print(len(d2.tricks))

What will this code output?

0 1 AttributeError 2

✓

Correct!

tricks is a class attribute — a single list shared by all instances. When d1.add_trick() calls self.tricks.append(), it mutates the shared class-level list (it does not reassign self.tricks). So d2.tricks reflects the same mutation, and its length is 1. The fix is to move self.tricks = [] inside __init__.

✗

Incorrect

Does self.tricks.append() create a new list or mutate an existing one?

Question 5

Which is the most appropriate use case for @classmethod?

To implement utility functions that don’t need instance or class state To create alternative constructors that return a new instance of the class To override a parent class method in a subclass To validate input data before passing it to __init__

✓

Correct!

@classmethod receives the class as cls, making it ideal for alternative constructors like Person.from_birth_year('Alice', 1990). Utility functions that need neither instance nor class state are better served by @staticmethod. Method overriding doesn’t require any decorator.

✗

Incorrect

Look at how from_birth_year is used in the notes.

Question 6

Which of the following statements about @staticmethod are true? (Select all that apply)

Static methods do not receive self or cls as a first parameter Static methods can directly access instance attributes Static methods can be called on both the class and an instance Static methods are useful for utility functions logically grouped with a class Static methods automatically have access to class attributes

✓

Correct!

Static methods have no implicit first parameter, so they cannot access instance or class attributes directly. They can be called via ClassName.method() or instance.method(). They are perfect for utility/helper functions that belong conceptually to a class but don’t need its state.

✗

Incorrect

Think about what @staticmethod removes compared to a regular or class method.

Question 7

In Python, super() always refers exclusively to the direct parent class.

True False

✓

Correct!

super() follows the Method Resolution Order (MRO), not just the immediate parent. In multiple inheritance, super() calls the next class in the MRO chain (computed via C3 linearization), which may not be the direct parent. This cooperative design is essential for diamond inheritance to work correctly.

✗

Incorrect

Consider what happens in a diamond inheritance pattern: class D(B, C) where both B and C inherit from A.

Question 8

Predict the output:

class A:
    def method(self):
        return "A"

class B(A):
    def method(self):
        return "B"

class C(A):
    def method(self):
        return "C"

class D(B, C):
    pass

d = D()
print(d.method())

What will this code output?

"A" "B" "C" "D"

✓

Correct!

Python’s MRO for D is [D, B, C, A, object] (C3 linearization). When d.method() is called, Python searches left to right: D has no method, B has one — it returns "B". C and A are never reached. You can verify with print(D.mro()).

✗

Incorrect

Python checks classes left to right following the MRO. What is the MRO for D(B, C)?

Question 9

Which dunder methods does @dataclass generate by default (without extra arguments)? (Select all that apply)

__init__ __str__ __repr__ __eq__ __lt__

✓

Correct!

@dataclass generates __init__, __repr__, and __eq__ by default. __str__ is NOT generated — Python falls back to __repr__ when printing. Comparison ordering methods like __lt__ require @dataclass(order=True).

✗

Incorrect

The default gives you construction, representation, and equality. Ordering is opt-in.

Question 10

Complete the decorator to define a property setter:

Fill in the property name used in the setter decorator

class Temperature:
    @property
    def celsius(self):
        return self._celsius

    @_____.setter
    def celsius(self, value):
        if value < -273.15:
            raise ValueError("Below absolute zero!")
        self._celsius = value

Your answer:

✓

Correct!

The setter decorator must reference the property by name: @celsius.setter. This links the setter to the celsius property defined above it. The method name must also match. Using a different name creates an unlinked setter that Python won’t connect to the property.

✗

Incorrect

Question 11

What happens when you try to assign a value to a @property that has no setter defined?

The value is silently ignored Python creates a new regular instance attribute with the same name, shadowing the property An AttributeError is raised A TypeError is raised

✓

Correct!

Attempting to set a read-only property (one with no setter) raises AttributeError: can't set attribute. This is the intended behavior — it enforces read-only access. To make it writable, you must explicitly define a @property_name.setter.

✗

Incorrect

Read-only means writing should be blocked with an error, not silently accepted.

Question 12

A double-underscore attribute like self.__secret in class MyClass is truly private and cannot be accessed from outside the class.

True False

✓

Correct!

Python applies name mangling — self.__secret in MyClass is stored as _MyClass__secret. This prevents accidental collisions in subclasses but does NOT enforce true privacy. You can still access it from outside as obj._MyClass__secret. Python’s philosophy is ‘consenting adults’: naming conventions communicate intent, but there are no hard access restrictions.

✗

Incorrect

Python doesn’t have true access modifiers like Java’s private. What mechanism does it use instead?

Question 13

To make a dataclass immutable so that attribute modification after creation raises a FrozenInstanceError, pass _____=True to the @dataclass decorator.

✓

Correct!

@dataclass(frozen=True) prevents any attribute assignment after the object is created, making the instance behave like a named tuple. Frozen dataclasses are also hashable by default, allowing them to be used as dictionary keys or set members.

✗

Incorrect

Think of what word describes an immutable/locked state.

Question 14

What is the minimum dunder method you need to implement to make instances of a class sortable with the built-in sorted()?

__eq__ __lt__ __gt__ __hash__

✓

Correct!

sorted() uses __lt__ (less than) as the default comparison operator. While __eq__ is useful for equality checks, it’s not required for sorting. __hash__ is for set/dict membership. You can also use functools.total_ordering to fill in all comparison methods from just __eq__ and one other.

✗

Incorrect

Sorting fundamentally relies on determining which item comes ‘before’ another.

Question 15

What is the key distinction between __str__ and __repr__?

__str__ is for large objects; __repr__ is for small, simple ones __str__ provides a human-readable string (used by print()); __repr__ provides an unambiguous developer-oriented representation for debugging __repr__ is called when an object is garbage collected __str__ is faster than __repr__ because it skips type information

✓

Correct!

__str__ is the ‘pretty’ representation for end users — called by print() and str(). __repr__ is for developers and debugging — called in the REPL, by repr(), and as a fallback when __str__ is absent. A good __repr__ ideally returns a string that could recreate the object: Person('Alice', 30).

✗

Incorrect

One is for users, one is for developers.

Question 16

Predict the output:

class Counter:
    count = 0

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

    @classmethod
    def get_count(cls):
        return cls.count

a = Counter()
b = Counter()
c = Counter()
print(Counter.get_count())

What will this code output?

0 1 3 Error

✓

Correct!

Each Counter() call triggers __init__, which increments the class attribute Counter.count. After three instantiations, count is 3. get_count() returns cls.count, which is 3. Note: using Counter.count += 1 (not self.count += 1) correctly modifies the class attribute rather than creating a shadowing instance attribute.

✗

Incorrect

How many times is Counter() called, and where does count live?

Question 17

Given class D(B, C) where class B(A) and class C(A), arrange the Method Resolution Order (MRO) for class D from first searched to last searched:

Drag to arrange from first to last in Python’s MRO

⋮⋮ A

⋮⋮ object

⋮⋮ C

⋮⋮ D

⋮⋮ B

✓

Correct!

Python’s C3 linearization produces the MRO: [D, B, C, A, object]. Python searches left to right, checking each class for the requested attribute. D itself is checked first, then its leftmost parent B, then C, then their shared ancestor A, and finally the base object. This prevents A’s methods from being found before C’s in a diamond pattern.

✗

Incorrect

Question 18

What is polymorphism in OOP, and how does Python implement it?

The ability for different objects to respond to the same interface (method call) in their own type-specific way.

Python uses duck typing: if an object has the right method, it works — regardless of its type. Example: shape.area() works on both Rectangle and Circle because each defines its own area() implementation. You don’t need explicit interfaces or type checks.

Did you get it right?

✓

Correct!

✗

Incorrect

Question 19

What is name mangling in Python, and what problem does it solve?

Name mangling transforms __attr (double underscore prefix) into _ClassName__attr at compile time.

Problem it solves: prevents accidental attribute name collisions in subclasses. If Parent uses self.__data and Child also defines self.__data, they don’t clash — they become _Parent__data and _Child__data respectively.

Important: this is NOT true privacy. The attribute is still accessible as obj._ClassName__attr from outside.

Did you get it right?

✓

Correct!

✗

Incorrect

Question 20

In a dataclass, __post_init__ is called after all fields have been initialized by the generated __init__, allowing you to perform validation or compute derived attributes.

True False

✓

Correct!

The generated __init__ assigns all declared fields first, then automatically calls __post_init__ if it’s defined. This is the correct place for cross-field validation or initializing fields that depend on other fields (like setting count = len(self.items) in an Inventory dataclass).

✗

Incorrect

The name itself is a clue — it runs post (after) __init__.

Question 21

Predict the output:

class Employee:
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary

class Manager(Employee):
    def __init__(self, name, salary, department):
        super().__init__(name, salary)
        self.department = department

mgr = Manager("Alice", 100000, "Engineering")
print(hasattr(mgr, "salary"))

What will this code output?

True False AttributeError None

✓

Correct!

super().__init__(name, salary) calls Employee.__init__, which sets self.salary = salary on the mgr instance. So mgr.salary exists. hasattr(mgr, 'salary') returns True. This demonstrates why calling super().__init__() is essential — skipping it means the parent’s attributes are never set.

✗

Incorrect

Does super().__init__() actually run Employee.__init__ on the mgr instance?

Question 22

In a dataclass, why must you use field(default_factory=list) instead of items: list = [] for list fields?

Because dataclasses don’t support list type annotations directly To avoid sharing the same list object across all instances (the mutable default argument problem) Because field() is significantly faster at runtime than a plain default To enable the frozen=True feature for the field

✓

Correct!

Using items: list = [] would make all instances share the same list object — a classic Python gotcha. field(default_factory=list) calls list() fresh for each new instance, giving every object its own independent list. This same issue applies to any mutable default (dicts, sets, custom objects).

✗

Incorrect

This is the same reason you should never use mutable defaults in function signatures.

Question 23

Predict the output:

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

    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

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

v1 = Vector(1, 2)
v2 = Vector(3, 4)
print(v1 + v2)

What will this code output?

Vector(1, 2) Vector(3, 4) Vector(4, 6) TypeError: unsupported operand type(s) for +

✓

Correct!

v1 + v2 is syntactic sugar for v1.__add__(v2). Python translates arithmetic operators to dunder method calls. __add__ receives other = v2 and returns a new Vector(1+3, 2+4) = Vector(4, 6). Without __add__, the + operator would raise a TypeError.

✗

Incorrect

Python translates a + b into a method call. Which method?

Question 24

A Playlist class needs to support len(playlist), playlist[0], and "Song" in playlist. Which dunder methods must it implement? (Select all that apply)

__len__ __iter__ __getitem__ __contains__ __setitem__

✓

Correct!

len() calls __len__. Index access obj[i] calls __getitem__. The in operator calls __contains__. __iter__ enables for item in obj iteration (not needed here). __setitem__ handles assignment obj[i] = value (also not needed here). Each built-in operation maps to a specific dunder method.

✗

Incorrect

Map each operation to its corresponding dunder: len(), [], and in.

Question 25

What does a single leading underscore (e.g., self._balance) conventionally signal in Python?

The attribute is private and Python will block external access The attribute is intended for internal use only — a convention, not enforcement Python applies name mangling, renaming it to _ClassName_balance The attribute is excluded from __repr__ and __str__ output

✓

Correct!

A single underscore is a convention — it signals “internal use, proceed with caution” to other developers. Python does not enforce it; obj._balance is perfectly accessible from outside. Name mangling (renaming) only applies to double underscores (__). This reflects Python’s philosophy: trust developers to respect conventions rather than enforce hard access restrictions.

✗

Incorrect

Compare: one underscore = convention, two underscores = name mangling.

Question 26

Predict the output:

class ManagedResource:
    def __enter__(self):
        print("Acquired")
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("Released")
        return False

with ManagedResource() as r:
    print("Using")

What will this code output?

Acquired
Using
Released

Using
Acquired
Released

Acquired
Released
Using

Using
Released

✓

Correct!

with executes __enter__ first (prints “Acquired”), then runs the block body (prints “Using”), then always calls __exit__ on exit (prints “Released”) — whether the block succeeded or raised an exception. This guaranteed cleanup is the entire point of the context manager protocol.

✗

Incorrect

Think about the sequence: set up → use → tear down.

Question 27

If __exit__ returns True, any exception that occurred inside the with block is suppressed and execution continues normally after the with statement.

True False

✓

Correct!

The return value of __exit__ controls exception propagation. True = suppress the exception (swallow it). False or None = re-raise it. This is why most context managers return False — they want to clean up resources but not silently hide errors. Returning True is intentional only when the class is designed to handle specific exceptions.

✗

Incorrect

What would make a context manager dangerous if it always returned True?

Quiz Results

Score

0/0

Accuracy

Right

Wrong

Skipped

Last updated on March 7, 2026

Error Handling Standard Library