PCAP Hard Questions — 25 Difficult Questions

Question 1

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 2

Refer to the exhibit. What is the output?

Accepted Answer

2
2
2. The code defines a class `A` with a class variable `x = 2`, and a class `B` that inherits from `A`. The `display` method prints `self.x`, which first looks up the instance attribute `x`; since no instance attribute is set, it falls back to the class variable `x = 2` from class `A`. The loop creates three instances of `B` and calls `display` on each, so each prints `2` on a separate line, resulting in the output 2, 2, 2.

Answer

2
0
0

Answer

2
1
1

Answer

0
2
2

Question 3

You are a developer at a company that builds a data processing pipeline. The pipeline consists of several Python modules organized in a package called 'pipeline'. The package structure is:

pipeline/
    __init__.py
    load.py
    transform.py
    analyze.py

The pipeline is deployed on a server where Python 3.8 is installed. The server also has a globally installed package called 'pipeline' (from a different project) in the site-packages directory. When you run your scripts that import 'pipeline', you get unexpected behavior because Python is importing the wrong package. You need to ensure that your local 'pipeline' package is used instead of the global one. You cannot uninstall the global package because it is used by another application. You have the following options:

A) Modify the PYTHONPATH environment variable to include the directory containing your 'pipeline' package before the site-packages directory.
B) Rename your local 'pipeline' package to something else and update all imports.
C) Use a virtual environment specific to your project and install your package there.
D) Add an __init__.py file with a special import hook to override the global package.

Which course of action is the most appropriate and reliable?

Accepted Answer

Use a virtual environment specific to your project and install your package there.. Using a virtual environment creates an isolated Python environment where you can install your local 'pipeline' package without affecting or being affected by the globally installed package. This is the most reliable approach as it ensures that Python's import system will search the virtual environment's site-packages before the global site-packages, preventing any naming conflicts. Virtual environments are the standard Python best practice for managing project-specific dependencies and avoiding package name collisions.

Answer

Modify the PYTHONPATH environment variable to include the directory containing your 'pipeline' package before the site-packages directory.

Answer

Rename your local 'pipeline' package to something else and update all imports.

Answer

Add an __init__.py file with a special import hook to override the global package.

Question 4

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 5

Which THREE of the following are valid ways to create a string in Python?

Accepted Answer

'world'. All five options are valid ways to create a string in Python. 'world' (A) is a single-quoted string literal, str(['h','i']) (B) uses the str() constructor to convert a list into its string representation ''['h', 'i']'', '''multi-line''' (C) is a triple-quoted string literal, str(None) (D) converts the None object into the string 'None', and 'hello' (E) is a double-quoted string literal. The str() function returns a string for any argument, making B and D just as valid as the literals A, C, and E.

Question 6

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 7

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 8

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 9

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 10

Which THREE of the following statements about Python's 'with' statement are true? (Select exactly 3)

Accepted Answer

It can be used with any object that implements __enter__ and __exit__ methods.. Option A is correct because the context manager protocol is defined precisely by the presence of __enter__ and __exit__ methods, so any object implementing both can be used with 'with'. Option B is correct because the 'with' statement's semantics ensure __exit__ is invoked when the block exits, whether normally or via an exception, which is the core guarantee of the protocol. Option C is correct because Python supports 'with A() as a, B() as b:' syntax, allowing multiple context managers separated by commas (equivalent to nested with statements). Option D is not marked correct because while 'with' often replaces try/finally for resource cleanup, it does not eliminate the need for try/finally in all cases, such as when no context manager exists or when cleanup logic must run without one. Option E is not marked correct because 'with' works with any context manager, not only file objects; files are just a common example.

Answer

It eliminates the need for try/finally blocks for resource management.

Answer

It can only be used with file objects.

Question 11

Given: s = "Python". Which expression raises an IndexError?

Accepted Answer

s[6]. For s = 'Python', valid positive indices are 0..5, so s[6] is out of range and raises IndexError. Valid negative indices are -1..-6, so s[-10] is also out of range and raises IndexError. Thus both B and C are correct.

Answer

s[-1]

Answer

s[5]

Question 12

Which of the following is a correct use of the @property decorator to create a getter and setter for an attribute named 'score' that ensures score stays between 0 and 100?

Accepted Answer

@property
def score(self): return self._score
@score.setter
def score(self, value): if 0 <= value <= 100: self._score = value. It uses the @property decorator to define a getter method that returns the private attribute `self._score`, and a setter method that validates the new value is between 0 and 100 before assigning it to `self._score`. This ensures encapsulation and data validation, which is the intended use of properties in Python.

Answer

@property
def _score(self): return self.score
@_score.setter
def _score(self, value): self.score = value

Answer

@property
def score(self): return self.score
@score.setter
def score(self, value): self.score = value

Answer

def get_score(self): return self._score
def set_score(self, value): self._score = value
score = property(get_score, set_score)

Question 13

A developer notices that a custom package 'mypackage' is not being found when importing, even though it is installed in the site-packages directory. The developer suspects a conflict with another package of the same name. Which command should the developer run to diagnose the location from which Python is importing the package?

Accepted Answer

print(mypackage.__file__). `mypackage.__file__` returns the filesystem path from which the module was loaded, allowing the developer to see exactly which `mypackage` Python is using. This directly reveals if the wrong package (e.g., from a different location or a conflicting installation) is being imported instead of the intended one.

Answer

print(mypackage)

Answer

print(__file__)

Answer

import os; print(os.getcwd())

Question 14

A developer has two separate directories on sys.path: /home/user/libs and /opt/libs. Both directories contain a subdirectory 'mypackage' without an __init__.py file. The developer wants to import a module from 'mypackage' that exists only in one of the directories. What concept allows Python to treat these two directories as a single namespace package?

Accepted Answer

Implicit namespace packages (PEP 420). PEP 420 introduced implicit namespace packages, which allow multiple directories on sys.path to contribute to the same package without requiring __init__.py files. When Python encounters a directory without __init__.py, it treats it as a namespace package, merging all matching directories across sys.path into a single logical package. This enables the developer to import a module from 'mypackage' that exists in only one of the directories, as Python searches all paths and resolves the module from the first location where it is found.

Answer

Regular packages with __init__.py

Answer

sys.path merging

Answer

Package overriding

Question 15

Which TWO of the following statements about Python's `sys.path` are true?

Accepted Answer

Module search stops at the first matching directory in `sys.path`.. Python's import mechanism iterates through `sys.path` in order and stops at the first directory containing the requested module. Option E is correct: the directory containing the script (or the current directory when running interactively) is inserted at the beginning of `sys.path` at startup. Options A, C, and D are false: the current working directory is not always first (the script's directory takes precedence), `sys.path` is initialized from the `PYTHONPATH` environment variable *in addition to* default paths, and `sys.path` is a list, not a tuple. Therefore, only two statements are true.

Answer

The current working directory is always the first element in `sys.path`.

Answer

`sys.path` is initialized from the PYTHONPATH environment variable.

Answer

`sys.path` is a tuple of strings.

Question 16

A user wants to ensure that a custom module 'mymod' located at '/home/user/custom' takes precedence over a standard library module with the same name. Which operation on sys.path should be performed?

Accepted Answer

sys.path.insert(0, '/home/user/custom'). `sys.path.insert(0, '/home/user/custom')` adds the custom module's directory to the very beginning of the module search path. Python's import system scans `sys.path` in order, so placing the custom directory first ensures that `mymod` is found there before any standard library or site-packages directory that might contain a module with the same name.

Answer

sys.path.replace('/', '/home/user/custom')

Answer

sys.path.append('/home/user/custom')

Answer

sys.prefix = '/home/user/custom'

Question 17

Refer to the exhibit. What is the root cause of the error?

Accepted Answer

The attribute 'age' is not defined in the class or instance.. The error 'AttributeError: 'ClassName' object has no attribute 'age'' occurs when code attempts to access an instance attribute that has never been defined. In Python, attributes must be assigned (e.g., in __init__ or directly on the instance) before they can be read; simply declaring a class-level variable named 'age' would not cause this error, but if no assignment exists, the attribute is missing.

Answer

The __init__ method was not called.

Answer

The attribute 'age' is private.

Answer

The attribute 'age' is a class attribute but not initialized.

Question 18

Which THREE factors can cause an 'ImportError' when trying to import a module?

Accepted Answer

The module is a C extension that fails to load.. If a module is a C extension (e.g., a .so or .pyd file) and it fails to load due to missing dependencies, incompatible architecture, or a linking error, Python raises an ImportError. This is distinct from a syntax error in Python source code, which would raise a SyntaxError, not an ImportError.

Answer

The module file has a syntax error.

Answer

The module's __init__.py is empty.

Question 19

What is the likely outcome of running the following code?

```python
with open("C:\Users\path\file.txt", "r") as f:
    print(f.read())
```

Accepted Answer

The program raises a SyntaxError due to invalid escape sequences.. The code likely contains backslash sequences (e.g., `\U`, `\p`, or other non-standard escapes) that are not valid escape sequences in Python. Starting with Python 3.12, such invalid sequences raise a `SyntaxError` at compile time, preventing the program from running. In earlier versions, a `DeprecationWarning` is issued, but the code may run. The error is not about file operations or path resolution; it's a compile-time syntax error. To avoid this, use raw strings (`r"..."`) or double backslashes (`\`).

Answer

The program runs but the file contents are incorrect.

Answer

The program raises a FileNotFoundError because the path is invalid after escape interpretation.

Answer

The file is opened successfully because backslashes are ignored.

Question 20

A package 'mypkg' has the following structure:
mypkg/
  __init__.py
  submod1.py
  submod2.py
The __init__.py file contains: from . import submod1, submod2. A user runs 'import mypkg' and then 'mypkg.submod1.func()'. However, the user got an AttributeError. What is the most likely cause?

Accepted Answer

The submod1 module does not define a function named 'func'.. The AttributeError indicates that the attribute 'func' was not found on the module object 'submod1'. Since the import statement in __init__.py correctly makes submod1 accessible as mypkg.submod1, the only remaining reason for the error is that submod1.py does not define a function named 'func'. The import mechanism itself is working as intended.

Answer

submod1 is actually a package, not a module, so it cannot be called with 'func()'.

Answer

The __init__.py should use absolute imports like 'import mypkg.submod1' to make submod1 accessible.

Answer

The user must also run 'from mypkg import submod1' before accessing submod1.