PCPP1 Practice Test 13 — 15 Questions

Question 1

You are implementing a class that represents a monetary amount. You want the expression amount1 + amount2 to return a new Money instance, and you also want amount1 + 5 to work by treating 5 as a Money with zero cents. However, 5 + amount1 should raise a TypeError. Which implementation achieves this behavior?

Choose an answer to begin — your selection is scored in the full session.

Accepted Answer

Define only __add__(self, other) to handle Money and int, and do not define __radd__.. For amount1 + amount2 and amount1 + 5, Python calls Money.__add__, which can handle both Money and int. For 5 + amount1, int.__add__ returns NotImplemented, and Python then looks for Money.__radd__. Since __radd__ is not defined, a TypeError is raised. This precisely implements the asymmetric addition behavior required.

Answer

Define __add__(self, other) and __radd__(self, other) where __radd__ simply calls self.__add__(other).

Answer

Define __iadd__(self, other) to handle both Money and int, and rely on Python to fall back to __add__ for the + operator.

Answer

Define __add__(self, other) to handle both Money and int, and define __radd__ to raise TypeError.

Question 2

You are designing a plugin system where each plugin class must automatically register itself with a central registry when defined, without requiring an explicit decorator or registration call. You decide to use the __init_subclass__ hook in the base Plugin class. Which statement correctly describes how to implement this so that every subclass is registered with its own class object?

Accepted Answer

Define __init_subclass__ as a classmethod in the base class that receives the new subclass as its first argument and adds it to a registry list.. The __init_subclass__ hook is invoked automatically on the parent class whenever a subclass is defined, receiving the new subclass as an argument. Implementing it as a classmethod in the base Plugin class allows the base to append each subclass to a shared registry at definition time, satisfying the automatic registration requirement without decorators or manual calls.

Answer

Define __init_subclass__ as an instance method in the base class that receives self and uses type(self) to identify the subclass.

Answer

Override __new__ in the base class to intercept subclass creation and register the subclass there.

Answer

Use a metaclass with a __call__ method that registers the class when the first instance is created.

Question 3

You are designing a class `Matrix` that supports element-wise addition and scalar multiplication. You want `m1 + m2` to return a new `Matrix` without modifying `m1` or `m2`. You have implemented `__add__` correctly. A colleague writes `m1 += m2` and expects `m1` to be rebound to a new `Matrix` object. However, after the statement, `m1` still refers to the same object and its internal data has been modified in place. Which change to your class is the most likely cause of this behavior?

Accepted Answer

You defined `__iadd__` to call `__add__` and then return `self` after updating the internal list in place.. The augmented assignment `+=` first looks for `__iadd__` on the left operand. When `__iadd__` is defined and mutates the object before returning `self`, the name is rebound to the same object and the original data changes. Without `__iadd__`, Python falls back to `__add__`, which produces a new object and rebinds the name.

Answer

You defined `__iadd__` to return a new `Matrix` instance without modifying `self`.

Answer

You defined `__radd__` to return a new `Matrix` instance instead of `NotImplemented`.

Answer

You defined `__add__` to modify `self` in place and return `self`.

Question 4

You are implementing a class `Vector` that supports addition and scalar multiplication. You want `v1 + v2` to return a new `Vector`, and `v1 * 3` to return a new scaled `Vector`. You also want `3 * v1` to work identically. Which pair of methods must you implement to support both `v1 * 3` and `3 * v1` correctly, assuming `v1` is a `Vector` and `3` is an `int`?

Accepted Answer

`__mul__` and `__rmul__`. To support both `v1 * 3` and `3 * v1`, the class must define `__mul__` for the normal case and `__rmul__` for the reflected case. When the left operand's `__mul__` returns `NotImplemented`, Python tries the right operand's `__rmul__`. Implementing both ensures consistent behavior regardless of operand order, which is important for intuitive mathematical types.

Answer

`__rmul__` and `__radd__`

Answer

`__mul__` only, because Python automatically swaps operands.

Answer

`__mul__` and `__imul__`

Question 5

You are designing a plugin registry that must automatically register every concrete subclass of a base class `Plugin` at the moment the subclass is defined, without requiring any explicit registration call in the subclass body. You want to avoid a metaclass because the project already uses `ABCMeta` for the base class and you do not want to introduce metaclass conflicts. Which approach best satisfies this requirement?

Accepted Answer

Define `__init_subclass__` as a classmethod on `Plugin` that appends the newly created class to a registry list.. The implicit `__init_subclass__` classmethod is executed by Python on the parent class right after a subclass is created, so it provides exactly the definition-time hook the registry needs. It is a plain method, so it coexists with `ABCMeta` and other metaclasses without conflict. Hooks tied to instantiation or descriptor binding run at the wrong moment and cannot reliably capture every concrete or abstract subclass.

Answer

Use `__subclasses__()` on `Plugin` inside a periodic background thread and append any newly discovered subclasses to the registry.

Answer

Override `__set_name__` on `Plugin` so that each subclass reports its name to the registry when the class body finishes executing.

Answer

Define `__new__` on `Plugin` and insert the class into the registry whenever `Plugin` itself is instantiated.

Question 6

A team is reviewing a module where a helper function `_normalize_path` is prefixed with a single underscore. A new developer asks which statement best describes the intent of that naming choice according to common Python conventions.

Accepted Answer

The single underscore signals that the function is intended for internal use and is not part of the module's public API.. A leading single underscore is a convention that marks a name as internal, signaling that it is not part of the public API and may change without notice. It provides no runtime enforcement, so callers can still use it, but doing so is discouraged. This convention helps communicate intent in `_normalize_path` without altering behavior.

Answer

The single underscore marks the function as deprecated and scheduled for removal in a future release.

Answer

The single underscore makes the function inaccessible from outside the module at runtime.

Answer

The single underscore indicates that the function is a special method recognized by the Python interpreter.

Question 7

A developer is adding a new public function `calculate_discount` to an existing Python module. The module currently uses four spaces per indentation level, and the function spans several nested `if` blocks. Which PEP 8 indentation practice should the developer follow?

Accepted Answer

Use four spaces per indentation level throughout the function and avoid mixing tabs with spaces.. PEP 8 recommends four spaces per indentation level and spaces over tabs. Because the existing module already uses four spaces, the new function should match that convention to keep the file internally consistent and avoid tab/space mixing, which Python 3 can reject with `TabError`. Consistency within a module matters more than personal preference.

Answer

Use one tab per indentation level because tabs render consistently in every IDE.

Answer

Use two spaces per indentation level to keep deeply nested blocks from drifting too far right.

Answer

Use a mix of tabs for the outer blocks and spaces for the inner blocks to visually separate nesting levels.

Question 8

You are designing a Python class that manages a database connection. The class has a method `_execute_query` that should only be used internally. According to Python best practices and PEP 8, how should you indicate that this method is for internal use only?

Accepted Answer

Prefix the method name with a single underscore: `_execute_query`.. PEP 8 specifies that a single leading underscore should be used to indicate that an attribute or method is intended for internal use. This is a widely recognized convention in Python. Double underscores are for name mangling, comments are not a convention, and there is no standard `@internal` decorator.

Answer

Prefix the method name with two underscores: `__execute_query`.

Answer

Use the `@internal` decorator from the `typing` module.

Answer

Add a comment above the method: `# Internal use only`.

Question 9

You are implementing a class `Matrix` that supports the `+` operator for matrix addition. You want `m1 + m2` to return a new `Matrix`, and you also want `sum([m1, m2, m3])` to work correctly. You define `__add__` to return a new `Matrix`. However, `sum([m1, m2, m3])` raises a `TypeError`. What is the most likely reason?

Accepted Answer

`sum()` starts with `0` as the initial value, and `0 + m1` fails because `int.__add__` returns `NotImplemented` and `Matrix` lacks `__radd__`.. `sum()` starts with `0` and adds each item. The first addition is `0 + m1`, which fails because `int.__add__` returns `NotImplemented` and `Matrix` does not define `__radd__`. To support `sum()`, you must implement `__radd__` to handle the initial `0` and any other non-Matrix left operand. This makes the class compatible with the built-in `sum()` function.

Answer

`sum()` calls `__add__` on the first element, but `Matrix.__add__` expects another `Matrix`, and `0` is not a `Matrix`.

Answer

`sum()` requires the `__iadd__` method for in-place addition.

Answer

`sum()` requires all elements to be of the same type, and `0` is an `int`.

Question 10

You are using the sqlite3 module to insert a large number of rows into a table. You want to maximize performance by reducing the number of disk writes. Which approach is most effective?

Accepted Answer

Use a single transaction by executing BEGIN, then many INSERTs, then COMMIT.. Batching many INSERTs into a single transaction minimizes disk I/O and is the most effective way to speed up bulk inserts in sqlite3. Autocommit or frequent commits increase overhead. Using a single cursor also helps, but the transaction grouping is the key factor.

Answer

Set connection.isolation_level = None and execute each INSERT individually.

Answer

Set the connection's isolation_level to 'DEFERRED' and commit after every insert.

Answer

Create a new cursor for each INSERT statement.

Question 11

You maintain a Tkinter inventory dashboard whose main window contains a large frame with a Treeview listing warehouse items. Operators complain that when they maximize the window, the Treeview stays at its original size and leaves a large empty gray area. The frame is already managed with grid() and the Treeview is placed inside that frame with pack(). Which single change most directly makes the Treeview grow with the frame when the window is resized?

Accepted Answer

Call tree.pack(fill='both', expand=True) and configure the frame's row and column weights with frame.grid_rowconfigure(0, weight=1) and frame.grid_columnconfigure(0, weight=1).. A Treeview that must follow its parent needs two cooperating mechanisms: the geometry manager inside the frame must allow expansion, and the frame must be told to give surplus space to the cell containing the Treeview. Combining pack(fill='both', expand=True) with weighted grid rows and columns satisfies both conditions, which is why this is the canonical Tkinter pattern for resizable data tables.

Answer

Call tree.config(width=200, height=50) so the Treeview requests a larger size whenever the window is maximized.

Answer

Replace pack() with place() and use relwidth=1, relheight=1 so the Treeview always occupies the whole frame.

Answer

Set the frame's propagate(False) method and assign explicit pixel dimensions to the Treeview's width and height attributes.

Question 12

You are building a Tkinter GUI that includes a Canvas widget. You want to draw a rectangle and then later change its fill color without redrawing the entire canvas. Which method should you use to update the rectangle's fill color?

Accepted Answer

canvas.itemconfig(rectangle_id, fill='blue'). Canvas items are managed by the Canvas widget and are referenced by integer IDs. To change an item's options after creation, you use canvas.itemconfig with the item ID and the new option values. Recreating the item adds a new one, configuring the canvas itself does not affect items, and items are not Python objects with methods. Thus, itemconfig is the correct method.

Answer

rectangle.fill('blue')

Answer

canvas.create_rectangle(..., fill='blue')

Answer

canvas.config(fill='blue')

Question 13

You are writing a Tkinter dialog that must react to a user pressing the Escape key at any time, even when focus is inside an Entry widget. You have a function named on_cancel. Which binding correctly achieves this?

Accepted Answer

root.bind_all('<Escape>', on_cancel). A global cancel shortcut must be registered at the application level. bind_all places the handler in the application-wide binding table so it triggers no matter which widget has focus. Widget-level and class-level bindings are scoped to specific widgets or widget classes and therefore miss events when focus is elsewhere, which is why they cannot satisfy the scenario.

Answer

root.bind_class('Entry', '<Escape>', on_cancel)

Answer

entry.bind('<Escape>', on_cancel)

Answer

root.bind('<Escape>', on_cancel, add='+')

Question 14

You are developing a Python application that uses a third-party library. You need to ensure that your code handles exceptions raised by that library in a way that is both robust and follows best practices. The library raises a custom exception named LibraryError, which is a subclass of Exception. Your function calls a method that may raise LibraryError. Which of the following is the best approach to handle this exception?

Accepted Answer

try:
    result = library.method()
except LibraryError as e:
    logger.error("Library method failed: %s", e)
    raise. The best practice is to catch the specific exception, log it with context, and re-raise it to allow higher-level handlers to decide how to proceed. This preserves the traceback and ensures that the error is not silently ignored. Catching only LibraryError avoids masking unrelated issues, and using a logger instead of print provides proper production-grade logging.

Answer

try:
    result = library.method()
except LibraryError:
    print("An error occurred")

Answer

try:
    result = library.method()
except Exception:
    pass

Answer

try:
    result = library.method()
except BaseException as e:
    logger.error("Error: %s", e)

Question 15

You are writing a Python module that includes a function to compute the factorial of a number. You want to document the function using a docstring that is compatible with the Google Python Style Guide. Which of the following docstrings correctly follows the Google style for documenting parameters and return values, including types?

Accepted Answer

"""Compute the factorial of a number.

Args:
    n (int): The number to compute the factorial for.

Returns:
    int: The factorial of n.

Raises:
    ValueError: If n is negative.
""". The Google Python Style Guide specifies that docstrings should have sections like Args, Returns, and Raises, with parameter types in parentheses after the parameter name. The correct docstring follows this exactly, making it both human-readable and machine-parsable by tools like Sphinx with the napoleon extension. This consistency is key for maintainable documentation.

Answer

"""Compute the factorial of a number.

Arguments:
    n: int, the number to compute the factorial for.

Returns:
    int, the factorial of n.

Raises:
    ValueError, if n is negative.
"""

Answer

"""Compute the factorial of a number.

:param n: The number to compute the factorial for.
:type n: int
:return: The factorial of n.
:rtype: int
:raises ValueError: If n is negative.
"""

Answer

"""Compute the factorial of a number.

@param n: The number to compute the factorial for.
@return: The factorial of n.
@raises ValueError: If n is negative.
"""