Certified Associate Python Programmer PCAP (PCAP) — Questions 151–225

An editable install for 'lib' registers the source directory via a .pth file or an .egg-link file, which adds that directory to sys.path. If the source directory was moved after the editable install, the recorded path becomes stale; alternatively, a leftover .egg-link from an earlier install can point to the old location. Re-running pip install -e should update this, but if it happened before the move or was interrupted, the import mechanism will still reference the old copy, so changes in the current directory are ignored.

The csv module implements RFC 4180 quoting rules, so its reader correctly treats commas inside double-quoted fields as literal data rather than delimiters. Passing the single line in a list yields the parsed fields, and csv ships with the standard library.

`__eq__` is the correct special method to override for the equality operator (`==`) in Python. By implementing `__eq__` in the `Point` class, you can compare two point instances based on their coordinate attributes (e.g., `self.x == other.x and self.y == other.y`) rather than by their identity. This is the standard, documented approach for value equality in Python's object model.

Decorating `make_sound` with `@abstractmethod` inside a class inheriting from `ABC` registers it as abstract, so Python raises `TypeError` when any subclass omits the override or when `Animal` itself is instantiated. This directly enforces the stem's requirement that every subclass implement `make_sound`.

Python's find() returns the lowest index of the substring within the string, or -1 when absent, which is exactly the specified behaviour. index() raises ValueError instead of returning -1, and count() or search() do not return positional indices.

This doubles every single quote, which is the standard SQL way to include a literal quote inside a string: the DBMS sees '' as an escaped quote and does not treat the second quote as the end of the literal. By replacing all occurrences of ' with '', every potentially dangerous quote is neutralized, preventing break-out SQL injection when building queries from unsanitized input.

`__init__` is a special (dunder) method automatically invoked by Python when an instance is created, initialising the object's attributes. It satisfies the stem's requirement for special methods, which are defined by reserved double-underscore names and called implicitly by the interpreter rather than by explicit invocation.

pip index versions pandas is correct because it contacts the configured package index (PyPI by default) and fetches the release history for the pandas project, listing every available version in ascending order. This is the only option that actually asks the remote index about versions, and it is the pip-native way to check which releases exist before installing or pinning one. Note that this subcommand is experimental, but it is still the right choice among the four.

For s = 'Python', s[1:4] returns 'yth' because Python string indices are zero-based and slice end points are exclusive. The characters are P(0), y(1), t(2), h(3), o(4), n(5), so the slice takes positions 1, 2, and 3. Those positions spell 'y', 't', 'h' in order, giving exactly 'yth', which is the correct answer.

This is the correct approach because it deliberately catches only UnicodeDecodeError, which is the exception raised when reading and decoding bytes containing invalid UTF-8 or another specified codec. By logging a warning and doing nothing else, the handler reports the problem while allowing the surrounding loop to move on to the next uploaded file. More specific handlers like this leave unrelated exceptions—such as OSError or file-system errors—free to propagate, preserving their diagnostic value.

This is a correctly formed f-string: the f prefix is directly attached to a single-quoted string literal, and each pair of curly braces contains an expression to be evaluated at runtime. Python inserts the values of the variables 'name' and 'age' into the string, converting them with their __format__ methods. The single quotes wrap the entire literal, making the syntax valid per PEP 498.

Using `from None` in a `raise` statement sets the `__suppress_context__` attribute of the exception to `True`. When the TypeError propagates, Python's default exception handler checks this flag and, because it is true, omits the implicit display of the original ValueError and its traceback. The final output therefore contains only the TypeError, either in the interactive shell or in a captured traceback.

IsADirectoryError is raised when the operating system reports that a path expected to be a regular file is actually a directory. Catching it by name lets the script log a specific message for that condition while allowing FileNotFoundError to fall through to its own handler. This directly satisfies the requirement to distinguish the two failures.

In an f-string, expressions inside braces are evaluated and replaced with their string representation, so {name} becomes 'Alice' and {age} becomes '30'. The surrounding literal text ' is ' and ' years old.' is preserved verbatim, giving the exact concatenation 'Alice is 30 years old.'. This matches the expected output because the variable `name` holds the string 'Alice', and the integer `age` is 30.

The MRO for D is D, B, C, A, so `super()` inside B resolves to C, not A. B's `super().method()` therefore invokes C's method, which prints 'C' after its own `super()` call reaches A and prints 'A'. Control then returns to B, printing 'B', yielding A C B.

str.startswith() is a predicate method: it evaluates the string against a condition and returns the boolean value True if the string begins with the given prefix, otherwise False. It also accepts optional start and end index arguments to scope the check, and can take a tuple of prefixes to test multiple alternatives at once. Because its entire purpose is to answer a Yes/No question about string content, it is one of the methods that truly returns a bool.

rindex() performs a right-to-left search but still returns the index of the match as measured from the left end of the original string. If the substring is not present, rindex() raises a ValueError, which is exactly the exception behavior that makes it a correct answer. It mirrors index() in its error semantics, differing only in the search direction.

Immutability is a core property of Python strings: there is no in-place operation that modifies the characters or length of an existing str. Concatenation, for example with s1 + s2, does not extend s1; it allocates a new string whose content is the combined characters, leaving both operands untouched. This guarantee makes strings safe to use as dictionary keys and allows the interpreter to share or cache them.

A package can contain subpackages. This is correct because packages are essentially directories that map to importable namespaces, and those directories can contain other package directories. When a package directory contains an `__init__.py` (or qualifies as a namespace package), its subdirectories with `__init__.py` become subpackages, allowing hierarchical imports such as `import parent.child.module`. This nesting is fundamental to organizing large projects into logical, reusable components without forcing every module to live at the top level.

The slice s[::-1] uses a negative step with default start and end, which makes Python traverse the string from the last character back to the first, producing the reversed string. Comparing this reversed result to the original string with == correctly determines whether s reads the same forward and backward, i.e., whether it is a palindrome.

s.isalnum() exactly implements the required test: it returns True only for non-empty strings where every character is a Unicode letter or digit, accepting both 'hello123' and accented letters like 'café'. It also recognizes Unicode digits such as '١' while correctly rejecting spaces, punctuation, and symbol characters like '#' or '!'. Because the condition is precisely that the string contains only alphanumeric characters, this is the correct method and also implies that isalpha() or isdigit() would be too restrictive individually.

This is the correct form for explicitly chaining a new exception to an existing one. The `from original_exception` clause makes Python assign the original to the new `ValueError`'s `__cause__` attribute, causing the traceback to present the original as the direct cause of the new exception. This preserves the debugging information from the original failure while still allowing a distinct exception type to be raised.

This expression builds a list containing only the digit characters from the input and then compares its length to 10. It therefore passes any string that contains exactly ten digits, regardless of additional letters, spaces, hyphens, or punctuation, because non-digits are simply filtered out before counting. This precisely matches the requirement to validate that user input contains ten digits without insisting on a specific format.

A normal string literal is parsed by the Python compiler before any code executes, and every backslash must form a legal escape sequence. `\U` is the escape prefix for a 32-bit Unicode code point and must be followed by exactly eight hexadecimal digits; here it is truncated, so the tokenizer raises `SyntaxError: (unicode error) ... truncated \UXXXXXXXX escape` at compile time. Consequently, no program output or file operation ever occurs.

This is the canonical Python syntax for importing one or more specific names directly into the current namespace. When you write `from module import name1, name2`, Python loads the entire module, but only the named attributes become local bindings—`name1` and `name2` are immediately accessible without any module prefix. This form gives you precise control over which objects you bring into scope, avoiding all extraneous names and clearly documenting the dependencies of your code.

This is the canonical pattern: the library base class derives from Exception, so all library errors are ordinary, catchable exceptions; the specific subclasses then derive from that base class. Code catching LibraryError will also catch FileError and ParseError, while code can still catch either refined type independently. This gives a consistent API and lets the library evolve by adding new specific errors without breaking callers that rely on the base type.

The \b word boundary anchors ensure that 'excellent' is matched only when it stands as its own word, not as a substring of a larger token, while the re.IGNORECASE flag makes the match case-insensitive. Because re.search scans the entire string but the boundary restricts the match position, this option correctly finds 'Excellent', 'excellent.', and 'excellent' while rejecting 'unexcellent'. This is the only approach that combines whole-word semantics with case-insensitive matching in a single call.

The join() method is invoked on the separator string, and it takes an iterable of strings as its argument. For example, ','.join(['a', 'b']) returns 'a,b' by inserting the separator between each pair of elements. The separator string is not modified; it is reused as the delimiter, and every element in the iterable must be a string or a TypeError will be raised.

The f-string's placeholders are evaluated at runtime: {name} is replaced by the value of the variable name, which is 'Alice', and {age} is replaced by the value of age, which is 30. The resulting concatenated string matches exactly this output, making it the correct answer.

This is the standard, reproducible way to make Python's packaging tooling use a private or alternate repository: specify an index URL via index-url or extra-index-url in pip.conf, or use a fully-qualified requirement line (e.g., --extra-index-url) in requirements.txt. During installation, pip queries the configured indexes, resolves the complete dependency graph, and installs the package plus all of its dependencies into site-packages as wheel or sdist distributions. This method respects version constraints, generates proper distribution metadata, and works consistently across environments because the configuration is declarative and versionable.

The mode string 'wb' is the correct Python file mode for binary writing. The first character 'w' specifies the operation (write), and the second character 'b' explicitly selects binary mode rather than text mode. This mode both creates the file if it does not exist and truncates it to zero length if it does, allowing you to write raw bytes without any encoding or newline translation.

Wrapping only the write operation in a try/except that specifically catches OSError is the correct pattern: OSError is the parent class of errors like disk full, permission denied, and other I/O failures, so it captures the exact failure mode. Falling back to sys.stderr preserves the log entry and keeps the application running; if stderr itself fails, you can chain another exception or silently drop the record, but the primary failure is isolated. This targeted fallback also avoids hiding non-I/O bugs, unlike a global exception handler.

Passing a space as the argument restricts strip() to that character set only, so leading and trailing spaces are removed while tabs, newlines and other whitespace remain intact. The bare strip() call would strip all whitespace types, violating the stated requirement.

When t = s executes, both variables reference the same immutable string object containing 'Python'. Later, s = s + '3.0' creates a new string object and rebinds only s; t remains bound to the original object. Therefore printing t outputs 'Python'.

This is the canonical Python idiom for conditional execution. The interpreter assigns the special variable __name__ the value '__main__' only when the source file is run directly as the main program (e.g., `python my_module.py`). When the file is imported as a module, __name__ becomes the module's fully qualified name, so the equality check fails and run() is not invoked, allowing safe import without side effects.

ValueError is a built-in exception and belongs to the Exception hierarchy, directly under Exception (and ultimately under BaseException). It is raised when a function receives an argument of the correct type but an inappropriate value—for example, int('abc') raises ValueError because the string cannot be converted to an integer. This distinguishes it from TypeError, which is for wrong types, and from other built-in exceptions that signal different error conditions.

This is correct because the code reads the configuration value and converts it to an integer using int() (or a ConfigParser getint() call). The integer 8080 is then passed to print(), which displays the number without quotes. Since the conversion succeeds, the output is exactly the integer 8080.

Correctly counts overlapping? No, count does not count overlapping, but 'is' appears at positions 5 and 17, not overlapping, so returns 2.

Invalid JSON is correct because the file exists and is readable, but its content cannot be parsed by json.load() or json.loads(). The json module raises json.JSONDecodeError, a subclass of ValueError, when the data does not conform to JSON syntax. The program's except block catches this exception, confirming the specific outcome is "Invalid JSON" rather than any file-system error.

This is correct because Python implicitly concatenates adjacent string literals at compile time. The expression ('Line1\n' 'Line2') produces the single string 'Line1\nLine2', where \n is a single escape character representing a line break. When printed, the result appears on two lines, so it is a valid multiline string. The parentheses are not required but help break long lines for readability.

This is the correct result after executing both operations in sequence: first, replace("Hello", "Hi") changes the string to "Hi, World!"; second, upper() converts every alphabetic character to uppercase, producing "HI, WORLD!". The order of the chain matters—the replacement happens before case conversion, so the greeting becomes "HI" instead of "HELLO", matching the exhibited output exactly.

Assigning `property(getter, setter)` as a class variable directly creates a data descriptor that manages a specific attribute. Because `property` is a class implementing `__get__` and `__set__`, Python calls the supplied getter and setter functions whenever the attribute is accessed or assigned. This functional form is valid and is equivalent to the decorator form, though less commonly used in modern code.

This is correct because it explicitly tests each character against the exact set of valid hexadecimal digits, '0123456789abcdefABCDEF', using the all() function with a generator expression. Every character in s must be a member of that set for the expression to evaluate to True. One subtlety is that all() returns True for an empty string, so if an empty input should be considered invalid, an additional length check is needed.

OSError is the base class for I/O failures such as a device being unplugged, and read() raises it when the underlying read fails. Catching OSError around the read allows a bounded retry loop for this transient hardware problem, while still letting unrelated errors propagate. Because FileNotFoundError and PermissionError inherit from OSError, the handler should inspect errno or use a narrower subclass if those must be handled differently.

importlib.import_module(mod_name) is the correct way to dynamically load a module when its name is only known at runtime, because it accepts a string and returns the corresponding module object while registering it in sys.modules. It uses the standard import machinery, supports both absolute and relative imports (with a package argument), and is designed exactly for this programmatic use case. This makes it the appropriate replacement for older, deprecated functions like load_module.

Every Python class exposes a read-only __mro__ attribute that is a tuple of classes in the exact order Python will search for attributes and methods. The tuple starts with the class itself, then its ancestors in C3-linearized order, and ends with object. This attribute is the canonical way to inspect the method resolution order, for example by printing MyClass.__mro__.

The str.center(width, fillchar) method returns a new string of length width, with the original string centered and padded with the specified fill character. For 'Alice' and width 20, the total padding is 15 characters. Python puts the extra padding on the right when the padding is odd, resulting in 7 asterisks on the left and 8 on the right, exactly as required.

Static methods are not bound to either an instance or the class, so Python passes no implicit first argument when they are invoked. Unlike instance methods which receive self or class methods which receive cls, a static method's signature matches exactly what is written in the function definition. This makes them behave like ordinary functions, but they still live in the class's namespace.

s[1::2] begins at index 1 (the first digit character '1') and then takes every second character thereafter, with no explicit stop so it runs to the end of the string. Indices 1, 3, and 5 correspond to '1', '2', and '3', respectively, so the result is exactly '123'. This is the correct expression because it isolates the digits that are positioned at odd indices.

This is the correct explanation. Python searches the directories and zip files listed in sys.path in order, and for a dotted import like 'common.helpers', it looks for a package (a directory with __init__.py) named 'common' in each path entry. If an earlier sys.path entry contains a different 'common' package that lacks a 'helpers' submodule, Python imports that shadowing package and then attempts to find 'helpers' within it, raising ModuleNotFoundError before ever reaching the intended /opt/app/common/ package. This is a classic path-shadowing bug that causes the real file to be completely ignored.

Multiple inheritance is a first-class feature in Python: class Derived(Base1, Base2) creates a class that inherits attributes and methods from all listed base classes. To resolve conflicts, Python computes a linearization order (MRO) using the C3 algorithm, which determines the sequence in which base classes are searched for attributes. This MRO also enables cooperative behavior with super(), making mixin classes a common and safe pattern, though diamond hierarchies require deliberate design.

For a directory to be a regular package, Python requires a valid `__init__.py`; when that file is missing, Python 3.3+ treats the directory as a namespace package. A namespace package executes no initialization code, so the `from mypackage.func1 import func1` lines that would normally populate the package namespace never run. The package is still importable, but it appears empty — exactly matching the failure to find `func1` while `import mypackage` succeeds.

The replace error handler substitutes the Unicode replacement character U+FFFD wherever the decoder encounters an invalid sequence. The resulting string is valid and the read does not raise, so the tool can search for U+FFFD to count and locate suspect regions. This matches the requirement to continue processing while recording that replacement occurred.

KeyboardInterrupt is a true statement because KeyboardInterrupt is a direct subclass of BaseException, not of Exception. This design ensures that a KeyboardInterrupt triggered by Ctrl+C propagates outward even when code has a broad `except Exception:` handler. Catching it accidentally would prevent clean interruption and could leave the program in an inconsistent state, so it must be caught explicitly with `except KeyboardInterrupt` or a bare `except:`. The hierarchy deliberately places user-initiated termination outside the ordinary exception family.

setup.py is the standard configuration and build script for Python packages, used by setuptools (or distutils) to define all distribution metadata—such as the package name, version, description, authors, and, crucially, dependencies via the `install_requires` keyword. When a developer runs commands like `python setup.py sdist` or `bdist_wheel`, this file is the source of truth for what goes into the package and what dependencies it declares, making it the correct place to specify the dependency on the other custom module.

lstrip() returns a copy with leading whitespace characters removed, leaving trailing and internal whitespace untouched. This matches the stem's constraint precisely, since only leading spaces, tabs and newlines must be stripped, and lstrip() is a built-in string method requiring no import.

The abc module in Python's standard library supplies the ABC metaclass-derived helper class and the abstractmethod decorator for defining abstract base classes. Marking a method with @abstractmethod forces any concrete subclass to implement it before it can be instantiated; attempting to instantiate an unfinished subclass raises TypeError. This gives developers a robust mechanism for enforcing interface contracts in a dynamically typed language.

This is the correct implementation because self.count += 1 is syntactic sugar for self.count = self.count + 1, which rebinds the instance attribute to its own current value plus one. The method receives the instance through the mandatory self parameter, so each call persists the updated count on the object. This follows the standard pattern for mutating instance state and produces the expected cumulative behavior across multiple calls.

This option incorrectly treats current directory, PYTHONPATH, and site-packages as three distinct search locations, whereas all are simply elements of the single sys.path list. The current directory (specifically the script's directory) is placed at sys.path[0], and PYTHONPATH directories are added immediately after it, while site-packages appears later, but the interpreter never performs separate 'phases' for these; it linearly walks the combined sys.path list. Moreover, the phrase 'current directory' is imprecise because Python uses the script's directory for file execution, not the process's current working directory.

This is true: the import system walks through the directories and zip archives listed in `sys.path` sequentially, and the first entry that contains the requested module (or package) is used; Python does not continue searching later entries for an alternative. This is why the order of `sys.path` is critical—adding a directory to the front can shadow a standard-library module or another installed package. If no matching module is found, an `ImportError` is raised after the entire list has been exhausted.

s.strip() correctly removes whitespace from both the beginning and the end of the string. For example, ' hello '.strip() returns 'hello', eliminating the leading and trailing spaces. Because it precisely matches the requirement, and because strings are immutable, it returns a new stripped string rather than modifying the original.

A class variable is defined directly in the class body, making it part of the class namespace and shared by all instances of that class. It can be accessed via ClassName.variable or through an instance (unless shadowed by an instance attribute), and changes made through the class are visible to every instance. This matches the requirement for a class attribute that is common to the class rather than per-instance.

Calling super().__init__(account_number, balance) immediately at the start of SavingsAccount.__init__ delegates construction of base-class attributes to Account, preserving its invariants and any additional logic it performs. After the delegate call, assigning self.interest_rate = rate adds the subclass-specific attribute. This is the canonical cooperative-inheritance pattern and ensures the object is fully initialized before it is used.

When importing `mypackage.subpackage1`, Python executes the `__init__.py` of each package along the dotted path to initialize them as proper packages. This happens because the import system processes each component sequentially: first `mypackage` is imported, which runs its `__init__.py`, then its submodule `subpackage1` is imported, which runs its own `__init__.py`. This two-step initialization is fundamental to Python's package system, ensuring parent packages are fully loaded before their subpackages.

On the first import of a module, Python's import system compares the source file's timestamp or hash against any existing cached bytecode; if no matching `.pyc` exists, it compiles the module and writes the resulting bytecode into the `__pycache__` directory. This occurs transparently as part of the import machinery, with no explicit user action, and it does not apply to the top-level script executed with `python script.py`—only to modules that are imported.

Correct. The format specifier `.2f` is a dot (precision marker) followed by `2` (the number of digits) and the fixed-point type `f`. This tells Python to render `value` as a float rounded to exactly two decimal places, so 3.14159 becomes `3.14`. This is the official way to force a fixed number of digits after the decimal point in f-string formatting.

`import math as m` is the correct and idiomatic way to import the `math` module while binding it to the local name `m`. The `as` clause in an import statement creates an alias for the module object, so every subsequent reference to `m` (such as `m.sqrt(2)`) accesses the `math` module's functionality without needing to type the full module name. This is a standard feature of the import system, commonly used to shorten long module names or avoid name conflicts.

startswith() is the correct and idiomatic Python string method for checking whether a string begins with a given prefix. It accepts a single string, a tuple of strings, or optional start and end indices, returning True if the string starts with the specified prefix and False otherwise. Its behavior is case-sensitive, and it is implemented in C for efficiency, making it the standard tool for this common validation task. This is the only method among the options that actually exists and performs the required check.

startswith() is a boolean predicate that returns True exactly when the string's prefix matches the supplied prefix, optionally constraining the check with the start and end index arguments. It never modifies the original string and its only meaningful return values are True and False, making it one of the two methods that answer the question correctly.

A static method receives no implicit first argument, so `Logger.log('msg')` and `logger.log('msg')` both call the same function with identical arguments and identical results. Since the method does not need instance state, the absence of `self` is not a problem, and there is no unused `cls` parameter to confuse callers. This exactly matches the requirement of identical behaviour from both the class and an instance.

This is the correct and idiomatic way to import exactly one function from a module. It binds the name `calculate` directly in the current namespace, so you can call `calculate(...)` without a module prefix, and it avoids pulling in the entire `formulas` module as a separate local name. This form also makes the dependency explicit, which improves readability and reduces the risk of accidentally shadowing other names.

Polymorphism allows objects of different classes that share a common abstract base to be used interchangeably, with the correct override of `pro` invoked dynamically at runtime. Because `pro` is abstract, each concrete subclass must provide its own implementation, and the Python runtime dispatches to the specific version based on the actual object type. This is precisely the concept the question is testing.

Specific exceptions allow callers to catch precisely the conditions they can handle, using except clauses that match the exception type. Without distinct types, you would have to inspect messages or attributes, which is brittle and error-prone. Thus, raising a specific exception class is warranted when different error conditions require different handling, because the exception type itself becomes part of the API contract.