Python Institute Certified Professional in Python Programming 1 (PCPP1, PCPP-32-101) (PCPP1) (PCPP1) — Questions 76–150

In Python, default arguments are evaluated only once at function definition time. Using a mutable default like `[]` means the same list object is reused across all calls, leading to unintended persistence of data. The recommended fix is to use `None` as the default and then check `if items is None: items = []` inside the function. This ensures a fresh list is created for each call, avoiding shared state bugs.

Tkinter is not thread-safe, so GUI updates must happen on the main thread. Running the heavy calculation in a worker thread keeps the event loop free to redraw and respond to input. The worker communicates results through a queue, and the main thread polls that queue using after(), performing widget updates safely on the main thread. This combination preserves responsiveness without violating Tkinter's threading constraints.

tk.Label() renders static, non-editable text and accepts no user input, matching the requirement for a display-only label. Unlike Entry or Text, it exposes no editing or selection behaviour, so it is the minimal widget satisfying the static-text constraint.

A class defining `__call__` receives the function being decorated as its initialiser argument, storing it for later invocation. This satisfies the stem's requirement: the decorator object wraps the target function, then `__call__` intercepts subsequent calls, forwarding arguments and returning the wrapped result.

requests.head() issues an HTTP HEAD request, so the server returns only headers with no message body, satisfying the requirement to check file existence without downloading content. It mirrors requests.get() but uses the HEAD verb, which is the correct method for metadata-only checks.

iterparse() is designed for incremental parsing of large XML files. It generates events (start, end, start-ns, end-ns) and allows you to process elements as they are parsed. By listening for 'end' events and checking if the tag is 'book', you can extract each book element and then clear it to free memory. This is the most memory-efficient way to handle large files.

__init__ initialises an already-created instance in place, so it must return None; returning any other value raises TypeError. Object construction itself is handled by __new__, which allocates and returns the instance, so __init__ has nothing meaningful to return.

AF_INET selects the IPv4 protocol stack, expecting addresses as (host, port) tuples with 32-bit hosts; AF_INET6 selects IPv6, using 128-bit addresses and four-element tuples. The stem asks for the primary difference, which is precisely the IP version each family binds sockets to.

`a += b` invokes `Vector.__iadd__`, which mutates `self` and returns it. Because `c = a` binds `c` to the same object, the in-place mutation is visible through `c`. This aliasing effect is the defining behavior of in-place operators and can surprise developers who expect `+=` to rebind a new object.

ConnectionResetError is raised when the peer sends a TCP RST rather than a graceful FIN, which happens when the remote process terminates or drops the socket abruptly. This matches the stem's multithreaded socket scenario, where the server side closed without completing the normal shutdown handshake.

Observers registered with a subject via strong references keep each other alive, so unregistered observers are never collected. weakref holds observers without incrementing their reference count, letting garbage collection reclaim them and preventing the memory leaks that accumulate over long-lived subjects.

`read()` returns a list of filenames successfully parsed, so a missing file simply yields an empty list rather than raising an exception. This satisfies the stem's scenario because `configparser` deliberately treats absent files as non-fatal, letting callers supply defaults or fallback paths without wrapping the call in error handling.

connect() takes a single tuple of (host, port) and performs the TCP three-way handshake, binding the client socket to the remote endpoint at 192.168.1.50:8080. Alternatives such as bind() or accept() serve server-side roles, so connect() is the only call that establishes the outbound connection required here.

Passing the path of a CA bundle to verify makes requests use exactly that file as the trust store, so the internal root is trusted while standard certificate and hostname validation still run. It is the documented way to point the library at a private CA without disabling security.

Entry is the standard single-line input widget. Binding a StringVar initialized to 'Search...' through `textvariable` pre-fills the field and keeps the value synchronized for later reading. This is the most direct way to seed initial text while retaining two-way data binding, and it matches the single-line search field requirement exactly.

PEP 8 recommends limiting all lines to a maximum of 79 characters. This limit is intended to improve readability, especially when viewing code side-by-side or on smaller displays. It also allows for multiple files to be open simultaneously. While many modern projects relax this to 99 or 119 characters, the official PEP 8 guideline remains 79 for code and 72 for docstrings and comments.

Explicitly specifying `encoding='utf-8'` ensures that the file is decoded using UTF-8 regardless of the platform's default encoding. This is the recommended practice for text files to avoid `UnicodeDecodeError` on systems where the default encoding is not UTF-8, such as Windows with cp1252.

Assigning through `parser['section']['option'] = 'value'` works because `ConfigParser` implements the mapping protocol: `__getitem__` returns a `SectionProxy` that supports `__setitem__`, writing straight into the section. This satisfies the stem's requirement for a valid definition method, unlike `set()` or `add_option()`, which do not exist on the parser.

Using only the `@property` decorator creates a read-only attribute: the getter runs on access, but any assignment raises `AttributeError` because no setter exists. This directly satisfies the stem's read-only constraint, unlike a plain attribute, which remains freely writable.

PEP 8 specifies that top-level function and class definitions should be surrounded by two blank lines. This convention improves readability by clearly separating distinct sections of code. It helps developers quickly identify where one function ends and another begins, especially in larger modules. Adhering to this rule is a common practice in well-formatted Python codebases.

The User-Agent header is client-supplied text, so any value can be sent regardless of the actual software. Tools and scripts routinely set it to a browser string, satisfying the requirement that it can be spoofed to mimic browsers.

Socket buffer sizes are bounded by kernel-level limits such as SO_RCVBUF and SO_SNDBUF maxima, so the operating system constrains how large buffers can be set. This is the actual constraint governing socket buffer configuration, not the Python socket module itself.

Adding `.env` to `.gitignore` prevents credentials and API keys from being committed to version control, satisfying the constraint that secrets must never enter the repository history. Since Git tracks content permanently, excluding the file at source stops accidental exposure through pushed commits, forks or public mirrors.

This approach correctly handles pagination by iteratively requesting each page, extracting the next link from the JSON response, and continuing until there are no more pages. It uses the requests library to send GET requests and parse JSON, which is straightforward and effective for APIs that provide next links in the body.

JSON and XML parsers construct only primitive data types, so they cannot execute arbitrary code during deserialisation. This directly satisfies the untrusted-source constraint, where pickle's `__reduce__` method allows attackers to run commands. Switching format removes the code-execution vector entirely rather than merely restricting which classes may load.

PEP 8 specifies that constants be written in all-uppercase letters with words separated by underscores, satisfying the stem's request for the recommended naming convention. This distinct style visually flags module-level values that should not change, separating them from lowercase variables and functions.

PEP 8 mandates two blank lines before and after every top-level class definition, visually separating it from surrounding module-level code. This satisfies the stem's request for recommended class-definition formatting, distinguishing top-level classes from nested ones and methods, which use a single blank line.

'tk.Frame()' creates a rectangular container widget that groups and positions child widgets, and can itself be placed inside a window or another frame. This directly satisfies the stem's requirement for a widget acting as a container.

`__str__` supplies the informal, human-readable string that `print()` calls when converting an instance to text. Python's `print()` invokes `str()` on its arguments, which delegates to `__str__`; `__repr__` only serves as a fallback when `__str__` is undefined. This directly satisfies the stem's requirement for controlling printed output.

This snippet correctly uses the headers parameter, which accepts a dictionary of HTTP headers to send with the request. The User-Agent header is set to 'MyApp/1.0', fulfilling the requirement. This is the standard and recommended way to add custom headers in requests.

`WeakSet` stores weak references, so when an observer object has no other strong references, it is collected and the set entry disappears silently. This is precisely the behavior wanted for the Observer pattern to avoid keeping observers alive indefinitely. No manual unregistration is required for objects that go out of scope.

The move method takes a tag or item ID and delta x and delta y values, and moves the item(s) by that amount. Using the tag 'ball' moves all items with that tag, which in this case is the circle, by 10 pixels right and 5 pixels down, exactly as required.

A custom logging filter can inspect log records and redact or remove sensitive information before they are emitted. This allows developers to log useful debugging information while ensuring that sensitive data such as passwords, tokens, or personal identifiers are not written to logs, maintaining security and compliance.

The show option determines which parts of the Treeview are displayed. Including 'tree' displays the tree column with expander controls, while 'headings' shows the column headers. Using 'tree headings' displays both, so the first column can act as an expandable tree node, matching the requirement.

Tk() only constructs the root window; nothing is drawn or processed until the event loop runs. Calling root.mainloop() hands control to Tk's event dispatcher, satisfying the stem's requirement to start the event loop so the window appears and responds.

Tkinter's Checkbutton writes its on/off state into a shared control variable, so passing a BooleanVar to the 'variable' parameter lets you read or set the tick state directly through that object rather than polling widget internals.

The grid geometry manager is designed for row-and-column alignment. Placing the labels in column 0 and entries in column 1 of the same row guarantees vertical alignment regardless of text length or font. Wrapping that grid inside its own Frame and packing the Frame lets you center the whole form in the parent, which is the minimal, idiomatic change for this requirement.

Observers register callbacks with the subject rather than being invoked by name, so the subject holds no compile-time reference to concrete observer classes. This satisfies the stem's decoupling constraint, letting observers be added or removed at runtime.

The csv writer applies QUOTE_MINIMAL by default, wrapping any field containing the delimiter, quotechar or newline in double quotes and escaping embedded quotes by doubling them. This preserves the comma inside the text field so the reader parses it as one value rather than splitting it.

When you pass a path to a CA bundle to the 'verify' parameter, requests uses that bundle to verify the server's certificate. Hostname verification is performed by default as part of the SSL verification process. There is no need for an additional parameter. This approach correctly configures requests to use the custom CA and ensures hostname verification is active, meeting the scenario's requirements.

Assigning a non-zero weight to column 0 via columnconfigure makes Tkinter distribute any surplus width to that column when the window grows, satisfying the resize constraint. Weight defaults to 0, so columns stay fixed without it; weight=1 grants the column proportional claim on extra space.

DELETE is a standard HTTP request method used in RESTful design to remove the resource identified by the request URI. It satisfies the stem by being one of the valid methods commonly applied to REST endpoints.

__set_name__ is called automatically at class creation with the owner class and the attribute name, letting the descriptor capture its own identifier. This removes the need to pass the name manually, enabling descriptors to store or validate per-attribute data.

super() delegates to the next class in the method resolution order rather than a hard-coded parent, so cooperative multiple inheritance chains correctly. This satisfies the stem's requirement by avoiding the brittle, MRO-breaking direct parent call.

When reading CSV files with embedded newlines, you must open the file with newline='' to prevent universal newline translation from interfering. The csv module expects the file to be opened with newline='' so it can correctly interpret line breaks within quoted fields. This is a documented requirement for both reading and writing.

A proxy tool intercepts HTTP traffic between client and server, exposing the actual request URLs, methods, payloads and status codes. This directly satisfies the need to debug REST API integrations, since it reveals what is genuinely transmitted rather than what the code intends to send.

A virtual environment isolates each project's installed packages from the system interpreter and from other projects, preventing version conflicts between libraries that demand incompatible dependencies. Creating one per project is the recommended baseline for reproducible, dependency-safe development.

Row weights control how surplus vertical space is distributed by grid(). A weight of zero keeps the toolbar row at its natural height, while a weight of one lets the Canvas row absorb all extra space. The sticky='nsew' option makes the Canvas fill the entire cell rather than centering at its requested size, which is required for the chart to use the available area.

ElementTree stores an element's direct text in its .text attribute, which returns the string between the opening and closing tags (or None if empty). This is the standard accessor for retrieving character data from a parsed element, satisfying the requirement to obtain text content.

shelve uses pickle by default to serialize values before storing them in the underlying dbm database. This allows storage of arbitrary Python objects, as long as they are picklable. The keys are also pickled. This is a fundamental aspect of how shelve works. The statement is true and important to understand for correct usage, especially regarding object compatibility across Python versions.

PEP 8 explicitly permits local consistency to override its rules when working within an existing codebase, so matching surrounding legacy conventions takes precedence over strict compliance. This satisfies the stem's constraint by acknowledging that readability and uniformity within a project outweigh blanket adherence to the style guide.

A single leading underscore marks the method as non-public by convention, satisfying the need to signal internal-only use without enforcing access control. Python's documentation treats such names as internal, and `from module import *` excludes them, so external callers receive a clear warning while the API remains unbroken.

The `requests` library uses `urllib3` under the hood, and `urllib3.util.retry.Retry` allows fine-grained control over retries, including which status codes to retry on, backoff factors, and total retries. By creating an `HTTPAdapter` with a `Retry` instance and mounting it to a `Session`, you can automatically retry failed requests. This is the recommended, robust way to implement retries.

Calling `type(name, bases, dict)` invokes the three-argument metaclass constructor, which builds a fresh class object at runtime from the supplied name string, base-class tuple and namespace dictionary. This satisfies the stem's requirement precisely: the three-argument form exists to create classes dynamically, unlike the single-argument form that merely returns an object's type.

Docstrings are the conventional, introspectable place for usage documentation in Python. Because they attach to the function object itself, tools like help() and IDEs surface the summary and usage details directly, satisfying the library's need for discoverable, self-contained documentation.

A Session object holds default headers that are merged into every request made through it, so updating session.headers once applies the bearer token to all calls. This is idiomatic, avoids repetition, and also reuses the underlying TCP connection for better performance.

PEP 257 specifies that multi-line docstrings should begin with a summary line on the same line as the opening quotes, followed by a blank line, then a more detailed description. The closing quotes should be on a separate line. This structure allows tools like help() to display the summary first and ensures consistent formatting across the codebase.

Setting selectmode to 'extended' enables the standard multi-selection behavior where users can select multiple items using Ctrl+click for non-contiguous items or Shift+click for ranges. This is the default mode for Listbox and matches typical desktop application behavior. It provides the most intuitive user experience for multiple selections.

bind_all registers the handler at the application level, so the binding fires regardless of which widget currently has focus. This is the correct way to implement a global keyboard shortcut such as Escape to cancel a dialog, because it applies to every widget in the application without needing to bind each one individually.

csv.reader() defaults to a comma delimiter, so semicolon-separated data splits at every semicolon, including those inside quoted fields once quoting rules do not match. Supplying delimiter=';' makes the parser treat semicolons as separators and honour the default quotechar so embedded semicolons inside quotes stay within one field. Opening with newline='' is also required so the csv module controls line splitting.

EAFP means attempting the operation and catching exceptions rather than pre-checking conditions. Python's try/except embodies this, avoiding race conditions between a check and the action, and suiting duck-typed code where pre-validation is unreliable or verbose.

The accelerator option only displays the shortcut text next to the menu item; it does not create the binding. To make the shortcut work, you must explicitly bind the key sequence (e.g., '<Control-s>') to the save function using bind on a widget, typically the root window. This two-step process is necessary because Tkinter does not automatically associate the accelerator text with the binding.

`lineterminator` is a valid `csv.writer` constructor parameter, letting you override the default `'\r\n'` row separator when writing files. This satisfies the stem's requirement for genuine constructor arguments, unlike dialect-only or reader-specific settings. It directly controls the character sequence terminating each written row.

PEP 8 explicitly recommends four spaces per indentation level and states that spaces are the preferred indentation method. Using four spaces consistently in the new function keeps the module uniform and avoids the ambiguity that arises when tabs and spaces are mixed, which can cause `TabError` or silent misalignment across different editors.

The @abstractmethod decorator marks a method as abstract within an ABC, so any concrete subclass that does not override it cannot be instantiated; Python raises TypeError at instantiation. This enforces the subclass implementation the question describes.

tomllib is the standard library module introduced in Python 3.11 for parsing TOML files. It provides load() and loads() functions to read TOML data into Python dictionaries. For older Python versions, you would need a third-party library, but for current Python, tomllib is the correct standard module.

The timeout parameter accepts a tuple where the first value is the connect timeout (maximum time to establish the TCP connection) and the second is the read timeout (maximum time to wait for a chunk of data after the connection is established). Passing (5, 30) exactly matches the requirement: 5 seconds to connect, 30 seconds to receive data.

Inheriting an ABC without overriding every abstract method leaves the subclass abstract, so Python refuses instantiation and raises TypeError. This satisfies the stem's constraint: the missing implementation is detected at instantiation time, not at class definition, because ABCMeta records remaining abstract methods in `__abstractmethods__`.

Environment variables keep secrets out of source code and version control, so credentials are injected at runtime rather than committed. This satisfies the constraint of handling sensitive keys without embedding them in files that could be leaked.

This loop repeatedly calls `recv(4096)` and appends chunks to a bytes object until `recv` returns an empty bytes object (`b''`), which signals that the server has closed the connection. This is the correct pattern to read all data from a TCP socket until EOF. It handles arbitrary data sizes and ensures no data is missed.

Checking status_code directly is explicit and avoids relying on exceptions. Calling response.json() on an error response is valid when the API documents JSON error bodies. This approach gives full control over parsing and is safe as long as the body is known to be JSON.

Skipping super().__init__() breaks Python's cooperative multiple-inheritance chain: the MRO traversal halts at that class, so subsequent parent initialisers never execute. This satisfies the stem's constraint that later classes in the MRO remain uninitialised, leaving their instance attributes unset.

cursor.lastrowid returns the rowid of the most recent successful INSERT on that cursor. For a table with an INTEGER PRIMARY KEY, this is the auto-generated key. Using placeholders for parameters prevents SQL injection. This is a standard, safe method to obtain the new key immediately after insertion.

tk.OptionMenu() binds a Tk variable to a menubutton displaying the current selection, letting the user pick exactly one value from a fixed list. This directly satisfies the stem's single-selection dropdown constraint, unlike Checkbutton or Listbox, which permit multiple selections or expose no collapsed menu.

Passing arguments as a list with shell=False bypasses the shell entirely, so metacharacters like `;`, `|` and `&&` are treated as literal argument data rather than shell syntax. This satisfies the stem's command injection constraint by removing shell interpretation, the mechanism through which injected commands would otherwise execute.