PCAP Practice Questions 1 — 50 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

Question 16

A developer is working on a class hierarchy for geometric shapes. They have a base class Shape with an abstract method area(). They also have a mixin class Drawable that provides a method draw(). They want to create a class Rectangle that inherits from both Shape and Drawable. However, they encounter a TypeError when trying to instantiate Rectangle because the abstract method area() is not implemented. Which action should they take to resolve this?

Accepted Answer

Implement the area() method in Rectangle.. The abstract method area() declared in the Shape base class must be implemented in any concrete subclass. In Python, a class that inherits from an ABC (Abstract Base Class) with an abstract method cannot be instantiated until that method is overridden. By providing an implementation of area() in Rectangle, the class becomes concrete and can be instantiated without raising a TypeError.

Answer

Change the inheritance order to Drawable first, then Shape.

Answer

Use a class decorator @abstractmethod for Rectangle.

Answer

Remove the abstract method from Shape by removing the @abstractmethod decorator.

Question 17

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 18

Which of the following correctly uses an abstract base class to enforce that all subclasses implement a 'make_sound' method? (Assume ABC imported)

Accepted Answer

from abc import ABC, abstractmethod
class Animal(ABC):
    @abstractmethod
    def make_sound(self):
        pass. It imports both `ABC` and `abstractmethod` from the `abc` module, defines `Animal` as a subclass of `ABC`, and decorates `make_sound` with `@abstractmethod`. This combination prevents instantiation of `Animal` and forces any concrete subclass to override `make_sound`, or else a `TypeError` is raised at instantiation time.

Answer

from abc import abstractmethod
class Animal:
    @abstractmethod
    def make_sound(self):
        pass

Answer

class Animal:
    def make_sound(self):
        return None

Answer

class Animal:
    def make_sound(self):
        raise NotImplementedError

Question 19

A developer needs to combine a list of 10,000 strings into a single string. Which approach is most efficient in terms of memory and performance?

Accepted Answer

Use ''.join(string_list). The `''.join(string_list)` method is the most efficient because it pre-allocates memory for the final string by first calculating the total length of all strings in the list, then building the result in a single pass. This avoids the quadratic time complexity and repeated memory reallocations caused by string immutability in Python when using `+=` in a loop.

Answer

Use a loop with str += to concatenate each string

Answer

Use str.replace() to merge the strings

Answer

Use str.format() to build the string step by step

Question 20

A team is developing a large application and wants to organize code into packages. Which of the following is a best practice for package design?

Accepted Answer

Use absolute imports with the package name to prevent breakage when the package is moved. Using absolute imports with the full package name (e.g., `from package.module import something`) ensures that the import path is explicit and independent of the module's location within the package. This prevents breakage when the package is moved or installed in a different location, as the import references the top-level package name rather than a relative path that may change. Absolute imports are the recommended style in PEP 8 for clarity and maintainability in larger applications.

Answer

Use relative imports inside the package to avoid hardcoding the package name

Answer

Keep all modules in a single package for simplicity

Answer

Avoid using __init__.py to keep packages lightweight