PCAP Practice Test 2 — 25 Questions

Question 1

What is the result of the expression '12345'[:10]?

Accepted Answer

'12345'. In Python, slicing a string with a start index of 0 and an end index of 10 (as in '12345'[:10]) returns the entire string if the slice end exceeds the string length. Since '12345' has only 5 characters, the slice extracts all characters without padding or error, resulting in '12345'.

Answer

'12345     '

Answer

IndexError

Answer

'12345 '

Question 2

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 3

Which three statements about the Method Resolution Order (MRO) in Python are true? (Choose three.)

Accepted Answer

The MRO can be viewed using the __mro__ attribute.. Every Python class has an `__mro__` attribute that returns a tuple of classes in the order they are searched for methods and attributes. This attribute is automatically generated by the C3 linearization algorithm and provides a clear, inspectable view of the resolution order.

Answer

The MRO is only used for methods, not attributes.

Answer

The MRO can be changed by modifying the class hierarchy at runtime.

Question 4

A Python class 'BankAccount' has a method 'withdraw(amount)' that deducts 'amount' from 'self.balance'. A developer writes a subclass 'SavingsAccount' that overrides 'withdraw' to add a penalty if balance drops below minimum. Which design pattern is being used?

Accepted Answer

Method overriding. Method overriding is the mechanism where a subclass provides a specific implementation of a method that is already defined in its superclass. In this scenario, SavingsAccount overrides the withdraw method from BankAccount to add penalty logic, which is the defining characteristic of method overriding in Python.

Answer

Composition

Answer

Aggregation

Answer

Inheritance

Question 5

A developer is writing a package that contains multiple modules. The package should allow users to import it directly and have all commonly used functions available at the package level. For example, after `import mypackage`, the user should be able to call `mypackage.func1()` without needing to import submodules. Which is the best way to achieve this?

Accepted Answer

In `__init__.py`, import the desired functions from the submodules, e.g., `from .submodule import func1`.. `__init__.py` is executed when a package is imported, and importing functions from submodules into `__init__.py` makes them directly accessible as attributes of the package object. This allows `mypackage.func1()` to work without requiring the user to import submodules explicitly, satisfying the requirement of a flat namespace at the package level.

Answer

Create a wrapper function in `__init__.py` that delegates calls to the submodule functions.

Answer

Include `__all__` in each submodule and ensure `__init__.py` is empty.

Answer

Define a list named `__all__` in the package's `__init__.py` that lists the functions.

Question 6

Given that MyClass defines __private_attr in __init__, why does this error occur?

Accepted Answer

The attribute name is mangled to _MyClass__private_attr.. Python uses name mangling for attributes with double underscores (__) to avoid accidental overriding in subclasses. When you define __private_attr inside __init__, Python internally renames it to _MyClass__private_attr. Attempting to access obj.__private_attr from outside the class fails because that mangled name is not recognized, leading to an AttributeError.

Answer

The attribute was not defined in __init__.

Answer

Private attributes cannot be accessed outside the class.

Answer

The attribute is a class attribute not an instance attribute.

Question 7

Your company has two separate Python packages: 'app' and 'lib'. They are maintained by different teams. 'app' depends on 'lib', but 'lib' is still under development and its API changes frequently. To avoid breaking 'app', the team decides to use a virtual environment and install a specific version of 'lib'. However, during development, they need to test 'app' with the latest 'lib' changes from the Git repository. The current workflow is: (1) activate virtual env, (2) install 'lib' from local source using `pip install -e /path/to/lib`. This installs 'lib' as a development package. But one developer reports that after pulling latest 'lib' changes, importing 'lib' in 'app' still uses the old version even after re-running pip install -e. What is the most likely reason?

Accepted Answer

The editable install may still point to an old copy of the library if the source directory was moved or if there is a stray .egg-link file.. The most likely reason is D. When using `pip install -e` (editable install), pip creates a special `.egg-link` file (or similar pointer) in the site-packages directory that points to the source directory. If the source directory was moved, renamed, or if a stale `.egg-link` file remains from a previous install, pip may still reference the old location, causing the old version to be imported even after re-running the install command. This is a known subtlety of editable installs, especially when the source code is managed under version control and the directory structure changes.

Answer

Python caches imported modules in sys.modules, so importing again does not reload the module from disk.

Answer

The package 'lib' is being imported as a namespace package, so changes are not picked up.

Answer

The .pyc files are not being invalidated because the timestamps are not updated.

Question 8

You are developing a package 'analytics' that contains subpackages 'stats' and 'ml'. The __init__.py of 'analytics' imports a function 'normalize' from 'analytics.stats'. When a user runs `import analytics`, they get an ImportError. Which change ensures the package imports correctly?

Accepted Answer

Change the import in analytics/__init__.py to: from .stats import normalize. It uses an explicit relative import (`from .stats import normalize`), which is the proper way to import from a subpackage within a package. Absolute imports like `from analytics.stats import normalize` can fail if the package's parent directory is not in `sys.path`, which is common when running scripts directly. Relative imports resolve correctly based on the package structure, ensuring the import works regardless of how the package is invoked.

Answer

Change the import to: from stats import normalize

Answer

Add sys.path.append('.') before the import in __init__.py

Answer

Move the import statement to the stats/__init__.py file

Question 9

A programmer writes a function that expects a string and returns it reversed. Which code snippet correctly reverses the string 'stressed' to 'desserts'?

Accepted Answer

result = s[::-1]. Both option B and option D correctly reverse the string 'stressed' to 'desserts'. Option B uses slice notation `[::-1]`, which creates a reversed copy of the string by stepping from end to start with a step of -1. This is the most direct and idiomatic way to reverse a string in Python. Option D uses `''.join(reversed(s))`: `reversed(s)` returns an iterator that yields characters in reverse order, and `join()` concatenates them into a new string. This is also a valid and correct approach. Option A is incorrect because strings do not have a `reversed()` method; `reversed()` is a built-in function. Option C is incorrect because `.reverse()` is a list method, not a string method, and strings are immutable.

Answer

result = s.reversed()

Answer

s.reverse()

Question 10

Refer to the exhibit. What is the output?

Accepted Answer

1 2. '1 2'. When `print(A.x, a.x)` is executed, `A.x` accesses the class attribute `x=1`, and `a.x` accesses the instance attribute `x=2` (set in `__init__`), which shadows the class attribute for that instance. Therefore, the output is '1 2'.

Answer

1 1

Answer

0 1

Answer

2 2

Question 11

Refer to the exhibit. A developer ran the script and saw the above traceback. The intended behavior was to load a JSON configuration file, and if the file is missing, create a default config. What is the most likely root cause of the second exception (NameError)?

Accepted Answer

The script did not import the json module.. The traceback shows a NameError for 'json.loads', which indicates that the name 'json' is not defined in the current namespace. This occurs when the script attempts to call json.loads() without first importing the json module. The intended behavior of loading a JSON configuration file requires the json module to parse the file content, and its absence causes the NameError exception.

Answer

The variable 'f' was not defined due to the FileNotFoundError.

Answer

The config.json file exists but is empty.

Answer

The file was opened in binary mode instead of text mode.

Question 12

Refer to the exhibit. What is the output?

Accepted Answer

100. The code `print('100')` outputs the string `100` without quotes. In Python, `print()` displays the value passed to it; when a string literal is passed, it prints the characters of the string, not the surrounding quotes. Therefore, the output is `100` (the integer-like string, but as a string). Option B is correct because it shows the numeric value without quotes, which is how Python's `print()` renders a string.

Answer

'100'

Answer

True

Answer

Error

Question 13

Consider a class `D` that inherits from multiple base classes `B` and `C`. The developer wants to call a method from a specific parent class while ensuring correct method resolution order (MRO). Which is the safest way?

Accepted Answer

`super().method()`. In Python, `super().method()` is the safest way to call a method from a parent class in a multiple inheritance scenario because it respects the Method Resolution Order (MRO) defined by the C3 linearization algorithm. This ensures that the method is resolved from the next class in the MRO, avoiding hard-coded references that could break if the inheritance hierarchy changes. It also correctly handles cooperative multiple inheritance, where each class in the MRO can collaborate via `super()` calls.

Answer

`self.method()`

Answer

`ParentClass.method(self)`

Answer

`BaseClass.method(self)`

Question 14

A developer installs a third-party package using pip, but when they try to import it in their script, Python raises a ModuleNotFoundError. The package is definitely installed (pip list shows it). What is the most likely cause?

Accepted Answer

The Python interpreter being used is different from the one where the package was installed.. When a package is installed via pip, it is placed into the site-packages directory of a specific Python interpreter. If the developer runs their script with a different Python interpreter (e.g., one from a virtual environment, a different version, or a system Python vs. a user-installed Python), that interpreter's import system will not search the site-packages where the package was installed, resulting in a ModuleNotFoundError even though pip list shows the package. This is the most common cause of such a mismatch.

Answer

The package name contains a hyphen.

Answer

The script is in a directory that shadows the package name.

Answer

The package does not have an __init__.py file.

Question 15

A developer is creating a custom exception hierarchy for a library. The base exception is `LibraryError`. Which definition ensures that subclasses can be caught using the parent exception, but also allows distinguishing between different error types?

Accepted Answer

class LibraryError(Exception): pass
class FileError(LibraryError): pass
class ParseError(LibraryError): pass. It defines `LibraryError` as a subclass of `Exception`, which is the proper base class for all user-defined exceptions in Python. Subclasses `FileError` and `ParseError` inherit from `LibraryError`, so they can be caught with `except LibraryError` while still being distinguishable by their own type. This follows the standard Python exception hierarchy, where custom exceptions should derive from `Exception`, not `BaseException` or no base class.

Answer

class LibraryError: pass
class FileError(LibraryError): pass
class ParseError(LibraryError): pass

Answer

class LibraryError(BaseException): pass
class FileError(LibraryError): pass
class ParseError(LibraryError): pass

Answer

class LibraryError(Exception): pass
class FileError(Exception): pass
class ParseError(Exception): pass

Question 16

A programmer writes a class with a method that should be called on the class itself, not on instances. Which decorator is appropriate?

Accepted Answer

@classmethod. The @classmethod decorator transforms a method so that it receives the class itself as the first implicit argument (cls), rather than an instance (self). This allows the method to be called on the class directly, e.g., MyClass.my_method(), and is the correct choice when a method should operate on the class level, not on instances.

Answer

@property

Answer

@abstractmethod

Answer

@staticmethod

Question 17

A developer needs to count the number of occurrences of the substring 'is' in the string 'This is a test. Is this a test?'. Which code correctly performs the count?

Accepted Answer

'This is a test. Is this a test?'.count('is'). Python's string method `count(substring)` returns the number of non-overlapping occurrences of the substring in the string. In 'This is a test. Is this a test?', 'is' appears twice (in 'This' and 'is'), and the method counts them correctly, ignoring case sensitivity (the capitalized 'Is' is not counted).

Answer

'This is a test. Is this a test?'.split().count('is')

Answer

'This is a test. Is this a test?'.index('is')

Answer

'This is a test. Is this a test?'.find('is')

Question 18

A class has a class attribute that is a list. A developer modifies this list via one instance, and the change is reflected in all other instances. What is the best practice to avoid this unintended sharing?

Accepted Answer

Initialize the list in `__init__` rather than as a class attribute.. Class attributes are shared across all instances. By initializing the list inside `__init__`, each instance gets its own independent list object, preventing unintended mutation from affecting other instances. This is the standard Python pattern for instance-specific mutable data.

Answer

Use a tuple instead of a list.

Answer

Use a class method to modify the list.

Answer

Use `deepcopy` when accessing the list.

Question 19

A senior developer in a team argues that using try-except blocks is slower than checking conditions with if statements. They propose replacing all try blocks that handle file I/O errors with existence checks using os.path.exists before opening files. During a code review, you recall that Python's official documentation and best practices prefer EAFP (Easier to Ask for Forgiveness than Permission) over LBYL (Look Before You Leap) in many cases, especially in concurrent environments. The team's application is a multi-threaded web server that serves static files from a shared directory. Which is the strongest counterargument against the senior developer's proposal?

Accepted Answer

LBYL leads to race conditions in concurrent code because the file's state can change between the check and the use.. In a multi-threaded web server, the LBYL approach (checking with os.path.exists) introduces a classic TOCTOU (Time of Check, Time of Use) race condition: between the existence check and the actual file open, another thread could delete or rename the file, causing the open to fail despite the check passing. Python's EAFP idiom (try-except) avoids this window by attempting the operation directly and handling the exception if it fails, which is inherently atomic with respect to the file system state. This is why official Python documentation recommends EAFP over LBYL in concurrent environments.

Answer

if statements are harder to read and maintain.

Answer

try-except can catch multiple exception types more cleanly.

Answer

try-except blocks have no performance cost at all.

Question 20

In Python, if you have a try block followed by an except clause that catches all exceptions, which of the following is true about the else clause?

Accepted Answer

The else clause runs only if no exception is raised in the try block.. In Python, the `else` clause in a `try` statement executes only if no exception was raised in the `try` block. This is true regardless of whether the `except` clause catches all exceptions (e.g., bare `except:` or `except Exception:`). The `else` block is specifically designed for code that should run only when the `try` block completes successfully without any exception.

Answer

The else clause runs only if an exception occurs.

Answer

The else clause runs before the finally block regardless of exceptions.

Answer

The else clause is used to specify additional exception handlers.