Certified Associate Python Programmer PCAP (PCAP) — Questions 376–421

Here, str.index() is invoked with 'd', which does not occur in the string 'abc'. Unlike find/rfind, index is designed to raise ValueError when the substring is absent, treating that condition as an exceptional event. Because 'd' is missing, this expression raises ValueError, making it the correct answer.

This is the canonical Python idiom used to determine whether the current file is being run as the top-level script. When the interpreter executes a script directly, it sets the global variable __name__ to the string '__main__'; when the file is imported as a module, __name__ is set to the module's import name instead. The if block therefore only runs for standalone execution, which is exactly what the script intends. This guard also supports running with python -m, where __name__ is also '__main__'.

Calling D().method() returns 'B' because the MRO for D is ['D', 'B', 'C', 'A', 'object']. Since D defines no method, Python's lookup proceeds to B, whose method returns the string 'B' directly, without calling super(). Therefore C.method is never reached, and the call evaluates to the string 'B'.

Triple double quotes define a multiline string literal: the opening and closing delimiters may be on different physical lines, and any raw line breaks inside become part of the string. Including \n adds an explicit line break as well; this is one of the two accepted forms for multiline literals in Python.

Splitting the original string on '=' gives [' key ', ' value ']. The list comprehension then applies .strip() to each part, removing all leading and trailing whitespace from both the key and the value. This yields ['key', 'value'], exactly two elements with spaces around the equals sign removed, satisfying the requirement.

Using `try: ... finally: f.close()` is the canonical Python idiom because the `finally` block is guaranteed to execute whether or not an exception is raised inside the `try` block. Unlike `except`, which only handles exception paths, `finally` runs on normal completion, on exception propagation, and even when a `break`, `continue`, or `return` is encountered in the `try` body. This ensures that the file descriptor is released deterministically, preventing resource leaks in both expected and exceptional control flows. It is the building block of context managers, where the `with` statement uses `__exit__` to achieve similar deterministic cleanup.

Slicing with [::] is a valid, non-mutating operation on strings because str implements the sequence protocol via __getitem__, accepting a slice object. For example, s[::-1] creates a reversed copy of the string, while s[1:4] extracts a substring; in every case the result is always a brand-new string and the original is left unchanged. This works regardless of the immutability of strings because it reads data rather than trying to modify it.

`__repr__` is the canonical developer-facing representation and is what the interactive interpreter, `repr()`, and container displays use. When `__str__` is not defined, `print()` falls back to `__repr__`, so implementing it alone yields `Circle(5)` in every context described. This single method covers both the debugging and printing needs of the scenario without duplication.

Python resolves the conflict using the Method Resolution Order, the linearised sequence computed by the C3 algorithm. It determines which parent's method is invoked, so the first matching class in that order executes, explaining why only one parent's version runs.

This is the recommended approach because it separates internal diagnostics from user-facing failure information. Logging the full traceback preserves the exact stack, exception types, and local context for developers, while raising a custom generic exception like PipelineProcessingError prevents sensitive implementation details from leaking. Using a custom exception also gives callers a stable interface for retry and alerting logic without coupling them to low-level I/O or network exceptions.

When a module is first imported, its top-level code runs, and the resulting module object is stored in the sys.modules dictionary. Subsequent import statements for the same module retrieve that cached object and bind it to the requested name, skipping re-execution of the module body. This ensures that expensive initializations and side effects (such as establishing database connections) happen exactly once per process.

The `endswith()` method is the dedicated predicate for suffix testing: it returns `True` only when the final characters of the string exactly match the given suffix, and `False` otherwise. It also accepts optional `start`/`end` slice arguments, which allow you to check only a portion of the string, and it performs a case-sensitive comparison by default (use `casefold()` or lowercasing for case-insensitive checks). Because it returns a boolean directly, it cleanly satisfies the developer's requirement to verify whether the string ends with a specific substring.

Correct syntax: parentheses form a tuple listing the two exception classes to catch. Python checks the raised exception against each class in the tuple and handles either FileNotFoundError or PermissionError in the same block. Because both derive from OSError, using this tuple is more precise than catching the parent class and avoids masking unrelated OSError subclasses.

This is the correct approach because it explicitly imports only the sqrt function from the math module into the current namespace. After execution, you can call sqrt(9) directly without a module prefix, which improves readability and reduces the chance of name collisions. It is a targeted, efficient way to bring in only the specific functionality you need.

The specifier `:10.2f` is the correct choice: `10` sets a minimum field width of 10 characters, `.2` requires exactly two digits after the decimal point, and `f` selects fixed-point notation with no exponent. When applied to `1234567`, it produces `1234567.00`, which is exactly 10 characters (7 integer digits, the decimal point, and 2 fractional digits) and satisfies the width and precision requirements. If the integer part were shorter, leading spaces would pad the output to the specified width.

This is a valid, if less common, manual application of the classmethod() built-in. The module-level function is defined with a first parameter named cls, and then classmethod(my_method) wraps that function in a classmethod descriptor before assigning it back to the same name. From that point on, accessing the attribute on the class or on an instance binds the class object as the first argument, exactly as the @classmethod decorator would do at class creation time.

Two leading dots in a relative import ascend one level in the package hierarchy: from a module inside `sub_package`, `..` refers to `my_package`. Therefore `from ..module_a import foo` asks Python to locate `module_a` as a sibling of `sub_package` within that parent package, which exactly matches the described structure. This is the correct way to import `foo` without relying on an absolute top-level path.

In Python, strings are immutable sequences, so slicing with s[::-1] does not alter the original object; it constructs a completely new string with the characters in reverse order. The original variable s still references the unchanged string, and the newly created string can be assigned to another name or used directly. This is the canonical way to reverse a string, and it correctly returns a new value rather than mutating existing data.

Relative imports are not intrinsically tied to the filesystem path of the file; they are only valid when the interpreter has assigned the importing module a non-empty `__package__` attribute, which happens only when that module is imported as part of a package (e.g., `import pkg.subpkg.mod2`). If you run a module directly, Python sets `__package__` to `None`, so a statement like `from . import sibling` fails with "attempted relative import with no known parent package" because there is no package context to anchor the leading dot.

The correct outcome is an AttributeError because of Python name mangling. Any identifier of the form __x (two leading underscores, at most one trailing underscore) inside a class is rewritten to _ClassName__x. Since the object has an attribute _ClassName__x and not __x, the direct access obj.__x cannot find the attribute, and Python raises AttributeError with a message like 'Test' object has no attribute '__x'.

Strings in Python are immutable sequences; the assignment `s[0] = 'H'' attempts to mutate the object at index 0, which violates the immutable contract of the `str` type. The interpreter raises a `TypeError` specifically because `str` objects lack a `__setitem__` method, preventing item assignment. This directly satisfies the constraint that strings cannot be modified in-place in Python.

str.split('.')[-1] is the correct idiom because it divides the entire string on every dot and then uses -1 to select the final element, which is exactly the substring after the last period. This handles file names with multiple dots, returning the last component as the extension. One caveat is that if no dot exists, the whole original string is returned, but for typical extension extraction this is acceptable and widely used.

FileNotFoundError is a precise subclass of OSError that Python's open() raises when the requested path cannot be found, including cases where a parent directory is missing or the path is a dangling symlink. By catching only this exception, the handler maps the specific 'missing resource' condition to send_404() and lets every other I/O problem—such as PermissionError—propagate or be handled elsewhere. This follows the EAFP (easier to ask forgiveness than permission) idiom and avoids the broader catch-all problems of checking existence beforehand.

A custom descriptor that implements __get__ is the right approach because it can compute the value on first access and then store that computed result in the instance's __dict__ under a private key or even the same name if it is a non-data descriptor. On subsequent accesses, the instance dictionary takes precedence over the non-data descriptor, so the cached value is returned directly without recomputation. This exactly matches the desired lazy, one-time computation behavior.

The sequence \t is a valid escape sequence that represents the tab character (ASCII 9, horizontal tab). It is commonly used to insert whitespace alignment in text output, for example in printing columns or formatting tables. Python recognizes \t as a single character with the ordinal value 9, not as two separate characters backslash and 't'.

Assigning the identifier as an attribute in the subclass __init__ makes it available on the caught exception object, which is how the worker logs it. Delegating to Exception.__init__ with the message populates the args tuple, and the inherited __str__ returns that message. Both requirements are satisfied by this design.

Using the join() method on a list: This is the canonical efficient technique. You collect all the pieces into a list, then call separator.join(list) once. The join() implementation precomputes the exact total length of the result, allocates a single buffer, and copies each piece into it in one straight pass, producing no intermediate strings. That makes it O(n) in both time and memory and is the fastest pure-Python way to assemble many separate string fragments.

This is the correct C3 linearization. For D(B, C), B(A), C(A), and A(object), the merge starts with D, then B's MRO [B, A, object] and C's MRO [C, A, object] are merged with the direct bases [B, C]. B is taken first, then C (because C is not in the tail of B's MRO), then A (because A is not in the tail of any remaining list), and finally object. This order preserves local precedence order (B before C), respects the inheritance chain C before A, and includes object as the final class.

A classmethod receives the class object as its first parameter, conventionally named cls, so assigning cls.attribute = value inside the method writes directly into the class's namespace and creates a genuine class attribute shared by every instance. This is valid as long as the method is executed at least once (for example, called after class creation). Because cls is the actual class, the attribute is also inherited correctly by subclasses.

Exception is the standard, recommended base class for custom exceptions because it is the root of the ordinary error hierarchy, below BaseException but above all built-in exceptions meant for program-level failures. Deriving from it ensures your invalid-data exception is caught by generic `except Exception` handlers, supports chaining with `__cause__`, and clearly communicates that it is an application-level error. This is the convention described in Python's official documentation and followed by most libraries and frameworks.

FileNotFoundError is a built-in exception raised when a file or directory is requested but cannot be found at the specified path. It is a subclass of OSError and is specifically designed for missing-file scenarios, which is exactly the case when reading a configuration file that does not exist. In Python 3, it is the canonical exception for this situation, replacing the more generic IOError that was used in earlier versions.

Circular imports arise when two modules mutually reference each other at import time, so Python cannot fully initialise either. Extracting shared logic into a third module breaks the cycle, satisfying the stem's requirement to resolve the ImportError through restructuring rather than deferred imports or runtime workarounds.

True is correct because in CPython, string literals are automatically interned, meaning that two identical string literals are stored in the same memory location. When the code compares them with the identity operator 'is', it compares object memory addresses, and since both variables point to the same interned object, the result is True. This is a well-known CPython behavior, though it is an implementation detail rather than part of the Python language specification. The exact code likely creates two variables with the same string literal, and interning makes their identities match.

This correctly overrides `type.__new__`, modifies the mutable namespace dictionary before class construction, and delegates to `super().__new__` to build the class object. Because `super().__new__` copies the entries of `dct` into the new class's `__dict__`, the added `created_by` attribute is present on the finished class. The explicit `return` is essential: without it, no class object would be created at all.

This is the correct distinction: the str object itself is immutable, so once a string is created its contents cannot be altered, added to, or removed. However, a variable that references a string can be assigned a new value, such as s = 'new', which makes the variable point to a different string object. This separation between object identity and variable binding is fundamental to Python's data model and explains why strings can appear to 'change' when they actually are being replaced.

Calling s.strip() returns a new string with all leading and trailing whitespace removed, so leading whitespace is indeed eliminated as part of the process. This makes it a valid choice for the task, even though it also strips the right end. By default, strip() removes spaces, tabs, and newline characters; an optional chars argument can narrow the set.

Assigning a value in the class body, directly at indentation level of the class, creates a class attribute stored on the class object. All instances of that class share the same object through normal attribute lookup; accessing it via an instance falls back to the class if no instance attribute shadows it. This is the idiomatic way to create shared state used by every instance.

Using extended slice syntax with a step of `-1` creates a reversed copy of the entire string: `s[::-1]` means start at the end, go to the beginning, and step backward by one. This is the most idiomatic and concise way to reverse a string in Python, and it is often preferred for its readability and speed. Since strings are immutable, this operation allocates a new string object containing the characters in reverse order, leaving the original string unchanged.

C3 linearization is the algorithm Python uses to compute the MRO at class creation time. It guarantees that every class appears before any of its parents in the linearization and that the local precedence order of bases is preserved across the entire hierarchy, a property called monotonicity. This ensures that `super()` calls follow a consistent, predictable order even in complex diamond inheritance, avoiding duplicate executions and inconsistent dispatch.

This is a valid use of the `str.format()` method. The replacement field `{0}` refers to the first positional argument passed to `.format()`, which is the string `"World"`. Python substitutes `"World"` for `{0}`, producing `"Hello World"`; zero-based indexing means `{0}` is the first argument, so this line works correctly.

Correct. The `@final` decorator from the `typing` module is designed to indicate that a method should not be overridden. Although not enforced at runtime, it is recognized by static type checkers and is the standard Python feature for this purpose.

This constructs a new instance of the custom exception class immediately before raising it, passing the string "invalid" into the constructor. That value is stored in the instance's args attribute and can be retrieved in an except block, making it the standard, readable way to raise a user-defined exception with diagnostic detail.

Placing the try-except inside the for loop is the correct EAFP (Easier to Ask Forgiveness than Permission) pattern: each line is parsed individually, and a ValueError raised by int() (or float()) for a malformed literal is caught, logged, and skipped without terminating the loop. This preserves the required behavior of processing all remaining configuration lines, and catching the specific exception type avoids masking unrelated programming errors. The logging can include the offending line number via enumerate(f) to aid debugging.

The from-import statement directly fetches the 'calculate' attribute from the 'app.operations.math_ops' module and binds it in the current namespace. This is the most common and concise way to bring a function into scope, and it bypasses the need to reference the module path each time. The import system locates the module using the dotted path, then performs attribute lookup for the function.

Python treats a directory as a regular package only when it contains an __init__.py file, which executes on import and defines the package namespace. Namespace packages lack this file, so its presence is what distinguishes a regular package from that alternative.