CCNA Strings Questions

The `replace()` method returns a new string with all occurrences of a substring replaced by another substring, without altering the original string. Similarly, `strip()` returns a new string with leading and trailing whitespace (or specified characters) removed, leaving the original unchanged. Both methods are non-mutating because strings in Python are immutable.

The find() method returns the lowest index where the substring 'l' is found. In 'Hello', the first 'l' is at index 2 (0-based).

Slicing with [0:6], [:], and [0:6:1] all return the entire string 'Python'. [:-1] returns 'Pytho', and [::2] returns 'Pto'.

Tuple (B) is immutable because once created, its elements cannot be added, removed, or changed. This is enforced by Python's internal structure: tuples are stored as a fixed-length array of PyObject pointers, and any attempt to modify them raises a TypeError.

Option A is correct because s[0:-4] uses negative indexing to slice from index 0 up to (but not including) index -4, which corresponds to the character 'o' (the fifth character from the end). Since 'Python' has length 6, index -4 is the character at position 2 (0-based), so the slice returns characters at indices 0 and 1, which are 'P' and 'y', yielding 'Py'.

Option A is correct because \n is a standard escape sequence in Python that represents a newline character (ASCII LF, 0x0A). It is defined in the Python language specification and is commonly used to insert line breaks in string literals.

A is correct because `.capitalize()` is a built-in string method in Python that returns a copy of the string with its first character capitalized and the rest lowercased. It is part of the standard string methods documented in Python's official library reference.

In Python, string slicing uses the syntax `string[start:stop]`, where `start` is inclusive and `stop` is exclusive. For `'Hello'[1:3]`, the indices are: index 1 = 'e', index 2 = 'l', and index 3 is not included, so the slice returns 'el'. This is a fundamental string slicing behavior defined in Python's sequence protocol.

Option D is correct because calling `'abc'.index('d')` raises a `ValueError` when the substring is not found. The `str.index()` method in Python is designed to raise this exception for missing substrings, unlike `str.find()` and `str.rfind()`, which return -1.

Triple-quoted strings (options B and E) allow literal newlines in the source code. Options A and D use escape sequences but are single-line in source. Option C is concatenation on one line.

Python variable scopes (LEGB rule).

Option D is correct because string slicing with the syntax `[start:stop:step]` (e.g., `[::]`) is a built-in operation for strings in Python, allowing extraction of substrings. Option E is correct because the `+` operator performs string concatenation, creating a new string by joining two strings together.

The `endswith()` method is specifically designed to check if a string ends with a given suffix, returning a boolean value. This is the correct and most direct approach for the task described, as it avoids manual slicing or comparison.

Strings are immutable in Python, so slicing returns a new string. The step -1 reverses the sequence. The function works for any string, including empty strings.

Option B is correct because `str.split('.')[-1]` splits the string at each dot and returns the last element, which is the file extension. This method works reliably for simple cases like 'report.pdf' and is a common Python idiom for extracting extensions.

Option C is correct because it uses a non-capturing group `(?:...)` to repeat the pattern `[0-9]{1,3}\.` exactly three times, followed by a final octet `[0-9]{1,3}`. This matches the dotted-decimal structure of an IPv4 address (four octets, each 1–3 digits, separated by dots) without introducing extra spaces or overly permissive digit counts, and it avoids capturing unnecessary groups.

Option B is correct because \t is the standard escape sequence for a horizontal tab character in Python strings. Escape sequences in Python begin with a backslash followed by a specific character, and \t is defined in the Python language specification (similar to C) to represent the ASCII tab character (0x09).

Using join() on a list of strings is efficient because it allocates the final string once. Using StringIO from the io module builds a mutable buffer, also efficient. The += and + operators create a new string object for each concatenation, leading to O(n^2) time. % formatting also creates a new string each iteration.

Due to string interning in CPython, string literals may be the same object. Thus a is b returns True. Option B is incorrect because interning often caches small strings.

Installing a package with pip involves opening terminal, checking pip, using install command, optionally specifying version, and verifying.

Option D is correct because strings in Python are immutable objects, meaning once a string is created, its contents cannot be changed. However, the variable referencing the string can be reassigned to point to a new string object. This distinction between mutability of the object and reassignment of the variable is fundamental to Python's data model.

Both strip() (removes both ends) and lstrip() (removes only leading) remove leading whitespace. rstrip() removes trailing. split() and chomp() are not correct.

Option B is correct because Python's slice notation `[::-1]` creates a reversed copy of the string by stepping through the sequence from end to start with a step of -1. Strings are immutable, so this returns a new string object with the characters in reverse order, exactly converting 'stressed' to 'desserts'.

Old-style formatting with % and the .format() method are both valid and widely used. Option C uses $s which is invalid, D would raise KeyError, and E assumes a variable that may not be defined.