Strings practice questions

r'[0-9]+\. [0-9]+\.[0-9]+\.[0-9]+'

Why it fails: This pattern embeds a literal space after the first escaped dot (`\. `), so it expects input like `192. 168.1.1` rather than the standard `192.168.1.1` found in server logs. Even if the space were removed, using `+` instead of `{1,3}` would make it over-permissive, but the immediate fatal flaw is the space, which causes every well-formed IP address to fail the match. The correct regex contains no whitespace and repeats the octet pattern with a non-capturing group.

r'\d+\.\d+\.\d+\.\d+'

Why it fails: The `\d+` quantifier matches one or more digits with no upper bound, so this pattern incorrectly accepts octets like `1234` or `9999`, which are impossible in valid IPv4 dotted-decimal notation. While it does match well-formed addresses, its lack of a `{1,3}` length limit makes it too permissive for log parsing, where garbage strings such as `1234.5678.9012.3456` must be excluded. In contrast, the correct pattern constrains each octet to at most three digits.

s.split('')

Why it fails: Calling s.split('') passes an empty string as the separator, which Python explicitly forbids: the method raises ValueError: empty separator rather than returning a list of characters. The split() method always needs a non-empty separator (or None) to delimit substrings, so it cannot be used to break a string into individual characters.

s.split()

Why it fails: With no arguments, s.split() uses any run of whitespace as the delimiter and automatically removes leading/trailing whitespace, so for 'hello world' it produces ['hello', 'world'] and discards the space. This is word tokenization, not character expansion; each element is a multi-character word, so it does not return the desired list of characters.

s.split(' ')

Why it fails: Using s.split(' ') supplies a single literal space as the separator, so the result is a list of substrings separated by spaces — for 'hello world' that is ['hello', 'world'], again losing the character-level structure. Moreover, because it only looks for exact space characters, consecutive spaces would create empty-string entries, and tabs or newlines would not split at all; either way it does not enumerate characters.

'Name: %s, Age: %d' % (name, age)

Why it fails: Although this statement is valid Python and would produce the expected string, it is marked wrong because the question targets the modern f-string syntax. %-formatting is the legacy printf-style approach that requires the format specifier (%s, %d) to match the argument type, and it is less readable and more error-prone than f-strings. Since the answer key expects f-strings, this option, while functional, is not the correct choice.

'Name: {name}, Age: {age}'.format(name, age)

Why it fails: The .format() call here is invalid because the replacement fields are named but the arguments are passed positionally; Python will raise KeyError when trying to resolve {name}. To make it work, you must either write .format(name=name, age=age) to supply keyword values, or replace the fields with positional indexes like {0} and {1} while passing arguments in order. This option is wrong because the format string and argument list are mismatched.

'Name: {0}, Age: {1}'.format(age, name)

Why it fails: This option uses positional replacement fields but reverses the argument order: {0} maps to the first argument (age) and {1} maps to the second (name), so the output will incorrectly show Name: <age>, Age: <name>. Even though the syntax is valid, the swapped arguments produce incorrect data, so it cannot be correct. If the intent were to use positional fields, the arguments should be passed as .format(name, age) to match {0} with name.

s[0] in 'aeiou'

Why it fails: This expression is not using the startswith method at all; it simply tests whether the first character of s is a member of the string 'aeiou'. It would only work for a single-character prefix, and it raises IndexError if s is empty because s[0] becomes an out-of-range access. It is also case-sensitive, so 'Apple' would return False unless you normalize the string first. Therefore, it is not the startswith-based approach the question is asking for.

s.startswith('a','e','i','o','u')

Why it fails: This call is invalid because str.startswith accepts at most three positional arguments: prefix (as a string or tuple), start, and end. Passing five separate strings causes a TypeError because 'a' is bound to prefix, 'e' to start, 'i' to end, and 'o' and 'u' have no matching parameters. To check against multiple prefixes, the accepted technique is to pack them into a tuple and pass that tuple as the first argument.

s.startswith('a') or 'e' or 'i' or 'o' or 'u'

Why it fails: This expression misuses Python's short-circuit boolean or logic. It evaluates as (s.startswith('a')) or 'e' or 'i' or 'o' or 'u'; if s.startswith('a') is False, the next operand is the non-empty string 'e', which is truthy, making the entire expression always truthy regardless of s. It never calls startswith for 'e', 'i', 'o', or 'u', so it does not actually test those vowels. The correct way to test multiple prefixes is to pass a tuple to startswith, not to chain or operators.

16

Why it fails: If the length were 16, the valid indexes would stop at 15, and the character at index 15 would be the final character. In the real string, the character at index 15 is the letter i, but two further characters, n and g, follow at indexes 16 and 17. Thus length 16 cuts off the last two characters and is too short by two.

17

Why it fails: If the string were 17 characters long, its valid zero-based indexes would run from 0 through 16, so a reference like s[15] would still be legal. However, the literal Python Programming contains 6 characters in Python, 1 space, and 11 characters in Programming — 18 characters in all. Choosing 17 requires silently dropping one of those characters, so it undercounts the actual string by one.

19

Why it fails: A length of 19 would imply indexes 0 through 18, meaning there is an extra character beyond the 18 visible in the literal. The string Python Programming has no trailing spaces, newline, or other hidden characters, so nothing exists to occupy an index 18. Therefore 19 overcounts the actual size by exactly one character.

['support@example', 'sales@example']

Why it fails: This output would only occur if the regex pattern terminated the match before the literal dot and top-level domain, such as with r'\b\w+@\w+\b', which captures only the domain name and stops at 'example'. The actual pattern includes the escaped dot and the TLD segment (r'\.\w+'), so the full addresses are matched and returned, not these truncated fragments.

[]

Why it fails: An empty list would result if the pattern failed to match any substring in the text—for instance, if it incorrectly required the TLD to be exactly '.com' while the second address ends in '.org', or if re.match() were used instead of re.findall(), which anchors the match at the beginning of the string. The given pattern is general enough to match both email addresses, and the text contains them, so findall() returns two occurrences rather than zero.

['support@example.com']

Why it fails: Returning only the first address would be the behavior of re.search(), which finds the leftmost match and returns a match object rather than a list of all matches. It could also happen if the regex had a trailing condition that failed for '.org', but the pattern here is indifferent to the specific TLD. Since the question uses re.findall(), which collects every match, both addresses are returned, making this option incomplete.

Install the package using 'pip install package_name', then verify the installation by importing the package, then open a terminal/command prompt, then verify pip is installed.

Why it fails: This order is invalid because it attempts to install the package before establishing that a terminal is open and that pip is even available—both are mandatory prerequisites for running pip commands. Moreover, importing the package immediately after installation, before verifying pip, assumes the installation succeeded without confirming the tool that performed it. Even if the import happened to work, the sequence still places the terminal and pip checks after the fact, which is backwards: you cannot execute 'pip install' without a shell, and you should not skip the pip availability check before installing. The verification of pip's presence must precede installation, not follow it.

Verify pip is installed, then open a terminal/command prompt, then verify the installation by importing the package, then install the package.

Why it fails: This ordering is impossible because 'pip --version' is a command-line instruction that requires a terminal/command prompt to execute; you cannot verify pip's installation without first opening a shell. Additionally, this sequence places 'verify the installation by importing the package' before the actual 'install the package' step, which is logically contradictory—there is nothing to import if the package has not yet been installed. Even after correcting the order, installing the package after verifying the import makes no sense because the import would fail on a freshly installed system unless the package was already present. The correct flow must start with a terminal, then check pip, then install, and only then verify via import.

Open a terminal/command prompt, then install the package, then verify the installation, then check if pip is installed.

Why it fails: The critical flaw here is that pip's availability is not checked until the very end, after installation and verification. If pip were missing or not on the PATH, the 'pip install package_name' command would have failed immediately, making the later verification and pip check redundant or misleading. Checking pip after the fact is also impractical because you would not know whether an installation failure was due to a missing package, a network issue, or an unavailable pip. A robust workflow always validates the toolchain (pip) before attempting the installation, and then verifies the installed artifact by importing it—never the reverse order.

for v in 'aeiou': s = s.replace(v, '')

Why it fails: Using str.replace in a loop repeatedly allocates a brand-new string on every iteration: each call scans the entire current string and copies every character except the target vowel, so for n characters and k vowels the time grows to O(k·n). It also does not exploit the translation machinery already built into strings, and the repeated C-level passes are unnecessarily expensive for a task that can be done in one pass.

return s.translate(str.maketrans('', '', 'aeiou'))

Why it fails: str.translate with a table built by str.maketrans('', '', 'aeiou') maps each vowel character to None, which instructs translate to delete that character while walking the string exactly once at C speed inside the interpreter. No temporary strings are produced during the operation, no Python code runs per character, and the final string is assembled in a single optimized pass—making this the fastest and most direct approach for removing a fixed set of characters. The table is tiny and can even be precomputed if the call is repeated.

return re.sub('[aeiou]', '', s, flags=re.I)

Why it fails: re.sub('[aeiou]', '', s, flags=re.I) correctly performs a case-insensitive replacement, but it hands a trivial character-removal task to the regex engine, which must first parse and compile the pattern (or look it up in the compile cache) and then drive the match through a state machine. That machinery adds fixed overhead and is slower than a specialized string method, even though the pattern is a basic character class without any complex constructs. For any non-trivial volume of text, importing or calling re for this job is disproportionate to the operation.

'100'

Why it fails: The print() function writes the string's actual contents to standard output, without adding any quotation marks. The quotes in the source code are delimiters that define the string literal, but they are not part of the string value itself. To display quotes, one would need to include them explicitly or use repr(), so showing '100' with quotes is not what print('100') produces.

True

Why it fails: Although '100' is a non-empty string and would be considered truthy in a boolean context like an if condition, print('100') does not evaluate its argument as a boolean. The print() function simply converts the argument to its string representation and writes it out. The output is the literal characters 1, 0, and 0, not the keyword True.

Error

Why it fails: The code print('100') is perfectly valid; it uses the built-in print() function with a string literal argument. No syntax or runtime error occurs because the parentheses and quotes are balanced and the string is well-formed. The program will execute and output the characters 100 to the console.

email.partition('@')[0]

Why it fails: Using partition('@') divides the string at the first occurrence of the '@' character, returning a three-element tuple (head, separator, tail). Index [0] therefore captures everything to the left of that first '@', which is the mailbox/local portion of the address, not the domain. Even if no '@' exists, partition returns the whole original string in index [0], so this expression never yields the domain.

email.split('@')[1]

Why it fails: split('@') without a maxsplit argument breaks the string at every '@' character, producing a list of all segments. Accessing [1] returns the second segment, which is only the domain when the address contains exactly one '@'. If the local part has an embedded '@' (for example 'user@name@example.com'), this expression returns 'name' instead of 'example.com'.

email.split('@', 1)[1]

Why it fails: split('@', 1) splits only once, starting from the left, so [1] contains everything after the first '@' rather than isolating the domain. For an address with a single '@' this happens to work, but for a valid local part that includes an '@' (e.g., 'user@name@example.com'), index [1] becomes 'name@example.com', mixing the rest of the local part with the domain. The one split is anchored to the wrong side.

Change `{0:s}` to `{0:str}` to explicitly specify string conversion.

Why it fails: The format-spec mini-language is not a set of Python type names: `str` is not a recognized format code, and the type code for string formatting is the single letter `s`. Because `42` is an int, even `s` itself would still fail, but `{0:str}` introduces a second problem by trying to use an invalid multi-character code, so this does not fix the original ValueError.

Change `{0:s}` to `{0:i}` to indicate integer.

Why it fails: The letter `i` is a C-style `printf` conversion specifier for integers, but Python's `format` mini-language does not support it; valid integer type codes are `b`, `c`, `d`, `n`, `o`, `x`, and `X`. Using `{0:i}` would still raise `ValueError`, just with a different unknown-code message, so it does not address the error.

'ty'

Why it fails: 'ty' is what you get from a backward slice that stops before including the start index, such as `s[-4:0:-1]`: it captures indices 2 and 1 only. The correct slice `s[-4::-1]` has no stop value, so Python keeps stepping back through index 0 (the 'P') as well, producing "tyP". Omitting that final index is what makes 'ty' incomplete.

'tho'

Why it fails: 'tho' is the result of `s[-4:]`, which uses the default step of +1 and no stop index, so it moves forward from index 2 to the end of the string. This is the exact opposite direction from the required backward traversal. A negative step is what changes the slice from a forward substring into a reversed walk to the string's beginning.

'nohtyP'

Why it fails: 'nohtyP' is the output of `s[::-1]`, which reverses the entire string by starting at the last character and stepping -1 all the way to index 0. The target slice, in contrast, starts at index -4 (the 't') and then steps backward, so it only covers the portion from that index up to the start. It never includes indices 5, 4, or 3, which are the characters 'n', 'o', and 'h'.

s[0:2:2]

Why it fails: Yields 'P' because step 2 skips the second character.

s[-6:-3]

Why it fails: Yields 'Pyt' (indices -6, -5, -4).

s[0:1]

Why it fails: Yields 'P' only.

20

Why it fails: Option 20 is wrong because 20 is the length of the original string `" Python Programming "` before any whitespace is removed. Strings are immutable, so `strip()` returns a completely new string of length 18 and does not modify the original; a result of 20 would come from calling `len()` on the original variable instead of on the value returned by `strip()`.

17

Why it fails: Option 17 is wrong because it ignores the space between the two words: counting only the letters in `"Python"` (6) and `"Programming"` (11) gives 17, but `len()` counts every character, including internal whitespace. `strip()` only removes whitespace at the very beginning and end of the string, so the space between `"Python"` and `"Programming"` remains and contributes 1 to the total length.

19

Why it fails: Option 19 is wrong because that count would result from removing only one of the two outer spaces, such as using `lstrip()` to get `"Python Programming "` or `rstrip()` to get `" Python Programming"`. The default `strip()` method removes all leading and trailing whitespace from both ends at once, so it cannot leave exactly one boundary space behind.

' Alice is 25 years old.'

Why it fails: Same as C.

'Alice is 25 years old.'

Why it fails: This would be left-aligned.

' Alice is 25 years old.'

Why it fails: Missing zero-padding.

items = data.split(); second = items[1]

Why it fails: Calling split() with no arguments treats any run of whitespace as a delimiter, so it never separates on the comma itself. In the input 'apple, banana, cherry', the returned list is ['apple,', 'banana,', 'cherry'], making items[1] equal to 'banana,' with the comma still attached. This produces the wrong value because the expected second item is 'banana' without any punctuation.

items = data.split(","); second = items[2].strip()

Why it fails: When split(',') is used, the result list is ['apple', ' banana', ' cherry'] because the delimiter is only the comma, not comma-space. Index 2 points to the third entry, ' cherry', and applying strip() yields 'cherry', not 'banana'. The mistake here is conflating the ordinal position 'second' with the zero-based index 2; the second item is always at index 1.

text.count('\r\n') + text.count('\n')

Why it fails: Adding text.count('\r\n') and text.count('\n') double-counts CRLF line endings because every \r\n substring contains a \n character that text.count('\n') also counts. For "Hello\nWorld\r\n", text.count('\r\n') is 1 and text.count('\n') is 2, yielding a total of 3 even though there are only 2 lines. This approach also miscounts when line endings are mixed (e.g., a file using both LF and CRLF) and gives no credit for lines ending in bare \r or other Unicode separators.

len(text.split('\n'))

Why it fails: len(text.split('\n')) does not count lines correctly because splitting on the literal LF character leaves the \r attached to the end of the previous line for CRLF endings, and because a trailing newline produces an empty final string. For "Hello\nWorld\r\n", text.split('\n') returns ['Hello', 'World\r', ''] (3 elements), so len() returns 3 instead of 2. It also entirely misses lines separated by bare \r or other Unicode line terminators, treating them as part of the same line.

return s.isdecimal()

Why it fails: str.isdecimal() returns True only when every character is a decimal digit (such as 0-9 and other Unicode decimal digits like Arabic-Indic). It excludes superscript digits, so '²'.isdecimal() is False even though '²' is a digit, making this check too narrow for the stated requirement.

return s.isnumeric()

Why it fails: str.isnumeric() is broader than isdigit(): it returns True for any character with the Unicode Numeric_Type property, including fractions, Roman numerals, and superscripts. For example, '½'.isnumeric() is True, but '½' is not a digit, so this method would accept strings that are not composed purely of digits.

return s.isalnum() and not s.isalpha()

Why it fails: The condition isalnum() and not isalpha() is true for strings that contain at least one digit and no punctuation, but it also allows letters to appear. For instance, 'a1'.isalnum() is True and 'a1'.isalpha() is False, so it would pass 'a1' even though the function should reject any string containing non-digit characters.