PCAP Practice Test 37 — 15 Questions

Question 1

Refer to the exhibit. What is the output?

Accepted Answer

4. The __add__ method adds the two values and adds 1, so 1+2+1=4.

Answer

3

Answer

Error

Answer

A object

Question 2

Refer to the exhibit. What is the output?

Accepted Answer

10. Base.method returns 3*2=6, Derived.method adds 4, so 10.

Answer

7

Answer

Error

Answer

14

Question 3

Refer to the exhibit. What is the output?

Accepted Answer

0 12.56. First object is Shape, area returns 0. Second is Circle, area returns 3.14*4=12.56.

Answer

12.56 0

Answer

Error

Answer

0 0

Question 4

Refer to the exhibit. If 'data.txt' does not exist, what happens?

Accepted Answer

A NameError is raised because f is not defined in the finally block.. The open() call raises FileNotFoundError, so f is never assigned. The finally block tries to call f.close() on an undefined variable, causing a NameError.

Answer

The function returns None.

Answer

A FileNotFoundError is raised and not caught.

Answer

The file is created and then closed.

Question 5

Refer to the exhibit. What is the output of the code?

Accepted Answer

True. After closing the file, file.closed returns True.

Answer

None

Answer

False

Answer

Error

Question 6

Refer to the exhibit. The script stops with this error. Which exception type should be caught to handle this error gracefully?

Accepted Answer

OSError. The error is FileNotFoundError, which is a subclass of OSError. Catching OSError or FileNotFoundError would handle it.

Answer

ValueError

Answer

FileNotFoundError

Answer

IOError

Question 7

Your team is developing a large application with many packages. To avoid name conflicts, you decide to use namespace packages. You have two directories: /team/common/ and /team/analytics/. Both contain an __init__.py file. You want to create a namespace package 'team' that combines these two directories. You create a directory /team/ with no __init__.py. You then set PYTHONPATH to /team/common/ and /team/analytics/ (actually, you set it to the parent directories). But when you try to `from team.common import something`, you get ModuleNotFoundError. What is the most likely reason?

Accepted Answer

The PYTHONPATH should point to the parent directory of 'team', not to the subdirectories directly.. Option B is correct because for namespace packages to work, PYTHONPATH must point to the parent directory of the 'team' namespace package, not to the subdirectories 'common' and 'analytics' directly. When PYTHONPATH includes '/team/common/' and '/team/analytics/', Python treats each as a separate top-level package, so 'from team.common import something' fails because 'team' is not found as a package. The correct setup is to set PYTHONPATH to the directory containing 'team' (e.g., '/team/'), allowing Python to discover 'team' as a namespace package and then locate 'common' and 'analytics' as sub-packages.

Answer

The presence of __init__.py in 'common' and 'analytics' prevents them from being part of a namespace package.

Answer

The namespace package requires an __init__.py in the parent directory as well.

Answer

The sys.path must also include the 'team' directory itself.

Question 8

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 9

A development team is building a real-time chat application using Python. The application uses a class 'ChatRoom' that maintains a list of 'User' objects as active participants. Each User object holds a reference back to its ChatRoom to send messages. Over time, the application runs out of memory. Profiling reveals that User objects are not being garbage collected even after users disconnect. The team suspects circular references. Which solution would effectively resolve the memory leak without breaking the functionality?

Accepted Answer

Use weakref.WeakSet for the participants list in ChatRoom, so that when a User is no longer referenced elsewhere, it is automatically removed. Option A is correct because using a `weakref.WeakSet` for the participants list in `ChatRoom` means the `ChatRoom` holds only weak references to `User` objects. When a user disconnects and all external references to that `User` are removed, the `User` object becomes unreachable and can be garbage collected, even though the `User` still holds a strong reference back to the `ChatRoom`. This breaks the circular reference without requiring manual intervention or altering the `User`-to-`ChatRoom` relationship.

Answer

Increase the Python heap size using PYTHON_MALLOC_DEBUG to avoid memory issues

Answer

Store the ChatRoom reference in User using a weakref.ref, so that the cycle is broken

Answer

Manually call gc.collect() every time a user disconnects

Question 10

A developer has a string that contains literal escape sequences like '\n' and '\t' (i.e., a backslash followed by 'n' or 't') and needs to convert them into actual control characters (newline, tab). The string comes from a configuration file that was written with double backslashes to represent single backslashes in the original configuration. The developer wants to use standard Python functionality. For example, the string "hello\nworld" should become "hello
world" (a string with a real newline). Which of the following is the simplest and most reliable method?

Accepted Answer

Encode the string to bytes and decode with 'unicode_escape': s.encode('utf-8').decode('unicode_escape'). Encoding the string to bytes and then decoding with 'unicode_escape' interprets the escape sequences. For example, s.encode('utf-8').decode('unicode_escape') works for standard escape sequences. Option A does this. Option B (manual replace) is error-prone if there are many escape types. Option C (regex) is more complex. Option D (ast.literal_eval) requires forming a valid string literal, which can be done but is less direct.

Answer

Use multiple str.replace() calls for each known escape sequence

Answer

Use ast.literal_eval on a quoted version of the string: ast.literal_eval('"' + s + '"')

Answer

Use a regex substitution to replace each escape sequence with its corresponding character

Question 11

A junior developer is building a script to convert user-provided headlines into URL slugs. The slug should contain only lowercase alphanumeric characters and single hyphens between words, with no leading or trailing hyphens. For example, 'Hello World! How are you?' should become 'hello-world-how-are-you'. The current code is: slug = input_string.lower().replace(' ', '-').replace('!', '').replace('?', ''). However, this produces multiple hyphens when there are multiple spaces, and trailing hyphens if the string ends with punctuation. The developer needs to modify the code to handle these issues reliably. Which of the following approaches is the most robust and efficient?

Accepted Answer

words = [w.strip('!?.,') for w in input_string.lower().split()]; slug = '-'.join(filter(None, words)). Option B splits the string into words (using split() which handles multiple spaces), strips punctuation from each word, filters out empty strings, and joins with a single hyphen. This ensures no multiple hyphens or leading/trailing hyphens. Option A uses regex but is more complex and may still have edge cases. Option C uses replace with regex but similar issues. Option D is a manual loop that is less efficient and error-prone.

Answer

Use string.replace multiple times to replace punctuation and then replace multiple spaces with a single hyphen

Answer

Use re.sub(r'[^a-z0-9]+', '-', input_string.lower()).strip('-')

Answer

Iterate over each character, build a list of allowed characters, and join with hyphens

Question 12

A DevOps engineer is writing a Python script to parse a configuration file. The file contains lines like: 'PARAMETER = value'. The engineer needs to extract the value part after the '=' sign, but there may be multiple equals signs in the value (e.g., 'DATABASE = mysql://user:pass@host/db'). The engineer initially uses line.split('=')[1] but this fails if there are extra equals. Which of the following approaches correctly extracts everything after the first '=' sign?

Accepted Answer

Both A and B work. Both split('=',1)[1] and partition('=')[2] will correctly extract everything after the first '='. split with maxsplit=1 splits at the first '=' only, returning a list of two elements. partition returns a tuple of three, where the third element is everything after the separator. Both work correctly. Using find and slicing also works but is more manual.

Answer

Use line.find('=') and slice from that index+1

Answer

Use line.partition('=')[2]

Answer

Use line.split('=', 1)[1]

Question 13

A network engineer processes a configuration file containing MAC addresses in the format 'aa:bb:cc:dd:ee:ff'. They need to convert each MAC address into a 6-byte bytes object for use in packet crafting. The current code is: mac_bytes = bytes([int(x, 16) for x in mac_str.split(':')]). This works correctly, but they need to process thousands of MAC addresses and want to optimize performance. They also need to handle invalid MAC addresses (e.g., non-hex characters) without crashing. Which of the following approaches is the most efficient and robust?

Accepted Answer

Use bytes.fromhex(mac_str.replace(':', '')). bytes.fromhex(mac_str.replace(':', '')) is efficient because fromhex is implemented in C and handles hex parsing quickly. It also raises ValueError for invalid input, so it can be wrapped in try-except. Option A also works but is slower due to list comprehension and int conversion in Python. Option C uses struct.pack which is also efficient but less direct. Option D is the slowest. Therefore, B is the best.

Answer

Use the same list comprehension but add a try-except block for ValueError

Answer

Use struct.pack('BBBBBB', *[int(x,16) for x in mac_str.split(':')])

Answer

Use a for loop to parse each pair and build a bytearray

Question 14

A developer is writing a function to reverse each word in a sentence while preserving the original order of the words. For example, 'Hello World' should become 'olleH dlroW'. The current implementation is: def reverse_words(s): return ' '.join(word[::-1] for word in s.split()). This works for simple cases. However, the input may contain multiple spaces between words (e.g., 'Hello   World') and tabs. The requirement is to preserve the exact whitespace between words (including tabs and multiple spaces) in the output. Which of the following modifications will achieve this while keeping the approach efficient?

Accepted Answer

Use re.split(r'(\s+)', s) to separate words and whitespace, then reverse the word parts and join back. To preserve whitespace, we need to split using a regex that captures the separators, then reverse each word and rejoin. Option C does this: re.split(r'(\s+)', s) splits and keeps the separators, making it easy to reverse non-whitespace parts. Option A loses the exact spacing. Option B does not preserve tabs. Option D is a manual loop that is error-prone.

Answer

Use s.split(' ') and handle empty strings to preserve spaces, but ignore tabs

Answer

Iterate over the string, detect word boundaries, and build a new string manually

Answer

Use s.split() and then join with the original spaces using a separate loop that tracks whitespace

Question 15

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.. Option B is correct because collecting lines in a list and joining them at the end avoids repeated string copying, solving the performance issue. Option A is wrong because it still uses concatenation, just with a different operator. Option C is wrong because file objects do not have a `join` method. Option D is wrong because while `StringIO` works, it is less efficient and not the standard recommended approach; `join` is more direct.

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('')`.

PCAP Practice Test 37 — 15 Questions

Exhibit

PCAP Practice Test 37 — 15 Questions

Exhibit