PCAP Practice Test 14 — 15 Questions

Question 1

A Python script uses a third-party library 'requests'. The developer wants to ensure that the exact version 2.25.1 is installed in the project's environment. Which tool and command should be used?

Accepted Answer

pip install requests==2.25.1. Both options B and C are correct because they use the standard pip syntax for pinning a specific version: `package==version`. The command `pip install requests==2.25.1` (B) works on systems where `pip` is linked to Python 3, while `pip3 install requests==2.25.1` (C) explicitly invokes the Python 3 version of pip. Both achieve the same result—installing requests exactly version 2.25.1. Option A fails to specify a version, and option D contains a typo ('instll') that will fail.

Answer

pip install requests

Answer

pip instll requests==2.25.1

Question 2

A developer wants to create a class that logs every attribute access on an instance. Which special method should they override?

Accepted Answer

`__getattribute__`. `__getattribute__` is the special method that is called unconditionally for every attribute access on an instance, making it the appropriate choice for logging all attribute accesses. Overriding this method allows the developer to intercept and log each access before the attribute is retrieved, whereas `__getattr__` is only invoked when the attribute is not found via normal lookup.

Answer

`__getattr__`

Answer

`__setattr__`

Answer

`__delattr__`

Question 3

Which of the following correctly uses `__slots__` to restrict attribute creation to only `x` and `y`?

Accepted Answer

`class Foo: __slots__ = ['x', 'y']`. Options C and D are both correct because `__slots__` must be assigned an iterable of strings. A list `['x', 'y']` and a tuple `('x', 'y')` are both valid iterables that restrict attribute creation to exactly `x` and `y`. Option A uses a single string, which would restrict to individual characters `'x'`; Option B uses a string in parentheses without a trailing comma, which is also just a string. Both A and B would produce unexpected behavior.

Answer

`class Foo: __slots__ = 'x'`

Answer

`class Foo: __slots__ = ('x')`

Question 4

Refer to the exhibit. A Python script uses the following code to load the policy. However, it fails with a JSONDecodeError. What is the most likely cause?
```python
import json
with open('policy.json', 'r') as f:
    policy = json.load(f)
```

Accepted Answer

The JSON file contains a trailing comma after the last element.. Python's json.load() strictly follows the JSON specification (RFC 7159), which does not allow trailing commas after the last element in an array or object. When the JSON file contains a trailing comma, the decoder raises a JSONDecodeError. This is a common syntax error in hand-written or poorly generated JSON files.

Answer

The policy variable is used before assignment elsewhere in the script.

Answer

The file should be opened in binary mode ('rb') instead of text mode.

Answer

The JSON decoder cannot handle IP addresses in strings.

Question 5

Consider the following code snippet: s = 'abcdefgh'; result = s[7:3:-2]; print(result). What is the output?

Accepted Answer

hf. The slice s[7:3:-2] starts at index 7 (character 'h'), goes backwards with step -2, and stops before index 3. The indices visited are 7 and 5, yielding 'h' and 'f', so the result is 'hf'. Option B is correct because the step is negative, meaning the slice moves from right to left, and the stop index is exclusive.

Answer

fh

Answer

h

Answer

hfd

Question 6

A junior developer writes a class 'Logger' that should only ever have one instance (singleton). They attempt to implement it by overriding __new__ to always return the same instance. However, when multiple threads attempt to create a Logger, they sometimes get different instances. Which modification will make the singleton thread-safe?

Accepted Answer

Use a lock (threading.Lock) in __new__ to serialize access. The race condition occurs when multiple threads simultaneously check `cls._instance` and find it `None`, then both proceed to create a new instance. Wrapping the creation logic inside a `threading.Lock` in `__new__` ensures that only one thread can execute the critical section at a time, guaranteeing that only one instance is ever created.

Answer

Use a class method get_instance() that checks a class variable and creates the instance if needed, and call that from __init__

Answer

Use a metaclass that overrides __call__ to return the singleton

Answer

Override __init__ to check if the instance was already initialized and if so, skip initialization

Question 7

Which THREE of the following are immutable types in Python?

Accepted Answer

str. (str) is correct because strings in Python are immutable sequences of Unicode code points. Once a string object is created, its contents cannot be changed; any operation that appears to modify a string (e.g., concatenation or slicing) actually creates a new string object in memory.

Answer

bytearray

Answer

list

Question 8

What happens when you execute the following code? s = 'hello'; s[0] = 'H'

Accepted Answer

TypeError is raised. In Python, strings 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`, not an `AttributeError` or `IndexError`, because the operation is a disallowed assignment on an immutable sequence type.

Answer

AttributeError is raised

Answer

String becomes 'Hello'

Answer

IndexError is raised

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

Which TWO statements about exception handling in Python are correct? (Select exactly 2.)

Accepted Answer

A single except clause can catch multiple exception types by passing a tuple of exceptions.. Python's except clause accepts a tuple of exception types, allowing a single handler to catch multiple exception types. For example, `except (ValueError, TypeError):` will catch either exception, which is a concise way to handle related errors without duplicating code.

Answer

The order of except clauses does not matter because only one will match.

Answer

An else block can be used without any except blocks in a try statement.

Answer

The else block in a try statement executes only if an exception was raised.

Question 11

A developer defines a class with an __init__ method that sets instance attributes. Which of the following is the correct way to call the parent class's __init__ from a child class?

Accepted Answer

super().__init__(arg1, arg2). `super().__init__(arg1, arg2)` is the modern, recommended way to call the parent class's `__init__` method in Python. It uses the `super()` function without arguments to automatically resolve the parent class based on the method resolution order (MRO), ensuring proper cooperative multiple inheritance and avoiding hardcoding the parent class name.

Answer

super(self, Child).__init__(arg1, arg2)

Answer

Parent.__init__(self, arg1, arg2)

Answer

Child.__init__(self, arg1, arg2)

Question 12

Match each Python data structure to its mutability.

Accepted Answer

list: Mutable. In Python, list, dict, and set are mutable data structures, meaning their contents can be modified. Tuple, string, and frozenset are immutable; their contents cannot be changed after creation. Common confusions include thinking tuples are mutable (they are not) or that frozensets are mutable (they are not).

Answer

tuple: Mutable

Answer

set: Immutable

Answer

frozenset: Mutable

Question 13

Which THREE of the following string methods return a boolean value (True or False)? (Choose exactly 3 correct answers.)

Accepted Answer

isspace(). The `isspace()` method returns `True` if all characters in the string are whitespace characters (e.g., space, tab, newline) and the string is non-empty; otherwise, it returns `False`. This is a boolean-returning method that checks a specific character property, making option A correct.

Answer

replace()

Answer

find()

Question 14

A cloud infrastructure engineer is developing a Python script to parse large configuration files from a fleet of servers. Each file can be up to 500 MB. The script reads the file line by line using a file object, strips comment lines (those starting with '#'), and accumulates only the configuration directives into a single string for further processing. The current code is:

```python
result = ''
with open('config.cfg') as f:
    for line in f:
        if not line.startswith('#'):
            result += line.strip()
```

After processing just a few hundred lines of a large file, the script becomes extremely slow and consumes an excessive amount of memory. The engineer identifies that string concatenation using `+=` is inefficient because strings are immutable, causing repeated memory reallocation. Which approach should the engineer implement to resolve the performance issue without changing the final output?

Accepted Answer

Use a list to collect stripped lines and then call `''.join(lines)` after the loop.. It avoids the O(n²) time complexity of repeated string concatenation by collecting stripped lines in a list and then joining them once with `''.join(lines)`. This leverages the efficient memory allocation of `str.join`, which precomputes the total size and allocates exactly once, solving the performance and memory issue without altering the final output.

Answer

Replace `result += line.strip()` with `result = result + line.strip()`.

Answer

Use `io.StringIO` to write lines and then retrieve content with `.getvalue()`.

Answer

Use `str.join` called on the file object: `f.join('')`.

Question 15

A data analyst is cleaning a CSV file. They have a string variable containing a row of data: 'John,Doe,30,New York'. They need to extract the last name 'Doe' using string methods. The analyst writes: name = row.split(',')[1]. However, they are concerned about performance because the file contains millions of rows. They want to use a more efficient method that extracts the substring without creating a full list. Which approach should the analyst use?

Accepted Answer

Use string slicing after finding the comma positions: start = row.find(',')+1; end = row.find(',', start); name = row[start:end]. It avoids creating a full list of all fields by using `find()` to locate the comma positions and then slicing the substring directly. This approach is more memory-efficient for millions of rows, as it only extracts the required portion without splitting the entire string into a list.

Answer

Use split(',', 2) and take the second element

Answer

Use partition(',') and get the third element

Answer

Use rsplit(',', 1) and take the first part