PCAP Practice Test 3 — 25 Questions

Question 1

A developer tries to modify a string: s = 'hello'; s[0] = 'H'. What happens when this code runs?

Accepted Answer

It raises a TypeError: 'str' object does not support item assignment. Strings in Python are immutable, meaning their contents cannot be changed after creation. Attempting to assign a new character to an index position (e.g., s[0] = 'H') raises a TypeError: 'str' object does not support item assignment. To modify a string, you must create a new string using slicing or concatenation.

Answer

It changes the string to 'Hello'

Answer

It creates a new string 'Hello' and assigns it to s

Answer

It raises an IndexError because index 0 is out of range

Question 2

You are a DevOps engineer managing a Python application that consists of multiple microservices. One microservice, 'data_processor', imports a shared library 'common_lib' which is also used by other microservices. The shared library is developed in a separate repository and is installed via pip in each microservice's virtual environment as an editable package (pip install -e). Recently, you updated 'common_lib' with new functions, but when you redeploy 'data_processor' (by restarting the container), the new functions are not available; the old version is still used. The container uses a Docker image built from a requirements file that specifies 'common_lib' from a Git repository. You verify that the Git commit hash in the requirements file points to the latest version. What is the most likely cause and what is the correct course of action?

Accepted Answer

Update the commit hash or use a version tag that points to the latest, and rebuild the Docker image without using cache (--no-cache).. When a Docker image is built, pip installs the package from the Git repository at the commit hash specified in the requirements file. Even if the requirements file points to the latest commit, Docker's layer caching may reuse a previously built layer that contains the old version of the package. Rebuilding the image with --no-cache forces Docker to re-execute the pip install step, fetching the latest code from Git and installing the updated common_lib. Simply restarting the container does not rebuild the image, so the old installed package persists.

Answer

Add the common_lib source directory to sys.path in the microservice code.

Answer

Rename the package in the requirements file to force a fresh install.

Answer

Change the Python interpreter to a different version.

Question 3

A developer is building a logging system that writes logs to a file. The system should handle disk-full situations gracefully without crashing the main application. Which approach is appropriate?

Accepted Answer

Wrap the log write in a try/except that catches OSError and writes to stderr as fallback.. It uses a targeted try/except block around only the log write operation, catching OSError (which includes disk-full conditions) and falling back to stderr. This prevents the main application from crashing while still reporting the error, adhering to the principle of handling exceptions at the point where they occur and only when you can meaningfully recover.

Answer

Check disk space before each write; if low, skip logging.

Answer

Wrap the entire application in a try/except that catches all exceptions.

Answer

Let the OSError propagate to the main program's exception handler.

Question 4

A Python script fails with 'ModuleNotFoundError: No module named 'myapp.config''. The environment variable PYTHONPATH is not set. Which of the following is the most likely cause?

Accepted Answer

The module is located in a directory not included in sys.path. When PYTHONPATH is not set, Python relies solely on sys.path to locate modules. sys.path includes the script's directory, standard library paths, and site-packages. If 'myapp.config' is not in any of these directories, Python raises ModuleNotFoundError. Option A correctly identifies that the module is in a directory not included in sys.path.

Answer

The module's __init__.py is missing

Answer

The module is installed in a different Python version's site-packages

Answer

The module has a syntax error

Question 5

A package 'pkg' is installed as an egg-link in development mode. Inside the package, there is a module 'submod.py' that uses relative imports. When a developer modifies 'submod.py', they find that changes are not always reflected on import. What is the most likely reason?

Accepted Answer

Python's module caching in sys.modules prevents re-loading the modified source.. Python caches imported modules in `sys.modules`. When a module is imported, Python stores the module object in `sys.modules` and subsequent imports retrieve it from this cache without re-executing the module's code. Modifying the source file of `submod.py` does not automatically invalidate this cache, so the changes are not reflected unless the module is explicitly reloaded (e.g., with `importlib.reload()`) or the interpreter is restarted.

Answer

The sys.path is altered by the egg-link, causing a different module to be loaded.

Answer

Relative imports are cached in the __init__.py file.

Answer

The __pycache__ directory is not cleared automatically.

Question 6

A programmer uses a class method to create an alternative constructor for a `Point` class. The method should parse a string like "10,20" and return a `Point` instance with x=10, y=20. Which code snippet correctly implements this?

Accepted Answer

`@classmethod
def from_string(cls, s):
    parts = s.split(',')
    return cls(int(parts[0]), int(parts[1]))`. It uses the `@classmethod` decorator, which automatically passes the class (`cls`) as the first argument. This allows the method to create an instance of the class using `cls(...)`, making it a proper alternative constructor that works correctly even if the class is subclassed. The method parses the string "10,20" by splitting on the comma and converting the parts to integers.

Answer

`def from_string(self, s):
    parts = s.split(',')
    return Point(int(parts[0]), int(parts[1]))`

Answer

`@staticmethod
def from_string(s):
    parts = s.split(',')
    return Point(int(parts[0]), int(parts[1]))`

Answer

`def from_string(cls, s):
    parts = s.split(',')
    return cls(int(parts[0]), int(parts[1]))`

Question 7

A developer has a module 'config.py' with the following content:

# config.py
import os
DATABASE_URL = os.getenv('DATABASE_URL', 'localhost')

Another module 'app.py' imports config and uses DATABASE_URL. During testing, the environment variable is set correctly, but the import still uses the default value 'localhost'. What is the most likely reason?

Accepted Answer

Python caches modules; config.py was imported earlier without the environment variable, and the cached version is reused.. Python caches imported modules in `sys.modules`. If `config.py` was imported earlier in the test session (e.g., during test discovery or another import) before the environment variable `DATABASE_URL` was set, the cached module would retain the default value `'localhost'`. Subsequent imports, even after setting the environment variable, reuse the cached module, so `os.getenv('DATABASE_URL', 'localhost')` is not re-evaluated.

Answer

The import statement in app.py is placed inside a function, so it is not executed.

Answer

The module was imported using 'from config import DATABASE_URL' which creates a separate copy.

Answer

The environment variable is only read when the function is called, not at import time.

Question 8

Given package structure: pack/__init__.py, pack/subpack/__init__.py, pack/subpack/mod.py. Inside pack/__init__.py, which import statement correctly imports mod.py using a relative import?

Accepted Answer

from .subpack import mod. `from .subpack import mod` uses a leading dot to indicate a relative import from the current package (`pack`), then navigates into `subpack` and imports `mod`. This is the proper syntax for importing a module from a subpackage within the same parent package.

Answer

from . import subpack.mod

Answer

from subpack import mod

Answer

from ..subpack import mod

Question 9

Drag and drop the steps to serialize a Python object to JSON using the json module into the correct order.

Accepted Answer

Step 1: Import the json module. Step 2: Create a Python dictionary. Step 3: Open a file in write mode. Step 4: Use json.dump() to write the dictionary to the file.. Serialization to JSON involves importing json, preparing data, using dumps for string or dump for file output.

Answer

Step 1: Create a Python dictionary. Step 2: Import the json module. Step 3: Open a file in write mode. Step 4: Use json.dump() to write the dictionary to the file.

Answer

Step 1: Import the json module. Step 2: Open a file in write mode. Step 3: Create a Python dictionary. Step 4: Use json.dump() to write the dictionary to the file.

Answer

Step 1: Import the json module. Step 2: Create a Python dictionary. Step 3: Use json.dump() to write the dictionary to the file. Step 4: Open a file in write mode.

Question 10

A developer writes a class 'Logger' with a class method 'log(msg)' that writes to a file. Another class 'AppLogger' inherits from 'Logger'. The developer expects both classes to share the same file handle. However, after creating an instance of 'AppLogger', the file handle is different. What is the most likely cause?

Accepted Answer

The file handle is opened in the __init__ method of the base class. If the file handle is opened in the `__init__` method of the base class, each time a new instance is created (including when an `AppLogger` instance is created), a new file handle is opened. This means the `Logger` class and the `AppLogger` class do not share the same file handle; instead, each instance gets its own handle. To share a single file handle across all instances, the file handle should be opened as a class attribute or in a class method, not in `__init__`.

Answer

The 'log' method is defined as a class method using @classmethod

Answer

The file handle is stored as a private attribute __file

Answer

The subclass overrides the 'log' method

Question 11

Refer to the exhibit. Which of the following is the most likely cause of this error?

Accepted Answer

mypackage is a module file, not a package directory.. The error indicates that Python cannot import 'mypackage' as a package. If 'mypackage' is a single module file (e.g., mypackage.py) rather than a directory containing an __init__.py file, Python treats it as a module, not a package. This prevents the expected package-style import of submodules like 'mymodule', causing the ImportError.

Answer

The __init__.py file in mypackage is empty.

Answer

There is a circular import between mypackage and mymodule.

Answer

mymodule.py does not exist in mypackage directory.

Question 12

A team is developing a data processing pipeline where each step is a class that implements a common interface. They have defined an abstract base class DataProcessor with an abstract method process(data). Several concrete subclasses implement process. Now they need to add a new step that logs the data before processing. They want to reuse the existing processing logic without modifying the original classes. Which design pattern should they apply?

Accepted Answer

Decorator pattern by creating a LoggingProcessor subclass that wraps another processor and calls its process method after logging.. The Decorator pattern allows behavior to be added to an individual object, either statically or dynamically, without affecting the behavior of other objects from the same class. By creating a LoggingProcessor that wraps an existing DataProcessor and delegates to its process method after logging, the team reuses the original processing logic without modifying the existing classes, adhering to the Open/Closed Principle.

Answer

Factory pattern to instantiate processors dynamically.

Answer

Singleton pattern to ensure only one logger exists.

Answer

Observer pattern to notify loggers of data changes.

Question 13

A Python script reads a file containing text with non-ASCII characters like 'é' and 'ü'. The script must encode the string as UTF-8 then decode it back. Which of the following correctly handles this without error?

Accepted Answer

s.encode('utf-8').decode('utf-8'). It first encodes the string (which contains non-ASCII characters like 'é' and 'ü') into UTF-8 bytes using `.encode('utf-8')`, then decodes those bytes back into a string using `.decode('utf-8')`. This round-trip preserves all characters since UTF-8 can represent any Unicode code point, and the operations are applied in the correct order: a string is encoded to bytes, then bytes are decoded back to a string.

Answer

s.decode('utf-8').encode('utf-8')

Answer

s.encode('ascii').decode('ascii')

Answer

s.decode('utf-8').decode('utf-8')

Question 14

A junior developer wrote a class representing a bank account with a private attribute balance. They used double underscore prefix (__balance) to make it private. However, in a test script, they are still able to access the attribute using the mangled name _Account__balance. The developer is confused about why encapsulation is not enforced. Which statement best explains this behavior?

Accepted Answer

Python's name mangling is only a convention and does not prevent access.. Python's name mangling (triggered by a double underscore prefix) is not a security mechanism but a syntactic transformation that renames the attribute to _ClassName__attribute. This prevents accidental name clashes in subclasses but does not enforce true encapsulation; the attribute can still be accessed via the mangled name from outside the class. The developer's confusion stems from mistaking name mangling for a privacy guarantee, which Python intentionally does not provide.

Answer

The double underscore prefix actually makes the attribute completely inaccessible from outside the class.

Answer

The developer forgot to use the @property decorator.

Answer

The test script must have used a different class attribute name.

Question 15

Which THREE of the following are true about the `__init__` method in Python?

Accepted Answer

It can be called manually.. The __init__ method is a special method in Python classes used for initializing newly created objects. It can be called manually (e.g., obj.__init__()), it accepts arguments that are passed during instance creation, and it is automatically invoked when an instance is created via the class constructor. It does not require a return value (it returns None), and it is inherited by subclasses unless explicitly overridden.

Answer

It must return a value.

Answer

It is not inherited.

Question 16

A Python package 'mypackage' contains the following hierarchy:

mypackage/
    __init__.py
    subpackage1/
        __init__.py
        module_a.py
    subpackage2/
        __init__.py
        module_b.py

From a script outside the package, a programmer writes:

import mypackage.subpackage1.module_a

Which statement is true about the import?

Accepted Answer

Both mypackage/__init__.py and mypackage/subpackage1/__init__.py are executed.. When Python encounters an import statement with a dotted path like `import mypackage.subpackage1.module_a`, it executes the `__init__.py` files for each package in the path in order: first `mypackage/__init__.py`, then `mypackage/subpackage1/__init__.py`. This is because Python must initialize each package before it can access its subpackages or modules. Option D correctly states that both `__init__.py` files are executed.

Answer

Only mypackage/__init__.py is executed.

Answer

No __init__.py files are executed because the import uses a dotted path.

Answer

After the import, 'mypackage' is not available as a name in the namespace.

Question 17

A developer wants to check if a string ends with a specific suffix. Which method should be used?

Accepted Answer

endswith(). The `endswith()` method is specifically designed to check if a string ends with a given suffix, returning a boolean value. This is the correct and most direct approach for the task described, as it avoids manual slicing or comparison.

Answer

index()

Answer

find()

Answer

startswith()

Question 18

A Python class 'Shape' defines an abstract method 'area'. Subclasses 'Circle' and 'Square' implement 'area'. A function 'calculate_area(shape)' expects a 'Shape' instance. Which principle ensures that the function works correctly without knowing the specific subclass?

Accepted Answer

Liskov Substitution Principle. The Liskov Substitution Principle (LSP) states that objects of a superclass should be replaceable with objects of its subclasses without affecting the correctness of the program. In this scenario, 'calculate_area(shape)' accepts a 'Shape' instance, and because both 'Circle' and 'Square' are proper subtypes that honor the contract of the 'area' method, the function works correctly regardless of which subclass is passed. This is the core of LSP: substitutability without side effects.

Answer

Interface Segregation Principle

Answer

Single Responsibility Principle

Answer

Dependency Inversion Principle

Question 19

A developer writes a function that reads a file and processes its content. The function should handle the case where the file does not exist without catching other I/O errors. Which exception should be caught?

Accepted Answer

FileNotFoundError. `FileNotFoundError` is a specific subclass of `OSError` that is raised exactly when a file or directory is requested but does not exist. By catching only `FileNotFoundError`, the function handles the missing-file scenario without masking other I/O errors such as permission issues or disk failures, which is the precise requirement stated in the question.

Answer

PermissionError

Answer

IOError

Answer

OSError

Question 20

A log processing script receives a multiline string log. The script needs to check if the string ends with the substring 'ERROR'. Which method should be used?

Accepted Answer

log.endswith('ERROR'). The `endswith()` method is specifically designed to check if a string ends with a given substring. It returns `True` if the string ends with 'ERROR', making it the most direct and readable solution for this requirement.

Answer

log.find('ERROR') != -1

Answer

log.rfind('ERROR') == len(log)-5

Answer

'ERROR' in log