PCAP Practice Exam 2 — 20 Questions

Question 1

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 2

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 3

Which of the following is the BEST practice for building a large string by concatenating many smaller strings in Python?

Accepted Answer

result = ''.join(parts). `''.join(parts)` is the most efficient way to concatenate a large number of strings in Python. It allocates memory once for the final string by iterating over the list and copying each part into the result buffer, avoiding the O(n²) time complexity of repeated concatenation in a loop.

Answer

result = sum(parts, '')

Answer

result = str.concat(*parts)

Answer

result = ''; for part in parts: result += part

Question 4

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 5

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 6

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 7

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 8

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 9

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 10

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 11

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 12

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 13

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 14

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 15

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 16

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 17

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 18

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 19

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 20

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