CCNA Strings Questions

Correctly counts overlapping? No, count does not count overlapping, but 'is' appears at positions 5 and 17, not overlapping, so returns 2.

This is correct because Python implicitly concatenates adjacent string literals at compile time. The expression ('Line1\n' 'Line2') produces the single string 'Line1\nLine2', where \n is a single escape character representing a line break. When printed, the result appears on two lines, so it is a valid multiline string. The parentheses are not required but help break long lines for readability.

This is the correct result after executing both operations in sequence: first, replace("Hello", "Hi") changes the string to "Hi, World!"; second, upper() converts every alphabetic character to uppercase, producing "HI, WORLD!". The order of the chain matters—the replacement happens before case conversion, so the greeting becomes "HI" instead of "HELLO", matching the exhibited output exactly.

This is correct because it explicitly tests each character against the exact set of valid hexadecimal digits, '0123456789abcdefABCDEF', using the all() function with a generator expression. Every character in s must be a member of that set for the expression to evaluate to True. One subtlety is that all() returns True for an empty string, so if an empty input should be considered invalid, an additional length check is needed.

The str.center(width, fillchar) method returns a new string of length width, with the original string centered and padded with the specified fill character. For 'Alice' and width 20, the total padding is 15 characters. Python puts the extra padding on the right when the padding is odd, resulting in 7 asterisks on the left and 8 on the right, exactly as required.

s[1::2] begins at index 1 (the first digit character '1') and then takes every second character thereafter, with no explicit stop so it runs to the end of the string. Indices 1, 3, and 5 correspond to '1', '2', and '3', respectively, so the result is exactly '123'. This is the correct expression because it isolates the digits that are positioned at odd indices.

lstrip() returns a copy with leading whitespace characters removed, leaving trailing and internal whitespace untouched. This matches the stem's constraint precisely, since only leading spaces, tabs and newlines must be stripped, and lstrip() is a built-in string method requiring no import.

s.strip() correctly removes whitespace from both the beginning and the end of the string. For example, ' hello '.strip() returns 'hello', eliminating the leading and trailing spaces. Because it precisely matches the requirement, and because strings are immutable, it returns a new stripped string rather than modifying the original.

Correct. The format specifier `.2f` is a dot (precision marker) followed by `2` (the number of digits) and the fixed-point type `f`. This tells Python to render `value` as a float rounded to exactly two decimal places, so 3.14159 becomes `3.14`. This is the official way to force a fixed number of digits after the decimal point in f-string formatting.

startswith() is the correct and idiomatic Python string method for checking whether a string begins with a given prefix. It accepts a single string, a tuple of strings, or optional start and end indices, returning True if the string starts with the specified prefix and False otherwise. Its behavior is case-sensitive, and it is implemented in C for efficiency, making it the standard tool for this common validation task. This is the only method among the options that actually exists and performs the required check.

startswith() is a boolean predicate that returns True exactly when the string's prefix matches the supplied prefix, optionally constraining the check with the start and end index arguments. It never modifies the original string and its only meaningful return values are True and False, making it one of the two methods that answer the question correctly.

The correct implementation first trims surrounding whitespace with s.strip(), then removes any leading/trailing punctuation characters via s.strip('.,!?;:') — a subtle but important order, because punctuation attached after spaces (e.g., " hello! ") is only exposed for removal after the outer whitespace is gone. Lowercasing follows, and finally re.sub(r'\s+', ' ', s) collapses any runs of internal whitespace (tabs, newlines, multiple spaces) into a single space. This sequence yields a fully canonical form: " Hello, World!! " becomes "hello, world". It deliberately handles each normalization dimension independently, making the result predictable for exact-match comparisons.

s.split(',') is correct because str.split() with a specified separator splits the string at every occurrence of that separator and returns a list of the substrings in between, with the separator removed. For the string 'apple,banana,orange', this yields ['apple', 'banana', 'orange'], exactly the three separate fruits the programmer wants. This is the standard built-in method for turning a delimited string into a list of parts.

This is the correct slice. Python's slice s[start:stop] includes characters from start up to, but not including, stop; therefore s[7:18] returns the characters at indices 7 through 17, which spell exactly 'programming'. The start index 7 points to the first letter 'p', and the exclusive stop index 18 excludes the space that immediately follows the word, ensuring a precise extraction.

This invokes re.sub with the pattern [0-9], a character class that matches exactly one character from the range '0' through '9'. Each matched digit is replaced independently with 'X', so the entire message is scanned and every digit becomes an X. Because re.sub processes the whole string and replaces all non-overlapping matches, this correctly sanitizes all ASCII digits in the message.

Calling lower() on the string 'aBc' returns a new string where every cased character has been converted to its lowercase form: the leading 'a' is already lowercase and stays 'a', while the uppercase 'B' becomes 'b'. The result is therefore exactly 'abc' — a three-character string with no uppercase letters remaining. This is the documented behavior of str.lower() in Python.

The negative lookbehind (?<!big) is a zero-width assertion that succeeds only when the characters immediately before the current position are not 'big'; if they are, the match attempt at that location fails. As a result, every 'cat' that is not part of 'bigcat' is replaced with 'dog', while 'bigcat' stays exactly as is. This correctly replaces all occurrences of 'cat' except those preceded by 'big'.

The expression 'hello'.count('l') correctly returns 2, the total number of non-overlapping occurrences of the character 'l' in the string. Python's str.count() method counts each match from left to right, and since 'hello' consists of 'h', 'e', 'l', 'l', 'o', it finds an 'l' at position 2 and another at position 3 (0-based). Therefore, the output is exactly 2.

The statement s[0] = 'J' raises a TypeError because assignment to an indexed position attempts to modify the contents of an existing str object, and immutable objects do not support item assignment. The interpreter explicitly forbids this operation, which is the most direct and unambiguous demonstration of string immutability.

Indexing 'python' from zero gives p=0, y=1, t=2, h=3, o=4, n=5; the two-character substring 'th' begins at offset 2, where 't' resides and is followed immediately by 'h'. Python's str.find returns the lowest zero-based index at which the substring starts, so 'python'.find('th') evaluates to exactly 2. This is the correct result.

strip() removes all leading and trailing whitespace characters — such as spaces, tabs, and newlines — and returns a new string with those characters removed. For "hello world", there are no surrounding whitespace characters, so it returns the exact same string unchanged. It leaves any internal whitespace intact, which is the desired behavior for trimming a string. This method is the standard and correct way to clean up whitespace at both ends of a string.

Returns True or False.

The f-string (formatted string literal) is the recommended formatting method in Python 3.6+ because it allows expressions to be embedded directly inside braces exactly where the value belongs in the text. It is concise, readable, and evaluated at runtime, so it can call functions, index collections, or access attributes without extra method calls. PEP 498 and the official Python documentation endorse f-strings as the preferred form for new code.

str.translate() with a translation table is correct because it replaces every character in a single C-level pass: each character's code point is looked up in the table and replaced with the designated string, or deleted if mapped to None, without constructing intermediate copies. The translation table is created once via str.maketrans() and reused for every line or chunk, so the total work is proportional to the file size rather than to the number of distinct replacements. This makes it the fastest built-in approach for bulk character-level substitutions in large text.

Strings in Python are immutable, so indexed assignment raises TypeError: 'str' object does not support item assignment. The statement s[0] = 'x' attempts in-place mutation of an existing str object, which the type forbids; the interpreter rejects it at runtime rather than silently creating a new string.

The literal 'Hello' is a standard single-quoted string, which is a perfectly valid way to create a string in Python. It uses a matching pair of single quote characters as delimiters, enclosing the sequence of characters exactly as written. Functionally, single-quoted strings are equivalent to double-quoted strings, though consistency in quoting style is a common best practice.

In Python, the * operator, when applied to a string and an integer, performs sequence repetition. Because 3 is an int, 'Hello' * 3 creates a new string by joining three sequential copies of the original 'Hello', yielding exactly 'HelloHelloHello'. This is valid string repetition that works for any string and any non-negative integer, and it returns a single string object, not a tuple or list.

Python supports negative indices that count from the end of a sequence. An index of -1 specifically refers to the last element, so s[-1] evaluates to the final character of s, regardless of the string's length. Internally, Python converts negative indices by adding len(s), yielding len(s)-1, which is always the final valid position.

Single quote escape.

startswith() is the correct and documented Python string method for prefix detection. It returns True if the string begins with the specified prefix and False otherwise. It also accepts a tuple of prefixes to check multiple alternatives, and optional start and end parameters to limit the search range within the string.

zfill(5) pads the string '123' with ASCII zero characters on the left until the total length reaches the specified width. Because '123' has length 3 and the target width is 5, exactly 2 zeros must be prepended, yielding '00123'. This is the documented behavior and the only correct result.

Because data was read as raw bytes from the IoT sensor, decode('utf-8') is the correct method to interpret those bytes as a Unicode string using the UTF-8 codec. This is the inverse of str.encode() and is exactly what bytes objects are designed to do. After decoding, the result is a normal str that can be compared, parsed, or logged as text.

With s = 'Python Programming', index 7 points to the uppercase 'P' that begins the second word, 'Programming'. A slice of s[7:] has no explicit stop index, so Python extends it to the string's full length, outputting every character from that 'P' through the final 'g'. The result is exactly 'Programming', the complete suffix of the original string.

The statement attempts to access an element using an index that is equal to or greater than the list's length, or a negative index less than -len(list). Python raises IndexError for any out-of-range sequence access, and the active except IndexError block catches this exact exception, printing the string 'Index out of range'. Since the handler successfully intercepts the exception, the program continues normally after the except block, making this the emitted output.

The string `C:\Users\John\Documents` (written as a raw string) contains 23 characters: `C`, `:`, `\`, `U`, `s`, `e`, `r`, `s`, `\`, `J`, `o`, `h`, `n`, `\`, `D`, `o`, `c`, `u`, `m`, `e`, `n`, `t`, `s`. Because it is a raw string, each backslash is its own character and none of the letters are escaped, so `len()` on this literal returns exactly 23.

input_str.istitle() returns True exactly when the string is titlecased: each word boundary is followed by an uppercase letter, and all remaining letters in that word are lowercase. For a value like 'Hello World', both words start with an uppercase letter and the rest are lowercase, so the method returns True. This is the precise built-in predicate for checking titlecase, ignoring spaces and punctuation when identifying words.

With s = 'abcdefgh', the slice s[7:3:-2] starts at index 7 (character 'h'), then subtracts 2 to reach index 5 (character 'f'), and stops before index 3 (character 'd') because the stop is exclusive. The step of -2 reverses the traversal direction and skips every other character. Hence the result is exactly 'hf'—first 'h', then 'f'.

This is the correct conversion: bytes.decode('utf-8') interprets the two-byte sequence 0xC3 0xA9 as the UTF-8 encoding of the Unicode code point U+00E9, which is the character 'é'. The decode() method is specifically designed to turn bytes back into a str using a specified codec, making this the exact inverse of 'é'.encode('utf-8'). The result is the Python string 'é'.

splitlines() splits a string at Unicode line boundaries such as \n, \r\n, \r, \v, \f, and other line separator characters, returning a list of lines without the line terminators unless keepends=True is passed. It does not accept a separator argument and does not split on spaces or tabs, making it ideal for line-oriented data like file contents or multi-line text.

Using the format specifier {:,} or the equivalent f-string f"{1234567:,}" applies the comma format, which groups digits by thousands from right to left. The integer 1,234,567 is correctly grouped into the three-digit blocks 1, 234, and 567. Python's format mini-language explicitly adds thousands separators when the comma flag is present, so this is the definitive result of formatting the number as described.

capitalize() is a valid string method that creates and returns a new string with the first character converted to uppercase and all remaining characters converted to lowercase. Because strings are immutable, the original string is not modified, and the method call produces a copy. If the first character is not a letter (e.g., a digit or symbol), it remains unchanged while the rest of the string is lowercased.

`rsplit('.', 1)` splits from the right, limiting to one split, so only the final dot separates the extension; indexing `[-1]` returns the trailing segment `'pdf'`. This satisfies the stem's requirement to isolate the extension from `'document.pdf'`, and unlike `split`, it handles filenames containing multiple dots correctly.

The expression slices the string literal '12345' with a stop index that exceeds the string's length. Python's slice operation clamps out-of-range boundaries to the sequence's actual length, so it returns every character from index 0 through index 4. Thus the result is exactly the original five-character string '12345', with no error and no added whitespace.

This is exactly the output of the slice `'Python'[::-1]`, which steps through the string from the last character to the first with a step of -1. Python's slicing mechanism creates a new string by copying the characters in reverse order while preserving each character's case and position relative to the others. Because the original string begins with an uppercase 'P', that 'P' appears at the final index, yielding 'nohtyP'.

Python's `in` operator for strings performs a substring containment test, checking whether the left operand appears as a contiguous sequence within the right operand. In 'abc', the two-character sequence 'ab' is present at indices 0 and 1, so the expression evaluates to True. This is exact, character-by-character matching with no wildcard or fuzzy semantics.

str.isdigit() returns True only when the string is non-empty and every character has the Unicode Numeric_Type of Digit or Decimal, which includes ASCII '0'-'9', non-Arabic decimal digits, and compatibility superscripts such as '²'. This is the broadest check that still excludes letters, punctuation, and numeric fractions, so it is the correct method when the requirement is to verify that a string contains only digits.

This is the exact string returned by the join() operation: a single string containing the characters 'a', a space, 'b', another space, and 'c'. In an interactive Python session or when using repr(), the result is shown with single quotes around it to clearly delimit it as a textual string object. The single quotes are part of the representation, not the actual data, and they confirm the value is a str, not a list or other container.

This is the correct output: r'\s+' matches one or more whitespace characters as a single delimiter, so the spaces before and after words are consumed. With the input 'one two three', each word is separated by exactly one space, and there is no leading/trailing whitespace, yielding exactly three substrings. The regex engine advances past all matching whitespace, so no empty strings appear.

The positive lookahead (?=AA) matches the zero-width position where the substring 'AA' begins, without consuming any characters, so the regex engine can find overlapping occurrences at every starting index. re.findall returns one empty-string match for each such position, so len() gives the exact count of overlapping occurrences. This is efficient because the regex engine scans the string once in O(n) time for a literal pattern, with no substring copying or manual index stepping. It is the cleanest solution when overlapping matches must be counted.

This is the exact third line of the pretty-printed JSON output when `indent=2` is used. The line begins with two spaces (the indentation for properties at the top level), then the key `"age"`, a colon and a space, and the value `30`, followed by a trailing comma. That comma is required because the `"city"` property still follows; this line matches the code's actual output verbatim.

The replace() method takes two substrings and returns a brand-new string in which all non-overlapping occurrences of the first substring have been replaced with the second. Since strings are immutable, the original string is untouched; instead, the method constructs a new string and returns it. This precisely matches the condition of returning a new string.

Option 2 is correct: the string 'hello' has the character positions h(0), e(1), l(2), l(3), and o(4). When str.index('l') is called, Python scans the string left-to-right and returns the smallest index where the substring 'l' occurs, which is 2. Therefore the code prints the integer 2.

The expression `"Python"[:]` is a full slice: both the start and stop indices are omitted, and the step defaults to 1. With these defaults, Python interprets the slice as starting at index 0 and stopping at the length of the sequence, thereby including every character in order. This idiom is commonly used to create a copy of a sequence; here it returns a new string object containing exactly the same characters as the original: `'Python'`.

Tuples are immutable sequences; once created, their contents cannot be changed, added, or removed. Although tuples can contain mutable objects (like a list), the tuple's own structure and element references are fixed, making it hashable only if all elements are hashable. This immutability allows tuples to serve as dictionary keys when they contain only immutable elements.

str.lower() returns a new string with all characters lowercased; the original string remains unchanged.

In Python string literals, the backslash introduces an escape sequence, and \n specifically represents the line feed character (ASCII 10), which advances the cursor to the next line. This is one of the most commonly used escapes for creating multiline output or separating lines in text. Although written as two characters in source code, \n is stored as a single character in the resulting string, making it a single indexable element.

.capitalize() is a built-in string method that capitalizes the first character and lowercases the rest.

Python slicing uses a half-open interval: the start index is included, but the stop index is excluded. In 'hello', the indices are h=0, e=1, l=2, l=3, o=4, so slice [1:3] selects index 1 ('e') and index 2 ('l'), producing 'el'. The character at index 3 is not part of the result because the stop boundary is exclusive.

Here, str.index() is invoked with 'd', which does not occur in the string 'abc'. Unlike find/rfind, index is designed to raise ValueError when the substring is absent, treating that condition as an exceptional event. Because 'd' is missing, this expression raises ValueError, making it the correct answer.

Triple double quotes define a multiline string literal: the opening and closing delimiters may be on different physical lines, and any raw line breaks inside become part of the string. Including \n adds an explicit line break as well; this is one of the two accepted forms for multiline literals in Python.

Splitting the original string on '=' gives [' key ', ' value ']. The list comprehension then applies .strip() to each part, removing all leading and trailing whitespace from both the key and the value. This yields ['key', 'value'], exactly two elements with spaces around the equals sign removed, satisfying the requirement.

Slicing with [::] is a valid, non-mutating operation on strings because str implements the sequence protocol via __getitem__, accepting a slice object. For example, s[::-1] creates a reversed copy of the string, while s[1:4] extracts a substring; in every case the result is always a brand-new string and the original is left unchanged. This works regardless of the immutability of strings because it reads data rather than trying to modify it.

The `endswith()` method is the dedicated predicate for suffix testing: it returns `True` only when the final characters of the string exactly match the given suffix, and `False` otherwise. It also accepts optional `start`/`end` slice arguments, which allow you to check only a portion of the string, and it performs a case-sensitive comparison by default (use `casefold()` or lowercasing for case-insensitive checks). Because it returns a boolean directly, it cleanly satisfies the developer's requirement to verify whether the string ends with a specific substring.

The specifier `:10.2f` is the correct choice: `10` sets a minimum field width of 10 characters, `.2` requires exactly two digits after the decimal point, and `f` selects fixed-point notation with no exponent. When applied to `1234567`, it produces `1234567.00`, which is exactly 10 characters (7 integer digits, the decimal point, and 2 fractional digits) and satisfies the width and precision requirements. If the integer part were shorter, leading spaces would pad the output to the specified width.

In Python, strings are immutable sequences, so slicing with s[::-1] does not alter the original object; it constructs a completely new string with the characters in reverse order. The original variable s still references the unchanged string, and the newly created string can be assigned to another name or used directly. This is the canonical way to reverse a string, and it correctly returns a new value rather than mutating existing data.

Strings in Python are immutable sequences; the assignment `s[0] = 'H'' attempts to mutate the object at index 0, which violates the immutable contract of the `str` type. The interpreter raises a `TypeError` specifically because `str` objects lack a `__setitem__` method, preventing item assignment. This directly satisfies the constraint that strings cannot be modified in-place in Python.

str.split('.')[-1] is the correct idiom because it divides the entire string on every dot and then uses -1 to select the final element, which is exactly the substring after the last period. This handles file names with multiple dots, returning the last component as the extension. One caveat is that if no dot exists, the whole original string is returned, but for typical extension extraction this is acceptable and widely used.

The sequence \t is a valid escape sequence that represents the tab character (ASCII 9, horizontal tab). It is commonly used to insert whitespace alignment in text output, for example in printing columns or formatting tables. Python recognizes \t as a single character with the ordinal value 9, not as two separate characters backslash and 't'.

Using the join() method on a list: This is the canonical efficient technique. You collect all the pieces into a list, then call separator.join(list) once. The join() implementation precomputes the exact total length of the result, allocates a single buffer, and copies each piece into it in one straight pass, producing no intermediate strings. That makes it O(n) in both time and memory and is the fastest pure-Python way to assemble many separate string fragments.

True is correct because in CPython, string literals are automatically interned, meaning that two identical string literals are stored in the same memory location. When the code compares them with the identity operator 'is', it compares object memory addresses, and since both variables point to the same interned object, the result is True. This is a well-known CPython behavior, though it is an implementation detail rather than part of the Python language specification. The exact code likely creates two variables with the same string literal, and interning makes their identities match.

This is the correct distinction: the str object itself is immutable, so once a string is created its contents cannot be altered, added to, or removed. However, a variable that references a string can be assigned a new value, such as s = 'new', which makes the variable point to a different string object. This separation between object identity and variable binding is fundamental to Python's data model and explains why strings can appear to 'change' when they actually are being replaced.

Calling s.strip() returns a new string with all leading and trailing whitespace removed, so leading whitespace is indeed eliminated as part of the process. This makes it a valid choice for the task, even though it also strips the right end. By default, strip() removes spaces, tabs, and newline characters; an optional chars argument can narrow the set.

Using extended slice syntax with a step of `-1` creates a reversed copy of the entire string: `s[::-1]` means start at the end, go to the beginning, and step backward by one. This is the most idiomatic and concise way to reverse a string in Python, and it is often preferred for its readability and speed. Since strings are immutable, this operation allocates a new string object containing the characters in reverse order, leaving the original string unchanged.