PCAP Practice Questions

Question 1

A developer is implementing a custom exception for invalid data. Which class should the custom exception inherit from?

Accepted Answer

Exception. The `Exception` class is the base class for all built-in, non-system-exiting exceptions in Python. Custom exceptions should inherit from `Exception` (or one of its subclasses) to ensure they are caught by generic `except Exception:` handlers and integrate properly with Python's exception hierarchy, while avoiding the system-exiting exceptions derived from `BaseException`.

Answer

RuntimeError

Answer

ArithmeticError

Answer

BaseException

Question 2

A programmer has a string s = 'Python programming is fun'. They want to extract the word 'programming'. Which slicing expression achieves this?

Accepted Answer

s[7:18]. Python uses zero-based indexing. The word 'programming' starts at index 7 (the character 'p' in 'programming') and ends at index 17 (the character 'g'), but slicing is exclusive of the end index, so s[7:18] extracts characters from index 7 up to but not including index 18, which gives 'programming'.

Answer

s[6:18]

Answer

s[7:19]

Answer

s[6:19]

Question 3

A developer needs to check if a string contains only alphanumeric characters. Which string method should be used?

Accepted Answer

s.isalnum(). The `isalnum()` method returns `True` if all characters in the string are alphanumeric (letters or digits) and the string is non-empty. This directly matches the requirement to check for only alphanumeric characters, covering both letters and digits without any other characters.

Answer

s.isnumeric()

Answer

s.isdigit()

Answer

s.isalpha()

Question 4

A developer needs to format a floating-point number 123.456789 with exactly 2 decimal places and a width of 10 characters, right-aligned. Which format specifier accomplishes this?

Accepted Answer

:10.2f. The format specifier `:10.2f` combines a total width of 10 characters with exactly 2 decimal places for a floating-point number, right-aligned by default. The `f` type ensures fixed-point notation, and the width of 10 includes the decimal point and digits, padding with spaces on the left.

Answer

:.2f

Answer

:10.2g

Answer

:10.2e

Question 5

A programmer wants to create a class that cannot be instantiated directly, only through a factory method. Which approach should be used?

Accepted Answer

Override __new__ to raise an exception unless called from a classmethod factory.. Overriding `__new__` allows the programmer to control instance creation at the lowest level. By checking the call stack or a flag set by a classmethod factory, `__new__` can raise an exception when instantiation is attempted directly, while still allowing the factory method to create instances. This ensures the class cannot be instantiated directly, only through the designated factory.

Answer

Raise an exception in __init__ if called directly.

Answer

Define the class as abstract using ABC and @abstractmethod.

Answer

Use a metaclass to prevent instantiation.

Question 6

A team is developing a large Python application with multiple modules. They encounter an ImportError when module A tries to import from module B, and module B tries to import from module A. What is the most likely cause and best practice to resolve this?

Accepted Answer

Restructure the code to eliminate circular dependencies by extracting shared logic into a third module.. Circular imports occur when two modules depend on each other at the top level, causing an ImportError due to incomplete module initialization. The best practice is to restructure the code to eliminate the circular dependency, typically by extracting the shared functionality into a third module that both A and B can import without mutual dependence. This approach aligns with Python's module loading mechanism, which executes a module fully before making its names available for import.

Answer

Use 'from module import *' to bring all names into the namespace.

Answer

Use lazy imports (inside functions) to defer the import until runtime.

Answer

Move all imports from module A to the bottom of the file.

Question 7

A team is using a shared Python environment where multiple projects have conflicting dependencies. Which approach is the best practice to isolate project dependencies?

Accepted Answer

Create a virtual environment using 'python -m venv' and install dependencies inside it.. Using `python -m venv` creates an isolated virtual environment with its own `site-packages` directory, preventing dependency conflicts between projects. This is the standard best practice recommended by the Python Packaging Authority (PyPA) for managing project-specific dependencies without affecting the system-wide Python installation.

Answer

Manually modify sys.path in each script to include different package directories.

Answer

Install all dependencies in the system-wide site-packages directory.

Answer

Install all packages using 'pip install --user' to avoid system conflicts.

Question 8

A developer creates a package 'mypackage' with the following structure:

mypackage/
  __init__.py
  module1.py
  module2.py

The __init__.py contains:

from mypackage.module1 import func1
from mypackage.module2 import func2

__all__ = ['func1', 'func2']

In a separate script, the developer writes:

from mypackage import *
print(func1())

This works as expected. However, when the developer runs the same script from a different directory (not the one containing mypackage), the import works but the script prints an error that func1 is not defined. What could be the problem?

Accepted Answer

The mypackage directory lacks proper __init__.py (maybe it is not present or invalid), causing it to be treated as a namespace package, and the __init__.py is never executed.. If the `mypackage` directory is found but its `__init__.py` is missing, invalid, or not executed (e.g., due to being a namespace package in Python 3.3+), the `from mypackage import *` statement will not trigger the imports defined in `__init__.py`. Consequently, `func1` and `func2` are never bound in the package namespace, leading to a `NameError` when the script tries to call `func1()`. This scenario occurs when the package is located via `sys.path` but the `__init__.py` is not properly processed, often because the directory is treated as a namespace package (PEP 420) rather than a regular package.

Answer

The current working directory is not in sys.path, so the package cannot be found.

Answer

The __all__ variable hides func1 because it does not include it, but it does.

Answer

The imports in __init__.py are relative imports and fail when run from a different directory.

Question 9

What is the value of matches?

Accepted Answer

['Alice', 'Bob']. The `re.findall(r'[A-Z][a-z]*', 'Alice and Bob are friends')` call matches all sequences starting with an uppercase letter followed by zero or more lowercase letters. This yields 'Alice' and 'Bob', as they are the only words beginning with a capital letter. The result is a list of those two strings.

Answer

['Alice']

Answer

['Alice', 'and', 'Bob', 'are', 'friends']

Answer

['Alice', 'Bob', 'friends']

Question 10

A developer writes a script to read a configuration file that may not exist. The script should handle the error gracefully and continue. Which approach is most Pythonic?

Accepted Answer

Use a try-except block catching FileNotFoundError. It directly catches the specific `FileNotFoundError` exception, which is a subclass of `OSError` and is raised when a file does not exist. This approach follows the Pythonic principle of EAFP (Easier to Ask for Forgiveness than Permission), allowing the script to attempt the operation and handle the failure gracefully without redundant checks.

Answer

Use a try-except block catching OSError

Answer

Use os.path.exists to check, then open if it exists

Answer

Use an if statement to check file size

Question 11

When importing a module, Python searches for it in a specific order. Which of the following lists the correct order of directories searched?

Accepted Answer

[current directory] then PYTHONPATH then site-packages. When Python imports a module, it first searches the directory containing the input script (or current working directory), then iterates through the directories listed in the PYTHONPATH environment variable, and finally checks installation-dependent default paths such as site-packages. This order is reflected in sys.path, which is built from the script directory, PYTHONPATH entries, and default site-packages. Option B accurately lists this sequence: current directory, then PYTHONPATH, then site-packages.

Answer

PYTHONPATH then sys.path

Answer

sys.path + [current directory]

Answer

[current directory] + sys.path

Question 12

Which THREE of the following are valid ways to import a function named 'calculate' from a module named 'math_ops' located in a subpackage 'operations' of a package 'app'?

Accepted Answer

from app.operations.math_ops import calculate. It uses the standard Python import syntax to directly import the 'calculate' function from the 'math_ops' module, which is located in the 'operations' subpackage of the 'app' package. This is the most straightforward and recommended way to import a specific attribute from a module.

Answer

import app.operations.math_ops.calculate

Answer

from app.import operations.math_ops import calculate

Question 13

You are working on a legacy system that processes financial transactions. The system uses a class hierarchy: Transaction (base), Deposit, Withdrawal, Transfer. Each subclass overrides a method 'process()' to handle its specific logic. The code often runs in a multi-threaded environment and you notice intermittent errors where a transaction is processed twice. The logging shows that the same transaction object is being passed to the process method multiple times. The transaction objects are created from a factory function that caches recently used transactions. The errors seem to occur when two threads call the factory at the same time with the same parameters. After investigating, you find that the factory uses a class-level dictionary to cache objects. Which of the following is the most appropriate solution to prevent double processing?

Accepted Answer

Make the process() method idempotent by checking if the transaction has already been applied to the account (e.g., check balance changes). The core issue is that the same transaction object can be processed multiple times in a multi-threaded environment, even if the factory is fixed. Making process() idempotent by checking whether the transaction has already been applied (e.g., verifying account balance changes) ensures that repeated calls with the same object do not cause duplicate financial effects, directly addressing the symptom of double processing regardless of how the object is cached or retrieved.

Answer

Add a lock around the cache lookup and creation in the factory function

Answer

Add a flag to each transaction object to indicate if it has been processed, and check it at the start of process()

Answer

Remove the caching mechanism from the factory function to ensure new objects are always created

Question 14

A developer uses the .index() method on a string to find the position of a substring. If the substring is not found, what exception is raised?

Accepted Answer

ValueError. The `.index()` method on a string raises a `ValueError` when the specified substring is not found. This is because `ValueError` is the standard Python exception for cases where a function receives an argument with the correct type but an inappropriate value, such as a substring that does not exist in the target string.

Answer

KeyError

Answer

IndexError

Answer

TypeError

Question 15

A programmer wants to restrict a class to only allow specific attribute names and reduce memory usage. Which feature should they use?

Accepted Answer

Define `__slots__` as a tuple of allowed attribute names.. Defining `__slots__` as a tuple of allowed attribute names restricts the class to only those attributes, preventing the creation of a per-instance `__dict__` and thereby reducing memory usage. This is a built-in Python mechanism that overrides the default dynamic attribute storage, making it ideal for memory-constrained applications.

Answer

Override `__init_subclass__` to enforce restrictions.

Answer

Use @property for every attribute.

Answer

Define `__dict__` as a class variable.

Certified Associate Python Programmer PCAP practice test

Three ways to study

Study PCAP by domain

Study PCAP by topic

Object-Oriented Programming practice questions

Modules and Packages practice questions

Exceptions and File I/O practice questions

Strings practice questions

PCAP fundamentals practice questions

PCAP scenario practice questions

PCAP troubleshooting practice questions

Top PCAP questions

Certified Associate Python Programmer PCAP practice questions