PCAP Practice Test 9 — 10 Questions

Question 1

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?

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

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 2

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 3

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 4

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 5

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 6

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 7

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 8

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 9

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 10

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.