PCAP Hard Questions — 25 Difficult Questions

Question 1

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?

Choose an answer to begin — your selection is scored in the full session.

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 2

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 3

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 4

A Python project uses namespace packages spread across multiple directories. The package structure is: project/ and lib/ both contain subdirectories 'mypkg/'. Each has an __init__.py file. When importing 'mypkg', which directory's contents are used?

Accepted Answer

Only the directory that appears first in sys.path is used.. When both directories contain an __init__.py file, they are regular packages, not namespace packages. Python's import system uses the first match in sys.path; it does not merge regular packages. Therefore, only the directory that appears first in sys.path is used, making option B correct.

Answer

Both directories are merged into a single namespace package.

Answer

An error is raised due to ambiguous import.

Answer

The last directory in sys.path overrides the previous.

Question 5

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 6

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 7

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 8

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 9

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 10

Which of the following is true regarding Python's method resolution order (MRO) in multiple inheritance?

Accepted Answer

The MRO is computed using the C3 linearization algorithm, ensuring that each class appears before its parents and that monotonicity is preserved.. Python's method resolution order (MRO) is computed using the C3 linearization algorithm. This algorithm ensures that each class appears before its parents and that monotonicity is preserved, meaning the order of class precedence does not change when new subclasses are introduced. This is essential for resolving method calls in multiple inheritance scenarios, particularly with diamond inheritance.

Answer

The MRO is always the same as the order of base classes specified in the class statement.

Answer

The MRO can be changed at runtime by modifying the __bases__ attribute of a class.

Answer

The MRO is determined by the order of base classes in the class definition, using a depth-first, left-to-right search without consideration of diamond inheritance.

Question 11

A developer is creating a Python package named 'utils' and wants to control what is imported when a user writes 'from utils import *'. Which file and variable should be defined?

Accepted Answer

Define __all__ = ['mod1', 'mod2'] in '__init__.py' of the 'utils' package.. In Python, the `__all__` variable in the `__init__.py` file of a package explicitly defines the list of module names that are exported when a user writes `from utils import *`. This controls the public API of the package and prevents unintended internal modules from being imported.

Answer

Define __all__ as a function that returns the list of modules in '__init__.py'.

Answer

Set the __all__ variable in the script that imports the package.

Answer

Define __all__ as a list of module objects in the main module 'utils.py'.

Question 12

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 13

Given the code above, what is printed? Note: each backslash is a single character.

Accepted Answer

23. The string "C:\Users\John\Documents" uses double backslashes to represent literal backslashes. Each double backslash `\` is a single backslash character. Counting all characters: C, :, \, U, s, e, r, s, \, J, o, h, n, \, D, o, c, u, m, e, n, t, s = 23 characters. Thus, the length is 23.

Answer

21

Answer

22

Answer

24

Question 14

Which of the following expressions returns True if the string s contains only hexadecimal digits (0-9, a-f, A-F)?

Accepted Answer

all(c in '0123456789abcdefABCDEF' for c in s). It explicitly checks each character in the string against the set of valid hexadecimal digits (0-9, a-f, A-F) using the `all()` function. This ensures that every character is a hex digit, which is the precise requirement for a string to contain only hexadecimal digits.

Answer

s.isdigit() or s.isalpha()

Answer

s.isnumeric()

Answer

s.isalnum() and s.islower()

Question 15

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 16

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 17

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.

Question 18

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 reports package needs to be moved under the app directory physically.. For 'app.reports' to be importable, the reports directory must reside inside an 'app' directory on one of the sys.path entries. Adding '/opt/project/another_location/' to sys.path makes a top-level 'reports' package importable, not 'app.reports'. The presence of __init__.py in the app directory is irrelevant here; even if removed, Python cannot find reports as a subpackage because there is no 'app' directory in another_location. The necessary fix is to physically move the reports package under the app directory (or create an app directory in another_location and place reports inside it, then remove __init__.py for namespace merging).

Answer

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

Answer

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

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.

Question 19

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 20

Given the code: s = 'Python'; t = s; s = s + '3.0'. What is the value of t after these lines execute?

Accepted Answer

'Python'. Strings in Python are immutable. The assignment `t = s` makes `t` reference the same string object as `s`. When `s = s + '3.0'` executes, a new string object `'Python3.0'` is created and bound to `s`, while `t` still references the original string `'Python'`. Thus, `t` remains `'Python'`.

Answer

It raises an error because s was reassigned.

Answer

''

Answer

'Python3.0'