PCAP Exam Questions and Answers

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.

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.

import math as m

Correct syntax: `import math as m` imports the full math module with alias m.

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.

Use a virtual environment specific to your project and install your package there.

Using a virtual environment creates an isolated environment, ensuring your local package is used without affecting or being affected by the global package. This is the standard and most reliable approach.

Both mypackage/__init__.py and mypackage/subpackage1/__init__.py are executed.

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.

'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.

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.

str.startswith()

Returns True or False.

str.islower()

Returns True or False.

str.isalpha()

Returns True or False.

Use re.search(r'\bexcellent\b', review, re.IGNORECASE)

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.

str.split()

str.split() with no arguments splits on any run of whitespace, trimming leading and trailing spaces, and returns a list of non-empty substrings. For a log line like '2025-04-10 14:22:31 INFO message here', the timestamp (which contains no spaces) becomes the first element while the rest of the line is broken into subsequent elements, cleanly isolating the timestamp. It is the most direct method because it handles variable amounts of whitespace without requiring a separator to be specified.

result = s[::-1]

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.

result = ''.join(reversed(s))

This is correct: `reversed(s)` is a built-in function that returns a reverse iterator over the characters of `s`, and `''.join()` consumes that iterator, concatenating each character with an empty separator to form a new string. This approach works for any finite sequence, not just strings, and it is memory-efficient because the iterator yields characters lazily rather than constructing an intermediate list. The resulting expression is explicit and clear, making it a reliable way to reverse a string.

Raise NotImplementedError inside the method body

Raising NotImplementedError clearly signals the method must be overridden.

Method overriding

The subclass provides a specific implementation of the inherited method.

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.

Liskov Substitution Principle

The Liskov Substitution Principle (LSP) asserts that any subclass must be able to replace its base class without altering the correctness of the program. When Shape declares an abstract area() method, it establishes a behavioral contract that every subclass must honor; if a subclass overrides area() with an incompatible return type, raises an unexpected exception, or changes invariants, it breaks substitutability. This is exactly the design concern addressed by LSP, making it the correct principle for the described scenario.

class MyClass: pass MyClass.attr = 0

Assigns a class attribute after definition.

class MyClass: attr = 0

Defines a class attribute directly.

__getitem__ and __len__

According to the Python data model, a sequence is defined primarily by having a `__len__` method and a `__getitem__` method that accepts integer indices (and optionally slices). Together they give the object a finite length, support `obj[i]` indexing, and implicitly enable iteration via the old-style `__getitem__` fallback. On top of these two, the `collections.abc.Sequence` ABC automatically mixes in `__contains__`, `__iter__`, `__reversed__`, `index`, and `count`, showing how much behavior is derived from just these two methods.

Override __init__ to accept a message and call super().__init__(message).

This ensures the message is stored and displayed.

It always executes, regardless of exceptions.

Finally is guaranteed to run.

8080

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.

Step 1: Import the json module. Step 2: Create a Python dictionary. Step 3: Open a file in write mode. Step 4: Use json.dump() to write the dictionary to the file.

This sequence is correct because the json module must be imported before any of its functions, such as json.dump(), can be referenced. The Python dictionary must then exist as the data to be serialized, followed by opening a file in write mode to provide a writable file-like object. Only after the file is successfully opened can json.dump() be called, as it writes the serialized JSON directly to that open handle. Attempting to run json.dump() without an open file would raise a TypeError or AttributeError, so the given order ensures every dependency is satisfied before the critical call.

list: Mutable

A list is a mutable, heterogeneous sequence stored in a contiguous block of memory. Its mutability means you can modify it in place without creating a new object: assign to an index or slice, append, pop, insert, extend, or remove elements via methods like append() and pop(). Because the underlying memory address remains the same throughout such operations, lists are suitable as dynamic collections that need frequent structural changes.

dict: Mutable

A dict is a mutable, unordered mapping stored as a hash table. Its mutability enables in-place alteration of key-value bindings: you can assign d[key] = value to add or replace an entry, use del d[key] or pop() to remove one, and employ methods like update() and setdefault() to modify the mapping. Because the hash table is allocated and resized dynamically, the dict object identity persists through these mutations, making it an efficient key-based associative container.

string: Immutable

A string is an immutable sequence of Unicode code points. No operation can alter the characters of an existing str object; each method that appears to modify a string—such as replace(), upper(), or strip()—actually constructs and returns a new string, leaving the original intact. This immutability guarantees that strings can be safely hashed and shared across threads, and it enables internal optimizations like interning, though it also means repeated concatenation in a loop creates many intermediate objects, making ''.join() the preferred approach.

FileNotFoundError

FileNotFoundError is the specific built-in exception that Python raises when an attempt to open or access a file path cannot succeed because the path does not exist, typically with errno ENOENT. For a read operation, open(path, 'r') will immediately raise it if the file is not present before any other processing occurs. Because it is narrowly scoped, catching FileNotFoundError lets the developer provide exactly the right fallback—like creating the file or printing a meaningful message—without masking permission problems or unrelated OS failures.