PCAP Strings Practice Test 12 — 15 Questions

Question 1

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 2

Which TWO of the following can be used to remove leading whitespace (spaces, tabs, newlines) from a string? (Choose exactly 2 correct answers.)

Accepted Answer

lstrip(). The `lstrip()` method removes all leading whitespace characters (spaces, tabs, newlines) from the left side of a string. `strip()` removes leading and trailing whitespace, so it also satisfies the requirement of removing leading whitespace. Both are built-in string methods in Python.

Answer

rstrip()

Answer

trim()

Answer

clean()

Question 3

A developer wants to convert a string 'Python' to all uppercase letters. Which string method should be used?

Accepted Answer

upper(). The `upper()` method returns a copy of the string with all lowercase characters converted to uppercase. Since the goal is to convert 'Python' to 'PYTHON', `upper()` is the correct and most direct method for this task.

Answer

capitalize()

Answer

title()

Answer

swapcase()

Question 4

A developer is working on a logging system where dynamic values are inserted into a template string. The template is 'User %s logged in at %s'. The developer has the username and timestamp as separate variables. Which approach is most Pythonic (PEP 498) and recommended for new code?

Accepted Answer

Use an f-string: f'User {username} logged in at {timestamp}'. PEP 498 introduced f-strings (formatted string literals) as the recommended approach for string formatting in Python 3.6+. They are concise, readable, and evaluated at runtime, allowing direct embedding of expressions. This aligns with the 'Pythonic' principle of simplicity and is the preferred style for new code according to the official Python documentation.

Answer

Use %-formatting: 'User %s logged in at %s' % (username, timestamp)

Answer

Use .format(): 'User {} logged in at {}'.format(username, timestamp)

Answer

Concatenate: 'User ' + username + ' logged in at ' + timestamp

Question 5

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

Question 6

Which method returns the lowest index where a specified substring is found, or -1 if not found?

Accepted Answer

find(). The `find()` method in Python returns the lowest index where the specified substring is found within the string, or -1 if the substring is not present. This behavior directly matches the question's requirement, making option A correct.

Answer

locate()

Answer

search()

Answer

index()

Question 7

A developer needs to extract the file extension from a filename like 'document.pdf'. Which expression returns 'pdf'?

Accepted Answer

filename.rsplit('.', 1)[-1]. `rsplit('.', 1)[-1]` splits the string from the right at the last occurrence of the dot, limiting to one split, and then retrieves the last element (index -1), which is the file extension. This handles filenames with multiple dots (e.g., 'archive.tar.gz') correctly, returning only the final extension.

Answer

filename.split('.')[1]

Answer

filename.split('.')[0]

Answer

filename[-3:]

Question 8

What is the result of the expression '12345'[:10]?

Accepted Answer

'12345'. In Python, slicing a string with a start index of 0 and an end index of 10 (as in '12345'[:10]) returns the entire string if the slice end exceeds the string length. Since '12345' has only 5 characters, the slice extracts all characters without padding or error, resulting in '12345'.

Answer

'12345     '

Answer

IndexError

Answer

'12345 '

Question 9

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

Question 10

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 11

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 12

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

Refer to the exhibit. What happens when the code is executed?

Accepted Answer

A TypeError is raised. The code attempts to modify a string by assigning a new character to an index position (s[0] = 'H'). Strings in Python are immutable, meaning their elements cannot be changed after creation. This operation raises a TypeError because the item assignment is not supported for string objects.

Answer

The string becomes "Hallo"

Answer

A SyntaxError is raised

Answer

The code runs without error and s remains "Hello"