PCPP1 Practice Test 16 — 15 Questions

Question 1

A library defines a base class `Plugin` with `__init_subclass__(cls, **kwargs)` that automatically registers every subclass in a global registry using `cls.__name__`. A developer writes `class MyPlugin(Plugin, priority=5): pass` but the registration fails with a TypeError about unexpected keyword arguments. What is the most likely cause?

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

Accepted Answer

The base `Plugin.__init_subclass__` signature does not accept or forward `**kwargs`, so `priority=5` reaches `object.__init_subclass__`, which rejects it.. Keyword arguments in a class header are forwarded to the parent's `__init_subclass__`. If that method does not declare `**kwargs` and forward them, the extra keyword reaches `object.__init_subclass__`, which rejects it with TypeError. Adding `**kwargs` to the signature and passing them to `super().__init_subclass__(**kwargs)` fixes the registration.

Answer

`__init_subclass__` must be declared as a classmethod explicitly; otherwise keyword arguments are not forwarded.

Answer

The registry is full because `__init_subclass__` runs before the class body executes, so `cls.__name__` is not yet available.

Answer

Keyword arguments passed in a class definition header are only supported on metaclasses, not on `__init_subclass__`.

Question 2

What is the purpose of the logging.StreamHandler?

Accepted Answer

To send logs to a stream like stdout.. It sends log messages to a stream, such as sys.stderr or sys.stdout.

Answer

To write logs to a file.

Answer

To format log messages.

Answer

To rotate log files.

Question 3

You are implementing a `Vector` class whose instances should support `v1 + v2` and also `v1 + 5`, where the second form broadcasts the scalar across every component. A colleague suggests relying on `__radd__` to handle the scalar case. Why is that insufficient?

Accepted Answer

`__radd__` is only consulted when the left operand's `__add__` returns `NotImplemented` or does not exist, so `Vector.__add__` must first detect and return `NotImplemented` for unsupported operand types.. Binary operator dispatch tries the left operand's forward method first. For `v1 + 5`, that is `Vector.__add__`, which must return the `NotImplemented` singleton to signal that it cannot handle an `int`. Only then does Python attempt the reflected operation. Relying on `__radd__` alone leaves `__add__` free to raise or misbehave, so the two methods must be designed as a pair.

Answer

`__radd__` receives the operands in the same order as `__add__`, so it cannot distinguish which operand is the vector and which is the scalar.

Answer

`__radd__` is reserved for augmented assignment, so `v1 += 5` would work while `v1 + 5` would raise a `TypeError` regardless of what `__add__` returns.

Answer

`__radd__` is only invoked for subclasses of the left operand's type, so a plain `int` on the left can never trigger it under any circumstances.

Question 4

Which magic method allows an object to behave like a function?

Accepted Answer

__call__. The __call__ method enables an object to be invoked with parentheses syntax.

Answer

__apply__

Answer

__invoke__

Answer

__func__

Question 5

You are writing a Python script that needs to parse a URL and extract the query parameters. The URL is 'https://api.example.com/v1/items?limit=10&offset=20'. Which module should you use to reliably parse this URL and retrieve the value of 'limit'?

Accepted Answer

urllib.parse. The urllib.parse module is specifically designed for parsing URLs. It provides urlparse to split a URL into scheme, netloc, path, query, etc., and parse_qs to parse the query string into a dictionary. This is the correct and standard way to extract query parameters like 'limit' from a URL in Python.

Answer

urllib.request

Answer

requests

Answer

urlparse

Question 6

You are developing a Python application that needs to retrieve data from a public REST API. The API returns JSON data and requires you to send a GET request with a custom User-Agent header. Which of the following code snippets correctly sends the request using the requests library?

Accepted Answer

requests.get(url, headers={'User-Agent': 'MyApp/1.0'}). The requests library provides the headers parameter to specify custom HTTP headers. It accepts a dictionary where keys are header names and values are header values. This is the standard way to set a User-Agent or any other header. The other options use non-existent parameters or incorrect data types, which would cause errors.

Answer

requests.get(url, user_agent='MyApp/1.0')

Answer

requests.get(url, headers=('User-Agent', 'MyApp/1.0'))

Answer

requests.get(url, custom_headers={'User-Agent': 'MyApp/1.0'})

Question 7

You are writing a Python script that must read a configuration file in TOML format. Which module from the Python Standard Library should you use?

Accepted Answer

tomllib. tomllib is the Standard Library module for reading TOML files, added in Python 3.11. It correctly parses TOML syntax and returns native Python types. Other modules like configparser, json, or yaml are either for different formats or not in the standard library.

Answer

yaml

Answer

configparser

Answer

json

Question 8

A Tkinter application has a main window containing a Text widget used as a log console. The application performs a long-running data import and must remain responsive, so the import runs in a background thread. The worker thread needs to append status lines to the Text widget. Which approach is correct?

Accepted Answer

Have the worker thread place messages on a queue.Queue, and have the main thread poll that queue periodically using the after method and perform the insert calls.. Tkinter widgets may only be manipulated from the thread that created the root window, so a background worker must not touch the Text widget directly. Passing messages through a queue and having the main thread drain it with an after-scheduled callback keeps all widget calls on the owning thread while the import proceeds in parallel. This preserves responsiveness and avoids interpreter corruption.

Answer

Wrap each insert call in a threading.Lock shared with the main thread so only one thread touches the Text widget at a time.

Answer

Call the Text widget's insert method directly from the worker thread, since Tkinter serializes widget access internally.

Answer

Call the root window's update_idletasks method from the worker thread before each insert so pending events are processed first.

Question 9

A developer defines `class Config:` with `__slots__ = ('host', 'port')`. Later, they want to add a new attribute `timeout` to an existing instance without modifying the class. They write `cfg.timeout = 30` and receive an `AttributeError`. Which change would allow per-instance `timeout` assignment while keeping `__slots__` for `host` and `port`?

Accepted Answer

Add `'__dict__'` to `__slots__`.. Slot descriptors are the only writable attributes unless the class also provides a `__dict__`. Declaring `'__dict__'` inside `__slots__` creates that dictionary, so new names like `timeout` can be stored per instance while `host` and `port` remain fast slots. The other options either do not affect assignment or misuse the `__slots__` contract.

Answer

Add a `__getattr__` method that returns `30` for unknown names.

Answer

Subclass `Config` and add `__slots__ = ()` in the subclass.

Answer

Change `__slots__` to a dictionary mapping names to default values.

Question 10

You are designing a Python REST API client that must handle HTTP errors gracefully. The client uses the requests library. Which TWO of the following statements about error handling with requests are correct? (Choose two.)

Accepted Answer

The response.raise_for_status() method raises an HTTPError if the HTTP status code indicates a client error (4xx) or server error (5xx).. The raise_for_status() method is the idiomatic way to trigger exceptions for HTTP error statuses, and status_code provides the numeric code for manual checks. The other statements confuse network-level exceptions with HTTP status codes, or incorrectly assume automatic error raising. Understanding these distinctions is crucial for robust API clients.

Answer

The requests.exceptions.ConnectionError is raised when the server returns a 500 Internal Server Error status code.

Answer

The requests.exceptions.Timeout exception is raised when the server returns a 408 Request Timeout status code.

Answer

By default, requests automatically raises an exception for any HTTP status code other than 200 OK.

Question 11

You are designing a class hierarchy for a document processing system. The base class `Document` defines a method `render()` that returns a string. You want subclasses to be forced to provide their own implementation, and you want to prevent `Document` from being instantiated directly. Which code correctly enforces this requirement?

Accepted Answer

from abc import ABC, abstractmethod

class Document(ABC):
    @abstractmethod
    def render(self):
        pass. The abstract base class pattern with ABC and @abstractmethod is the idiomatic way to prevent direct instantiation of a base class and force subclasses to implement specific methods. It ensures that any subclass lacking an override remains abstract and cannot be instantiated, raising a TypeError. The other approaches either fail to enforce implementation or rely on fragile runtime checks.

Answer

class Document:
    def render(self):
        raise NotImplementedError("Subclass must implement render")

def __init__(self):
        if self.__class__ is Document:
            raise TypeError("Cannot instantiate Document directly")

Answer

class Document:
    def render(self):
        pass

def __new__(cls, *args, **kwargs):
        if cls is Document:
            raise TypeError("Cannot instantiate Document directly")
        return super().__new__(cls)

Answer

class Document:
    def render(self):
        raise Exception("Not implemented")

class DocumentMeta(type):
    def __call__(cls, *args, **kwargs):
        if cls is Document:
            raise TypeError("Cannot instantiate Document directly")
        return super().__call__(*args, **kwargs)

Question 12

You are writing a Python script that must download a large file from a REST API endpoint. The file is several gigabytes, and you want to avoid loading it entirely into memory. Which approach using the requests library is most memory-efficient?

Accepted Answer

Use requests.get(url, stream=True) and iterate over response.iter_content(chunk_size=8192), writing each chunk to a file.. Using stream=True prevents the response body from being downloaded immediately. Iterating over iter_content() with a chunk size writes data to disk incrementally, keeping memory usage low. Other methods either load the entire response into memory or fail to stream properly. This is the standard pattern for large file downloads with requests.

Answer

Use requests.get(url).content to get the raw bytes and write them to a file in one operation.

Answer

Use requests.get(url, timeout=300) and then use shutil.copyfileobj(response.raw, file) to copy the raw stream to a file.

Answer

Use requests.get(url, stream=True) and call response.raw.read() to read the entire raw stream at once.

Question 13

Which THREE of the following are true regarding the use of 'threading' and 'requests' in Python?

Accepted Answer

Threads share the same memory space. Option A is correct because threads within a single Python process share the same memory space, which allows them to access shared objects and data directly (though this requires synchronization primitives like locks to avoid race conditions). Option C is correct because creating a requests.Session object per thread is a best practice: a Session provides connection pooling and cookie persistence, and since Session objects are not thread-safe, each thread should have its own instance to avoid cross-thread interference. Option E is correct because threading is well suited for I/O-bound tasks such as API calls with the requests library, since threads release the GIL during blocking I/O operations, allowing other threads to run concurrently. Option B is incorrect because requests is inherently I/O-bound (network operations), not CPU-bound. Option D is incorrect because threads do not bypass the GIL entirely; the GIL still serializes bytecode execution, and threads only release it during I/O or explicit C-level calls.

Answer

Requests is inherently CPU-bound

Answer

Threads bypass the GIL entirely

Question 14

You are using the logging module in a long-running service. You need to ensure that a specific logger named 'app.db' writes DEBUG and higher messages to a file, but its parent logger 'app' must not propagate these DEBUG messages to the root logger. Which configuration achieves this?

Accepted Answer

Set the 'app.db' logger level to DEBUG, add a FileHandler, and set 'app.db'.propagate = False.. To keep DEBUG messages from 'app.db' confined to its own FileHandler, the logger must process DEBUG records and must not propagate them to ancestors. Setting the logger level to DEBUG enables processing, adding a FileHandler writes to the file, and setting propagate to False stops upward propagation. Other options either allow propagation or attempt to control it via unrelated levels or handlers, which does not achieve the isolation.

Answer

Set the 'app.db' logger level to DEBUG, add a FileHandler, and set the root logger level to INFO.

Answer

Set the 'app' logger level to DEBUG, add a FileHandler to 'app.db', and leave propagate at its default.

Answer

Set the 'app.db' logger level to DEBUG, add a FileHandler, and add a NullHandler to the 'app' logger.

Question 15

You are consuming a paginated REST API that returns a JSON object with a 'data' list and a 'next' field holding the URL of the following page, or null on the last page. You want a loop that retrieves every record exactly once. Which TWO statements about implementing this loop correctly are true? (Choose two.)

Accepted Answer

You must stop the loop when the 'next' field is null, since that signals there are no further pages.. Following the server-provided next link respects opaque pagination tokens, and terminating when that field is null matches the documented contract. Reusing a single parsed body, disabling TLS verification, or assuming next is always absolute all lead to incorrect or fragile behavior, so those statements are not true.

Answer

You should call response.json() once and reuse the parsed object for subsequent pages to save CPU.

Answer

You should set verify=False on each request so pagination is not slowed by certificate checks.

Answer

You should assume the 'next' value is always an absolute URL and pass it directly to requests.get without inspection.