PCAP Strings Practice Test 12 — 15 Questions

Question 1

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?

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

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

Question 2

A function receives a file path like '/home/user/docs/file.txt' and needs to return the path without the file extension, e.g., '/home/user/docs/file'. Which code reliably removes only the last dot extension, even if the directory names contain dots?

Accepted Answer

path.rsplit('.', 1)[0]. `rsplit('.', 1)` splits the string from the right, limiting the split to exactly one occurrence, which isolates the file extension (the part after the last dot) and returns everything before it. This reliably removes only the last dot extension, even if directory names contain dots, because it targets the final dot in the path.

Answer

path.split('.')[0]

Answer

path.replace('.', '', 1)

Answer

path[:path.find('.')]

Question 3

A developer generates a report where numbers must be right-aligned in a 10-character column using f-strings: f'{value:>10}'. However, some values may be None, causing a TypeError. Which is the most robust way to handle None values without affecting other falsy values like 0?

Accepted Answer

f'{value if value is not None else "N/A":>10}'. It uses an explicit identity check (`value is not None`) to distinguish `None` from other falsy values like `0` or empty strings. This ensures that `0` is still right-aligned as a number, while `None` is replaced with the string `"N/A"` before formatting. The f-string then applies the `>10` alignment specifier to the resulting value.

Answer

Use str.format() with a conditional for the format spec

Answer

f'{value or "N/A":>10}'

Answer

Wrap the f-string in a try-except block

Question 4

Which TWO of the following string methods return a boolean value?

Accepted Answer

startswith(). The `startswith()` method returns `True` if the string starts with the specified prefix, otherwise `False`. Similarly, `isalpha()` returns `True` if all characters in the string are alphabetic and there is at least one character, otherwise `False`. Both methods explicitly return a boolean value (`True` or `False`), making them correct choices.

Answer

capitalize()

Answer

format()

Answer

swapcase()

Question 5

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 6

In a performance-critical application, you need to concatenate many strings in a loop. Which TWO approaches are most efficient?

Accepted Answer

Using the join() method on a list. The `join()` method on a list (Option B) is efficient because it allocates memory once for the final concatenated string, avoiding repeated reallocation and copying that occurs with immutable strings. `StringIO` (Option E) provides a mutable buffer that accumulates string fragments efficiently, making it suitable for high-performance concatenation in loops.

Answer

Using the % formatting operator

Answer

Using the += operator

Answer

Using the + operator

Question 7

A data entry application reads a CSV file where each line contains fields separated by commas. However, some fields are enclosed in double quotes and contain commas inside, e.g., 'John,"Doe, Jr.",30'. The developer currently uses line.split(',') to parse each line, which incorrectly splits the quoted field. The developer wants a solution using only the Python standard library (no third-party packages). Which of the following is the best approach?

Accepted Answer

Use the csv module's reader: import csv; next(csv.reader([line])). The csv module's reader is specifically designed to handle CSV parsing according to RFC 4180, including quoted fields with embedded commas. By passing the line wrapped in a list to csv.reader, the developer gets a properly parsed list of fields without needing to manually handle quote escaping or comma splitting.

Answer

Use line.strip().split(',') and then manually merge fields that start with a quote

Answer

Iterate through each character, track whether inside quotes, and split on commas outside quotes

Answer

Write a regular expression that matches commas outside quotes

Question 8

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()` is implemented in C, making it significantly faster than a Python-level list comprehension for thousands of conversions. It also inherently validates that the input contains only hexadecimal characters (and colons, which are ignored after removal), raising a `ValueError` for invalid input, which can be caught for robustness. This approach avoids the overhead of splitting, iterating, and calling `int()` for each octet.

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 9

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. `re.split(r'(\s+)', s)` splits the string into a list where every other element is a whitespace segment (preserving exact spaces and tabs), and the word segments can be reversed individually. Joining the list back with `''.join(...)` reconstructs the original whitespace exactly, meeting the requirement efficiently without manual iteration.

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 10

A junior developer is parsing a log file where each line has comma-separated fields. However, some fields are enclosed in double quotes and contain commas inside, e.g., '2023-08-15 14:30:00,WARNING,"Disk space low, please clean up".'. They are required to parse these lines using only built-in string methods (no modules like csv or re). Which approach is the most reliable and efficient?

Accepted Answer

Write a custom parser that iterates over characters, toggles a quote flag, and splits on commas when outside quotes. A custom parser that toggles a quote flag while iterating over characters can reliably distinguish commas inside double quotes from field-separating commas. This approach handles embedded commas and escaped quotes without relying on external modules, making it both efficient and robust for the given constraints.

Answer

Remove all double quotes from the line before splitting

Answer

Use a regular expression that matches commas outside double quotes

Answer

Use the split() method and then merge fields that start with a double quote

Question 11

A data scientist needs to count the occurrences of a substring in a long DNA sequence (e.g., 1 million bases). However, the count must include overlapping occurrences. For example, in 'AAAA', the substring 'AA' appears three times overlapping. The built-in count() method does not count overlapping matches. The scientist needs a function to count overlapping substrings efficiently without using third-party libraries. Which of the following approaches is the most efficient for this task?

Accepted Answer

Use re.findall with a positive lookahead: len(re.findall(r'(?=AA)', sequence)). `re.findall` with a positive lookahead `(?=AA)` matches overlapping occurrences without consuming characters. The lookahead assertion checks for the substring at each position without advancing the match position, so every overlapping occurrence is found. This is more efficient than manual loops because the underlying regex engine is implemented in C and optimized for pattern matching.

Answer

Use a for loop with slicing and compare: sum(1 for i in range(len(s)-len(sub)+1) if s[i:i+len(sub)] == sub)

Answer

Use two nested loops to check all possible positions

Answer

Use a while loop with str.find() and increment the start index by 1

Question 12

A developer is validating user input in a Python application. The string variable `input_str` is assigned the value `'Hello World'`. Which TWO of the following conditions evaluate to `True`? (Choose two.)

Accepted Answer

input_str.istitle(). `istitle()` returns `True` when the string is titlecased, meaning the first character of each word is uppercase and all other characters are lowercase. 'Hello World' has both words starting with an uppercase letter followed by lowercase letters, so it satisfies this condition.

Answer

input_str.isalpha()

Answer

input_str.isalnum()

Answer

input_str.isspace()

Question 13

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 14

A developer is building an IoT application that reads temperature data from a sensor over a TCP socket. The sensor sends data as a stream of bytes encoded in UTF-8, with each reading terminated by a newline character. The developer uses the following code to receive data:

```python
import socket
s = socket.socket()
s.connect(('sensor.local', 5000))
data = s.recv(1024)
```

The variable `data` is a bytes object. The developer needs to convert it to a string to parse the temperature value. Which of the following lines of code should the developer use to correctly obtain the string representation of the received data, assuming the data is valid UTF-8 and may contain non-ASCII characters?

Accepted Answer

data.decode('utf-8'). The `recv()` method returns a bytes object. Since the data is valid UTF-8 and may contain non-ASCII characters, the correct way to convert bytes to a string is by calling `data.decode('utf-8')`. This method interprets the byte sequence according to the UTF-8 encoding and returns a Unicode string.

Answer

data.encode('utf-8')

Answer

bytes(data)

Answer

str(data)

Question 15

Which TWO string methods raise an exception when the searched substring is not found?

Accepted Answer

rindex(). (rindex()) is correct because the rindex() method, like index(), raises a ValueError exception when the searched substring is not found. This is in contrast to rfind() and find(), which return -1 instead of raising an exception.

Answer

rfind()

Answer

find()

Answer

count()