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

Which THREE statements about inheritance in Python are correct?

Accepted Answer

A child class inherits all attributes and methods from its parent class.. In Python, a child class inherits all non-private attributes and methods from its parent class by default. This includes both data attributes and methods, allowing the child to reuse and extend the parent's behavior without redefinition. Private attributes (with double underscore prefix) are name-mangled to _Classname__attribute, but they are still inherited in the sense that they exist in the child's namespace under the mangled name, though direct access by the original name is restricted.

Answer

Private attributes (with __) are inherited unchanged.

Answer

Python supports method overloading based on parameters.

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

An application uses a heavy-weight class DatabaseConnection that establishes a network connection upon instantiation. The class is used in multiple places, and the developer wants to ensure that only one instance of DatabaseConnection exists throughout the application. They implement a Singleton pattern using a class attribute _instance and a class method get_instance(). However, they notice that the network connection is being established multiple times. After debugging, they find that the singleton is not being enforced because the __init__ method is called every time the class is instantiated, even if the same instance is returned. They want to fix this so that the connection is established only once. Which modification should they make?

Accepted Answer

Override __new__ in DatabaseConnection to control instance creation and return the singleton from there, bypassing __init__ on subsequent calls.. Overriding __new__ allows the developer to control instance creation at the lowest level. By checking if the singleton already exists in __new__, they can return the existing instance without calling __init__ again, thus preventing the network connection from being established multiple times. This is the standard Pythonic way to implement a singleton that avoids reinitialization.

Answer

Use the @staticmethod decorator on get_instance.

Answer

Use a global variable instead of a class attribute to store the singleton.

Answer

Move the connection initialization code out of __init__ and into a separate method that is called only once.

Question 7

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).. 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 8

A developer creates a Python class with a method that is intended to be overridden in subclasses. Which approach best ensures that the method is not accidentally called on the base class?

Accepted Answer

Raise NotImplementedError inside the method body. Raising NotImplementedError inside the base class method is the standard Python idiom for defining an abstract-like method that must be overridden in subclasses. If a subclass fails to override the method and it is called, Python will raise an explicit error at runtime, preventing accidental use of the base implementation. This approach enforces the contract that the method is intended only for subclasses, without requiring the `abc` module.

Answer

Use 'pass' as the method body

Answer

Delete the method from the base class using 'del'

Answer

Add a comment '# override in subclass' inside the method body

Question 9

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 10

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 11

What is the output of the following code?

try:
    exec('1/0')
except:
    print('error')
else:
    print('no error')
finally:
    print('done')

Accepted Answer

error done. The `exec('1/0')` raises a `ZeroDivisionError`, which is caught by the bare `except:` clause, printing 'error'. The `else` clause is skipped because an exception occurred, but the `finally` clause always executes, printing 'done'. Thus the output is 'error' followed by 'done'.

Answer

done error

Answer

error

Answer

done

Question 12

Consider the code fragment: 
    f = open('data.txt', 'r')
    data = f.read()
    process_data(data)
    f.close()
What is the primary risk if an exception occurs during process_data(data)?

Accepted Answer

The file descriptor may be leaked because the close() call is skipped.. If `process_data(data)` raises an exception, the `f.close()` statement is never executed, leaving the file descriptor open. This is a resource leak that can exhaust system file handles, especially in long-running applications. Python's `with` statement is the recommended approach to guarantee automatic cleanup even when exceptions occur.

Answer

The exception will be silently suppressed.

Answer

The file will be automatically closed by Python's garbage collector immediately.

Answer

The file contents will be corrupted.

Question 13

Which THREE of the following statements about Python's module search path are true?

Accepted Answer

The PYTHONPATH environment variable can be used to add custom directories to sys.path.. The PYTHONPATH environment variable is a standard mechanism for extending Python's module search path. When Python starts, it reads the PYTHONPATH variable and prepends its contents to sys.path, allowing users to specify additional directories where Python should look for modules before falling back to the default search order.

Answer

The site-packages directory is searched before the PYTHONPATH directories.

Answer

The current working directory is always the last entry in sys.path.

Question 14

You are designing a class that should behave like a sequence and support slicing. Which special methods must be implemented?

Accepted Answer

__getitem__ and __len__. For a class to support slicing in Python, it must implement both `__getitem__` (to handle indexing and slice objects) and `__len__` (to define the sequence length, which is required for proper slice boundary handling). Together, these satisfy the sequence protocol, enabling Python's slicing syntax like `obj[start:stop:step]`.

Answer

__len__ and __contains__

Answer

__iter__ and __next__

Answer

__getitem__ alone

Answer

__getitem__ and __setitem__

Question 15

Which of the following statements about the __init__.py file in a package is true?

Accepted Answer

It is required for a directory to be considered a regular package. In Python, a directory containing an `__init__.py` file is recognized as a regular package. This file can be empty or contain initialization code, and its presence is required for the directory to be imported as a package (as opposed to a namespace package). Without it, Python will not treat the directory as a regular package.

Answer

It is required for a namespace package

Answer

It cannot contain executable code

Answer

It is automatically generated by Python

Certified Associate Python Programmer PCAP practice test

Three ways to study

Study PCAP by domain

Study PCAP by topic

Modules and Packages practice questions

Strings practice questions

Object-Oriented Programming practice questions

Exceptions and File I/O practice questions

PCAP fundamentals practice questions

PCAP scenario practice questions

PCAP troubleshooting practice questions

Top PCAP questions

Certified Associate Python Programmer PCAP practice questions