PCAP Exam Questions and Answers

Raise NotImplementedError inside the method body

Raising NotImplementedError in the base method body makes any direct call fail immediately at runtime, forcing subclasses to provide their own implementation. This satisfies the stem's requirement that the method is not accidentally invoked on the base class.

Define a private class attribute (e.g., __shared) and provide a class method to access it

Defining `__shared` inside the class body but outside `__init__` puts it in the class namespace, and Python's name mangling rewrites it to `_ClassName__shared`, which discourages accidental external access. A `@classmethod` getter (for example `cls.__shared`) can return the value to all callers without exposing a writable descriptor; while a determined caller could still use the mangled name, the mangling plus getter signals that the attribute is private and read-only. This achieves shared state across every instance and gives a single controlled access point.

Method overriding

SavingsAccount redefines the inherited withdraw method with its own penalty logic while keeping the same signature, so Python dispatches to the subclass version at runtime. That substitution of a superclass method implementation is method overriding, not overloading or composition.

Polymorphism

Polymorphism (specifically subtype polymorphism) is correct because it allows a common interface or base-class reference to invoke different implementations depending on the actual runtime type. In a system handling different types, a single method call can be dispatched dynamically to the appropriate subclass override, which directly addresses the need for type-specific behavior. This is the OOP feature specifically designed to let objects of different classes respond to the same message in distinct ways.

The file handle is opened in the __init__ method of the base class

Opening the file handle inside __init__ assigns the result to an instance attribute (via self), so each time a new Logger or subclass object is created, a separate descriptor is opened and stored on that specific instance. Because the handle is not attached to the class object, no sharing occurs between instances. This directly contradicts the premise that a single logger's file handle is shared, making this the correct flaw in the developer's code.

Because name mangling renames the attribute to _MyClass__private, and the subclass implicitly accesses _MySubClass__private

In Python, any attribute name written with two leading underscores inside class MyClass is transformed at compile time to _MyClass__private, a process called name mangling. When the same spelling __private appears in the body of a subclass, the compiler uses the subclass's name, producing _MySubClass__private; since that attribute was never assigned, self.__private raises AttributeError. The base class value still exists, but only under the base-mangled key _MyClass__private.

Configure the repository URL in pip's configuration file or in requirements.txt.

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.

if __name__ == '__main__': run()

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.

if __name__ == '__main__': run()

This option is exactly equivalent to the standard guard in option A, and it is just as correct. Comparing `__name__` to the string literal '__main__' is the recognized, PEP 8-compliant way to determine whether a file has been executed directly rather than imported. The identical code appearing twice in the options does not change its validity; both instances pass because the interpreter sets __name__ consistently regardless of how many times the idiom appears.

sys.path.append('utils')

This is the correct fix because sys.path is a list of directories Python searches when resolving import statements. Appending 'utils' adds that directory to the end of the list, making any Python module or package inside it visible to the import system. Since the target module lives directly in utils, adding this directory allows 'import config' or a similarly named module to be found.

from formulas import calculate

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.

print(mypackage.__file__)

For an imported module, the `__file__` attribute stores the filesystem path of the source file from which the module was loaded. When `mypackage` is a package, its `__file__` points to the package's `__init__.py` file, which is exactly the location of the package on disk in most ordinary cases. This is the standard, programmatic way to determine where a package or module resides, making this option correct.

A module is a single .py file containing Python definitions and statements.

This is the definition of a module.

The __all__ variable defines the public API of a module or package.

__all__ controls what is exported with 'from module import *'.

Relative imports use dots to refer to the current and parent packages.

A single dot refers to current package, two dots to parent, etc.

FileNotFoundError

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.

open('file.txt', 'w')

The 'w' mode opens the file for writing and truncates it to zero bytes if it exists, or creates a new file if it does not. This makes it the standard choice for write operations that should replace the entire contents of the file. It is the correct mode here because it permits immediate writing to the file with the expectation that prior content will be discarded.

f.read(4)

Calling f.read(4) on a binary file opened with mode 'rb' reads at most 4 bytes from the current file position, returning them as a bytes object. This is precisely the intended operation for reading a fixed-size chunk, which is essential when parsing binary formats that store data in fixed-width fields, such as integers or headers. The size argument caps the read length, so the file pointer advances by exactly the number of bytes actually read, and it handles end-of-file gracefully by returning fewer than 4 bytes.

Division by zero

When the user enters '0', int('0') returns 0 without error, so the try block proceeds to evaluate 10 / 0. This expression raises ZeroDivisionError, and Python matches it to the except ZeroDivisionError clause, causing 'Division by zero' to be printed. The output is exactly that message, demonstrating that an exception raised by an arithmetic operation is handled by its specific handler.

It always executes, regardless of exceptions.

The `finally` block guarantees execution after the `try` block completes, whether an exception is raised, caught, or the block exits via `return`, `break` or `continue`. This satisfies the stem's requirement for a statement that is always true, since only `finally` provides unconditional cleanup semantics in Python.

except (FileNotFoundError, PermissionError):

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 a test. Is this a test?'.count('is')

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

def is_pal(s): s = ''.join(c for c in s if c.isalnum()).lower(); return s == s[::-1]

This is the correct palindrome checker because it first strips out every non-alphanumeric character with a generator expression and ''.join(), then lowercases the cleaned string. Comparing this normalized form to its extended-slice reverse s[::-1] accounts for spaces, punctuation, and mixed case in one clean pass. This is the robust, idiomatic approach expected for a general-purpose palindrome test.

str.isdigit()

str.isdigit() returns True only when the string is non-empty and every character has the Unicode Numeric_Type of Digit or Decimal, which includes ASCII '0'-'9', non-Arabic decimal digits, and compatibility superscripts such as '²'. This is the broadest check that still excludes letters, punctuation, and numeric fractions, so it is the correct method when the requirement is to verify that a string contains only digits.

re.sub(r'\bcat\b', 'dog', s)

The correct solution uses a raw-string regex pattern with word boundary anchors: `\b` at both ends ensures `cat` is only matched as a standalone word, not as a substring inside larger words like `category` or `bobcat`. `re.sub` then replaces every such whole-word occurrence globally, returning a new string with each standalone `cat` changed to `dog`, leaving all other text intact.

2

Indexing 'python' from zero gives p=0, y=1, t=2, h=3, o=4, n=5; the two-character substring 'th' begins at offset 2, where 't' resides and is followed immediately by 'h'. Python's str.find returns the lowest zero-based index at which the substring starts, so 'python'.find('th') evaluates to exactly 2. This is the correct result.

s = ('Line1\n' 'Line2')

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.

s = """Line1 Line2"""

This is correct because triple double quotes, like triple single quotes, let a string span multiple physical source lines while preserving the embedded line breaks exactly as typed. The resulting string contains a newline character at the end of the first line, so it behaves as a genuine multiline string. This syntax is the standard choice for docstrings and is also convenient for writing SQL or long formatted text blocks in code.

s = '''Line1 Line2'''

This is correct because triple single quotes allow a string literal to contain literal newline characters, meaning the physical line break between Line1 and Line2 is preserved as part of the string value. It is equivalent to writing 'Line1\nLine2' but is more readable when the string is long. Additionally, triple single quotes permit embedded single quotes without escaping, giving it flexibility for multiline text.