PCAP Strings Practice Test 9 — 15 Questions

Question 1

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?

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

Accepted Answer

words = [w.strip('!?.,') for w in input_string.lower().split()]; slug = '-'.join(filter(None, words)). It splits the string into words (removing all whitespace), strips punctuation from each word, filters out any empty strings (e.g., from multiple spaces), and joins the cleaned words with a single hyphen. This reliably eliminates multiple hyphens and leading/trailing hyphens without relying on fragile multiple replace calls or regex that could mishandle edge cases like consecutive punctuation.

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 2

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 3

A developer receives a string that looks like a JSON object but uses single quotes instead of double quotes and has unquoted keys. For example: "{'name': 'John', 'age': 30}". They need to convert this into a Python dictionary. They are allowed to use any standard library module. Which approach is the simplest and safest?

Accepted Answer

Use ast.literal_eval() directly on the string. ast.literal_eval() safely evaluates Python literal syntax, including dicts with single-quoted keys/values. It is the simplest and safest because it requires no string transformation and does not execute arbitrary code. json.loads() with simple quote replacement is not a robust general solution: it may break on strings containing apostrophes and does not fix truly unquoted keys (as stated in the question).

Answer

Use eval() after replacing the outer single quotes with double quotes

Answer

Use a regular expression to parse the key-value pairs

Answer

Use json.loads() after replacing single quotes with double quotes

Question 4

A developer is building a template system where placeholders like {name} and {age} appear in large text documents. They have a dictionary 'data' with the replacement values. Currently, they use a loop that calls str.replace() for each placeholder, e.g., for key, value in data.items(): text = text.replace('{' + key + '}', str(value)). This works, but performance is poor on large texts with many placeholders. The developer wants to use a more efficient method from the Python standard library. Which of the following is the best alternative?

Accepted Answer

Use text.format_map(data). `str.format_map(data)` is a built-in method that performs dictionary-based placeholder replacement in a single pass, avoiding the O(n*m) overhead of repeated `str.replace()` calls. It directly substitutes keys like `{name}` with corresponding values from the dictionary, making it far more efficient for large texts with many placeholders.

Answer

Use re.sub with a function that looks up the dictionary

Answer

Use an f-string with the dictionary unpacked as local variables

Answer

Use string.Template with data.safe_substitute

Question 5

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 6

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 7

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 8

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 decoding with 'unicode_escape' is the simplest and most reliable way to interpret literal escape sequences like '\n' and '\t' as actual control characters. The 'unicode_escape' codec treats backslash-prefixed sequences as escape codes, converting them into their corresponding characters (e.g., '
' becomes a newline). This method handles all standard escape sequences in one step without needing to manually list each one.

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 9

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 10

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 11

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

Question 12

A developer needs to count the number of occurrences of the substring 'is' in the string 'This is a test. Is this a test?'. Which code correctly performs the count?

Accepted Answer

'This is a test. Is this a test?'.count('is'). Python's string method `count(substring)` returns the number of non-overlapping occurrences of the substring in the string. In 'This is a test. Is this a test?', 'is' appears twice (in 'This' and 'is'), and the method counts them correctly, ignoring case sensitivity (the capitalized 'Is' is not counted).

Answer

'This is a test. Is this a test?'.split().count('is')

Answer

'This is a test. Is this a test?'.index('is')

Answer

'This is a test. Is this a test?'.find('is')

Question 13

Which THREE are valid ways to create a multiline string in Python?

Accepted Answer

s = ('Line1
' 'Line2'). Options A, B, and C are all valid ways to create a multiline string in Python. Option A uses implicit string concatenation within parentheses; the `
` escape sequence inserts a newline, resulting in a multiline string. Option B uses triple double quotes to span multiple lines physically, preserving line breaks. Option C uses triple single quotes, which work identically to triple double quotes for multiline strings. Option D uses a backslash for line continuation, which does not insert a newline into the string—it just continues the literal on the next line, so the result is a single-line string without a newline. Option E causes a syntax error because a single-quoted string literal cannot span multiple lines without a continuation character.

Answer

s = "Line1\
Line2"

Answer

s = 'Line1
Line2'

Question 14

Which THREE methods return a boolean value?

Accepted Answer

str.startswith(). B is correct because str.startswith() returns True if the string starts with the specified prefix, otherwise False. It is a boolean-returning method, as required by the question.

Answer

str.upper()

Answer

str.find()

Question 15

You are a data analyst working with a dataset of customer reviews. Each review is stored as a string in a list. You need to count how many reviews contain the word 'excellent' (case-insensitive). However, the word might appear as 'Excellent', 'EXCELLENT', or even with punctuation like 'excellent!'. The current code uses 'excellent' in review.lower(), but this fails if 'excellent' is part of another word like 'unexcellent'. You need to ensure that only the whole word 'excellent' is counted. Which code modification will correctly count whole word occurrences?

Accepted Answer

Use re.search(r'\bexcellent\b', review, re.IGNORECASE). `re.search(r'\bexcellent\b', review, re.IGNORECASE)` uses the `\b` word boundary anchor to ensure that 'excellent' is matched as a whole word, not as part of another word like 'unexcellent'. The `re.IGNORECASE` flag handles case-insensitive matching, covering 'Excellent', 'EXCELLENT', etc. This approach also correctly handles punctuation attached to the word, such as 'excellent!', because the word boundary matches between a word character and a non-word character.

Answer

Use 'excellent' in review.lower().split()

Answer

Use review.lower().count('excellent') > 0

Answer

Use review.lower().find('excellent') != -1