PCPP1 Practice Test 12 — 15 Questions

Question 1

When designing a class hierarchy, what is the best way to prevent a method from being overridden by subclasses?

Accepted Answer

Using the @final decorator from typing.. The @final decorator from the typing module (PEP 591) is the standard, type-checker-enforced way to mark a method as non-overridable in Python. When applied to a method, static type checkers like mypy or Pyright will flag any subclass that attempts to override it, and applying @final to a class prevents subclassing entirely. Python itself does not enforce this at runtime, but the decorator is the idiomatic, documented mechanism for expressing the intent.

Answer

Defining it as a private method.

Answer

Defining it as a static method.

Answer

Using the 'final' keyword.

Question 2

When implementing the Singleton pattern, what is the advantage of using a module-level instance over a class-based Singleton?

Accepted Answer

It is simpler and leverages Python's built-in module caching mechanism.. Python modules are naturally Singletons because they are initialized only once upon the first import.

Answer

It is more secure.

Answer

It allows multiple instances if needed.

Answer

It supports lazy loading.

Question 3

What happens when you add two objects of a class that implements __add__?

Accepted Answer

The __add__ method is called.. The __add__ method is automatically called by the interpreter when the '+' operator is used.

Answer

It does nothing.

Answer

It concatenates the objects.

Answer

It raises a TypeError.

Question 4

How do you access the value of a StringVar associated with an Entry widget?

Accepted Answer

var.get(). The get() method is used on the StringVar object to retrieve its current value.

Answer

var.retrieve()

Answer

var.content()

Answer

var.value

Question 5

Which TWO of the following are commonly used for debugging REST API integrations?

Accepted Answer

Using a proxy tool to inspect traffic. Option D is correct because a proxy tool (e.g., Charles Proxy, Fiddler, or mitmproxy) acts as an intercepting man-in-the-middle that captures and displays the actual HTTP/HTTPS requests and responses, letting you inspect methods, URLs, status codes, and payloads for REST debugging. Option E is correct because logging request and response headers (e.g., Content-Type, Authorization, Accept, and custom headers) reveals exactly what the client sent and what the server returned, which is essential for diagnosing issues like missing auth tokens, wrong content negotiation, or unexpected status codes. The remaining options do not belong: hardcoding all credentials (A) is a security anti-pattern that exposes secrets and does nothing to aid debugging, deleting the socket library (B) would break networking entirely, and increasing the CPU clock speed (C) is a hardware performance tweak unrelated to inspecting or troubleshooting API traffic.

Answer

Hardcoding all credentials

Answer

Deleting the socket library

Answer

Increasing the CPU clock speed

Question 6

What is the purpose of the 'type' function when called with three arguments?

Accepted Answer

To create a new class dynamically.. It is used for dynamic class creation: type(name, bases, dict).

Answer

To register a class.

Answer

To inherit from multiple classes.

Answer

To check object type.

Question 7

When using the grid layout manager, which option allows a column to grow when the window is resized?

Accepted Answer

root.columnconfigure(0, weight=1). The columnconfigure() method is used to set the weight of a column, allowing it to expand.

Answer

root.grid_grow(column=0, weight=1)

Answer

root.grid_column(0, resizable=True)

Answer

root.set_grid(0, expand=True)

Question 8

You are logging events with custom levels. How do you add a custom level 'TRACE' (value 5) to the logging module?

Accepted Answer

logging.addLevelName(5, 'TRACE'). You use logging.addLevelName() to associate a numerical value with a level name.

Answer

logging.TRACE = 5

Answer

logging.setLevel('TRACE', 5)

Answer

logging.define_level('TRACE', 5)

Question 9

In the context of writing robust error handling, what is the 'EAFP' principle?

Accepted Answer

Easier to Ask for Forgiveness than Permission.. EAFP stands for 'Easier to Ask for Forgiveness than Permission,' a Python coding philosophy that encourages attempting an operation and catching exceptions if it fails, rather than checking preconditions beforehand. In practice, this means using try/except blocks around code that might raise errors (e.g., accessing a dictionary key or opening a file) instead of using if statements to verify conditions first. This approach aligns with Python's dynamic nature and often results in cleaner, faster code because it avoids redundant checks and race conditions.

Answer

Ensure All Functions Pass.

Answer

Exit All Files Properly.

Answer

Evaluate All Faults Promptly.

Question 10

A developer implements a class `Vector` with `__add__` returning a new `Vector`, and also defines `__iadd__` that mutates `self` in place and returns `self`. A colleague writes `a = Vector(1,2); b = Vector(3,4); c = a; a += b`. What is the state of `c`?

Accepted Answer

`c` now reflects the updated values because `__iadd__` mutated the shared object that `c` also references.. Augmented assignment prefers the in-place method `__iadd__` over `__add__`. When `__iadd__` mutates the object and returns it, any other references to that same object see the updated state. This aliasing behavior is a common source of subtle bugs when mutable objects are shared between variables.

Answer

`c` raises an AttributeError on access because `__iadd__` invalidates all prior references to the mutated object.

Answer

`c` is unchanged because `+=` always creates a new object, leaving the original binding intact.

Answer

`c` is unchanged because the augmented assignment rebinds `a` to a new object produced by `__add__`, ignoring `__iadd__`.

Question 11

What does the @abstractmethod decorator do when applied to a method inside an ABC?

Accepted Answer

It requires the subclass to implement the method.. It marks the method as requiring an override in any non-abstract concrete subclass.

Answer

It prevents the method from being called.

Answer

It automatically generates a default implementation.

Answer

It makes the method faster.

Question 12

When using abstract base classes (ABCs) from the abc module, what happens if a class inherits from an ABC but fails to implement one of the abstract methods?

Accepted Answer

The class will be marked as abstract and will raise a TypeError upon instantiation.. Python will raise a TypeError when you attempt to instantiate the class, preventing the creation of an incomplete object.

Answer

The class will be created, but calling the missing method will raise an AttributeError.

Answer

The missing method will default to a 'pass' statement.

Answer

The parent ABC will automatically provide a NotImplementedError.

Question 13

Which TWO of the following are potential pitfalls when using multithreading for network operations in Python?

Accepted Answer

Race conditions when accessing shared state. Option A is correct because when multiple threads access and modify shared state (such as a shared socket buffer, connection pool, or counter) without proper synchronization primitives like locks, race conditions can occur, leading to corrupted data or unpredictable behavior. Option B is correct because Python's Global Interpreter Lock (GIL) allows only one thread to execute Python bytecode at a time, so multithreading does not achieve true parallelism for CPU-bound tasks—though it can still help with I/O-bound network operations where threads block on socket calls. Option C is incorrect because threads do not always execute slower than single-threaded code; for I/O-bound network operations, multithreading often improves throughput by overlapping waiting periods. Option D is incorrect because threads within a process share the same memory space and typically consume less memory overhead than separate processes, not more. Option E is incorrect because socket objects in Python are not automatically thread-safe; concurrent access to the same socket from multiple threads can cause data corruption or errors unless explicitly synchronized.

Answer

Threads always execute slower than single-threaded code

Answer

Threads consume more memory than processes

Answer

Socket objects are automatically thread-safe

Question 14

Which TWO of the following are valid ways to create a connection in the sqlite3 module?

Accepted Answer

sqlite3.connect(':memory:'). Option A, sqlite3.connect(':memory:'), is correct because sqlite3.connect() is the module's factory function for creating a Connection object, and passing the special filename ':memory:' opens a temporary in-memory database. Option C, sqlite3.connect('my_db.sqlite'), is also correct because the same sqlite3.connect() function accepts a filesystem path and returns a Connection to that database file, creating it if it does not exist. The other options are invalid: sqlite3.Connection is the class of connection objects and is not normally instantiated directly with a filename, while sqlite3.new_db and sqlite3.open are not functions provided by the sqlite3 module.

Answer

sqlite3.Connection('my_db.sqlite')

Answer

sqlite3.new_db('my_db.sqlite')

Answer

sqlite3.open('my_db.sqlite')

Question 15

When documenting a complex function, which approach is most compliant with Google Style Python Docstrings regarding parameter types?

Accepted Answer

Use the 'Args:' section followed by the parameter name, type, and description.. Google Style Python Docstrings require an 'Args:' section where each parameter is listed with its name, type, and description in the format 'name (type): description'. This makes the function's interface self-documenting and consistent with tools like Sphinx Napoleon that parse Google-style docstrings.

Answer

Embed the types directly in the function name.

Answer

Include type hints in the docstring but omit them from the function signature.

Answer

Avoid documenting types to prevent redundancy with type hints.