PCAP Practice Test 15 — 15 Questions

Question 1

A team is developing a large application that consists of multiple components, each housed in separate directories. They want to organize these components under a common namespace package called 'app'. The directory structure is as follows:

/opt/project/
├── components/
│   ├── auth/         (contains __init__.py and modules)
│   └── billing/      (contains __init__.py and modules)
├── main.py
└── another_location/
    └── reports/      (contains __init__.py and modules)

The team wants to allow all these components to be imported as subpackages of 'app', e.g., 'import app.auth', 'import app.billing', 'import app.reports'. They have ensured that none of the directories named 'app' exist; instead, they plan to use namespace packages. They create a directory '/opt/project/app/' with an __init__.py file, and move the auth and billing directories under it. However, the reports directory must remain at '/opt/project/another_location/reports/', but they want it to be accessible as 'app.reports'. They attempt to achieve this by adding '/opt/project/another_location/' to the sys.path. When they run main.py, they get an ImportError: No module named 'app.reports'. The auth and billing modules work fine. What is the most likely issue and the correct fix?

Accepted Answer

The app directory has an __init__.py file, which prevents it from being a namespace package. Remove the __init__.py from the app directory.. Option A is correct because the 'app' directory has an __init__.py file, making it a regular package. Namespace packages must not have __init__.py in the top-level directory to allow extending via sys.path. Removing __init__.py from app/ turns it into a namespace package, allowing reports from another_location to be found. Option B is incorrect because subpackages can have __init__.py. Option C is incorrect because sys.path modifications are effective for the session. Option D is incorrect because namespace packages are designed to span multiple directories without moving files.

Answer

The sys.path modification is not persistent; they need to set the PYTHONPATH environment variable.

Answer

The reports package needs to be moved under the app directory physically.

Answer

The reports directory has an __init__.py file, which conflicts with the namespace package.

Question 2

Given that MyClass defines __private_attr in __init__, why does this error occur?

Accepted Answer

The attribute name is mangled to _MyClass__private_attr.. Python uses name mangling for double-underscore attributes: __private_attr becomes _MyClass__private_attr when accessed outside the class. The external code tries to access __private_attr directly, which is mangled, causing the attribute error.

Answer

The attribute was not defined in __init__.

Answer

Private attributes cannot be accessed outside the class.

Answer

The attribute is a class attribute not an instance attribute.

Question 3

When processing a large text file, a developer notices that using str.replace() in a loop is slow. Which alternative is most efficient for multiple replacements?

Accepted Answer

Use str.translate() with a translation table. Option C is correct because `str.translate()` with a translation table built by `str.maketrans()` performs all character replacements in a single pass over the string, operating at the C level in CPython. This avoids the O(n) per-replacement overhead of `str.replace()` in a loop, making it the most efficient choice for multiple, fixed-character substitutions on large text.

Answer

Use str.maketrans() on the original string

Answer

Use re.sub() from the re module

Answer

Chain multiple str.replace() calls

Question 4

An engineer is debugging an application that uses inheritance. The base class 'Vehicle' defines a method 'start()' that prints 'Vehicle started'. The subclass 'Car' overrides 'start()' to print 'Car started'. The code contains a function that accepts a Vehicle object and calls 'start()'. What is the output if a Car object is passed?

Accepted Answer

'Car started'. When a Car object is passed to a function expecting a Vehicle reference, Python uses dynamic dispatch (late binding) to call the overridden `start()` method defined in the Car class. Since the actual runtime type is Car, the overridden version executes, printing 'Car started'. This is a fundamental principle of polymorphism in Python.

Answer

'Car started Vehicle started'

Answer

'Vehicle started'

Answer

AttributeError

Question 5

A developer implements a custom exception class `DataError` that inherits from `Exception`. Which method override is essential to ensure the exception message is properly displayed when caught?

Accepted Answer

Override __init__ to accept a message and call super().__init__(message).. Option A is correct because the `Exception` class's `__init__` method stores the message argument in the `args` attribute, which is used by the default `__str__` method to display the message. By overriding `__init__` to accept a message and call `super().__init__(message)`, the custom exception properly passes the message to the base class, ensuring it is displayed when caught and printed.

Answer

Set the __cause__ attribute in __init__.

Answer

Override __str__ to return a formatted string.

Answer

Override __repr__ to return a detailed representation.

Question 6

A developer needs to extract the file extension from a string like 'report.pdf'. Which string method is most appropriate?

Accepted Answer

str.split('.')[-1]. Option B is correct because `str.split('.')[-1]` splits the string at each dot and returns the last element, which is the file extension. This method works reliably for simple cases like 'report.pdf' and is a common Python idiom for extracting extensions.

Answer

str.find('.')

Answer

str.partition('.')[2]

Answer

str.rstrip('.pdf')

Question 7

Which THREE of the following are true about the `with` statement for file handling?

Accepted Answer

It uses the __enter__ and __exit__ methods of the file object.. Option C is correct because the `with` statement relies on the context management protocol, which requires the object to implement the `__enter__` and `__exit__` methods. When a file object is used with `with`, its `__enter__` method returns the file object itself, and its `__exit__` method is called upon block exit to handle cleanup, such as closing the file.

Answer

It can only be used with files.

Answer

It can only handle one file at a time.

Question 8

A programmer wants to catch both `FileNotFoundError` and `PermissionError` with a single except clause. Which tuple is correct?

Accepted Answer

except (FileNotFoundError, PermissionError):. Option A is correct because Python's exception handling syntax allows a tuple of exception types in a single `except` clause, enabling the programmer to catch multiple exception types with the same handler. Both `FileNotFoundError` and `PermissionError` are subclasses of `OSError`, but using the tuple explicitly catches only those two specific exceptions, not all `OSError` subtypes.

Answer

except FileNotFoundError, PermissionError:

Answer

except OSError:

Answer

except [FileNotFoundError, PermissionError]:

Question 9

A Python script processes a log file line by line. If a line cannot be decoded due to an encoding error, the script should skip the line and continue. Which exception handling approach is best?

Accepted Answer

Inside the loop, wrap the line decoding in a try-except UnicodeDecodeError block and continue.. Option C is correct because it places the try-except block inside the loop, specifically catching `UnicodeDecodeError` for each line. This allows the script to skip only the problematic line and continue processing subsequent lines, which matches the requirement exactly.

Answer

Wrap the entire file reading in a try-except block without specifying exception type.

Answer

Use a try-except-else block to handle success and failure separately, exiting on failure.

Answer

Catch Exception in the outer loop and break on error.

Question 10

A developer is troubleshooting a Python application that fails to import a custom module named 'utils'. The file 'utils.py' exists in the same directory as the main script. Which of the following is the most likely cause of the import failure?

Accepted Answer

The directory containing utils.py is not in sys.path.. When Python imports a module, it searches for it in the directories listed in sys.path. Even if 'utils.py' is in the same directory as the main script, that directory may not be automatically included in sys.path if the script is not run as a module (e.g., using python main.py from a different working directory). The most common cause of such a failure is that the script's directory is missing from sys.path, which prevents Python from locating the file.

Answer

There is a circular import between utils.py and the main script.

Answer

The directory lacks an __init__.py file.

Answer

The utils.py file contains a syntax error.

Question 11

A Python program uses multiple inheritance. Class A defines method 'foo', class B also defines 'foo', and class C(A, B) inherits from both. The developer expects that calling 'foo' on an instance of C should invoke the method from class A. However, it invokes the method from class B. What is the most likely cause?

Accepted Answer

The method resolution order (MRO) is not as expected due to the order of base classes. Option A is correct because Python's Method Resolution Order (MRO) uses the C3 linearization algorithm, which respects the order of base classes as listed in the class definition. When class C(A, B) is defined, the MRO is C → A → B, so 'foo' from A should be found first. However, if the developer mistakenly wrote C(B, A), the MRO becomes C → B → A, causing B's 'foo' to be invoked. The question states the developer expected A's method but got B's, indicating the base class order was reversed.

Answer

Python always calls the method from the last base class

Answer

The 'foo' method in class B is defined after class A's 'foo' in the same file

Answer

Python uses depth-first, left-to-right resolution

Question 12

A team is developing a system that must handle different types of documents (PDF, Word, etc.). Each document type has a unique parsing method. To avoid massive conditional logic, which OOP concept should be applied?

Accepted Answer

Polymorphism. Polymorphism allows different document types (PDF, Word, etc.) to be treated uniformly through a common interface (e.g., a `parse()` method) while each class implements its own parsing logic. This eliminates the need for conditional statements (like `if type == 'PDF'`) because the correct method is resolved at runtime via dynamic dispatch, which is exactly what the team needs to avoid massive conditional logic.

Answer

Encapsulation

Answer

Inheritance

Answer

Abstraction

Question 13

A class 'Employee' has a method 'work()'. A subclass 'Manager' overrides 'work()' but also wants to call the parent's 'work()'. Which syntax correctly achieves this?

Accepted Answer

super().work(). Option B is correct because `super().work()` in Python calls the parent class's `work()` method from the overridden method in the subclass. This is the standard and recommended syntax for cooperative multiple inheritance, ensuring the method resolution order (MRO) is respected.

Answer

self.work()

Answer

super(Manager, self).work()

Answer

Employee.work(self)

Question 14

Which THREE of the following statements about Python packages and modules are true?

Accepted Answer

A module is a single .py file containing Python definitions and statements.. Option C is correct because a module in Python is defined as a single .py file that contains Python definitions, such as functions, classes, and variables, as well executable statements. This is the fundamental unit of code organization in Python, and any .py file can be imported as a module.

Answer

The sys.path list is read-only and cannot be modified at runtime.

Answer

A package must contain an __init__.py file to be importable.

Question 15

A developer creates a package named 'analytics' with the following structure:

analytics/
    __init__.py
    stats.py
    models/
        __init__.py
        regression.py

The developer wants the statement 'from analytics import *' to import only the functions 'mean' and 'std' from stats.py. What should be added to analytics/__init__.py?

Accepted Answer

__all__ = ['mean', 'std']. Option D is correct because in Python, the `__all__` variable in a package's `__init__.py` explicitly controls which names are exported when `from package import *` is used. By setting `__all__ = ['mean', 'std']`, the developer ensures that only the functions `mean` and `std` from `stats.py` are imported into the namespace, as Python will look up these names in the package's scope after executing the `__init__.py` file. This overrides the default behavior where all public names (those not starting with an underscore) would be exported.

Answer

Nothing; by default, all names are exported.

Answer

from analytics.stats import *

Answer

__all__ = ['stats.mean', 'stats.std']