Strings

2.1 Core concepts

• What is a string? A string is a sequence of one or more UNICODE characters — letters, digits, whitespace, or any other symbol. It can be created by enclosing characters in single ('...'), double ("..."), or triple quotes ("""...""" or '''...'''). Triple-quoted strings can span multiple lines. (NCERT §8.2, p. 175)
• Accessing characters — indexing: Each character is accessed via its integer index written in square brackets. Positive indices start at 0 (first character) and go up to n-1 (last character). Negative indices start at -1 (last character) and go down to -n (first character). Using an out-of-range index raises an IndexError; using a non-integer index raises a TypeError. (NCERT §8.2.1, p. 176)
• Positive and negative index table: For str1 = 'Hello World!' (length 12), positive indices are 0–11 and negative indices are -12 to -1. str1[0] = 'H', str1[-1] = '!', str1[-12] = 'H'. (NCERT §8.2.1, Table 8.1, p. 177)
• len() function: The built-in function len() returns the number of characters in a string. For str1 = 'Hello World!', len(str1) returns 12. str1[n-1] gives the last character, str1[-n] gives the first character. (NCERT §8.2.1, p. 177)
• String immutability: Strings are immutable — their contents cannot be changed after creation. Attempting str1[1] = 'a' raises TypeError: 'str' object does not support item assignment. (NCERT §8.2.2, p. 177)
• Concatenation (+): Two strings can be joined using the + operator. 'Hello' + 'World!' produces 'HelloWorld!'. The original strings remain unchanged after the operation. (NCERT §8.3.1, p. 178)
• Repetition (*): A string can be repeated using the * operator with an integer. 'Hello' * 2 produces 'HelloHello'. The original string remains unchanged. (NCERT §8.3.2, p. 178)
• Membership (in, not in): The in operator returns True if the first string appears as a substring in the second string, otherwise False. 'not in' does the reverse. Example: 'W' in 'Hello World!' → True; 'My' in 'Hello World!' → False. (NCERT §8.3.3, p. 178)
• Slicing (str1[n:m]): Slicing extracts a substring from index n (inclusive) to m (exclusive). The number of characters in the result always equals m-n. If the first index is omitted, slicing starts from 0; if the second is omitted, slicing goes to the end. A too-large second index is silently truncated to the string's length. If the first index is greater than the second, an empty string is returned. (NCERT §8.3.4, p. 179)
• Slicing with step (str1[n:m:k]): A third index specifies step size — every k-th character is extracted. Default step is 1. str1[0:10:2] on 'Hello World!' gives 'HloWr'. Using str1[::-1] reverses the string. (NCERT §8.3.4, p. 179–180)
• Traversal using for loop: A for loop iterates over each character automatically from the first to the last. (NCERT §8.4, p. 180)
• Traversal using while loop: A while loop with an integer index variable runs while index < len(str), incrementing the index each iteration. (NCERT §8.4, p. 180)
• Built-in string methods (Table 8.2): Python provides a rich set of methods. Key ones: len(), title(), lower(), upper(), count(str, start, end), find(str, start, end), index(str, start, end), endswith(), startswith(), isalnum(), islower(), isupper(), isspace(), istitle(), lstrip(), rstrip(), strip(), replace(oldstr, newstr), join(), partition(), split(). (NCERT §8.5, Table 8.2, pp. 180–184)
• find() vs index(): Both return the position of the first occurrence of a substring. The difference: find() returns -1 if the substring is not found, while index() raises a ValueError. (NCERT §8.5, Table 8.2, p. 181)
• partition(): Splits the string at the first occurrence of the separator into a 3-tuple: (before separator, separator, after separator). If separator is not found, returns (whole string, '', ''). (NCERT §8.5, Table 8.2, p. 184)
• split(): Returns a list of words delimited by the specified substring. If no delimiter is given, words are separated by spaces. (NCERT §8.5, Table 8.2, p. 184)
• join(): Returns a string in which all characters of a given string have been joined by a separator. Example: '-'.join('HelloWorld!') → 'H-e-l-l-o-W-o-r-l-d-!'. (NCERT §8.5, Table 8.2, p. 183)
• Handling Strings — user-defined programs (§8.6): Five programs demonstrate applying the above concepts: (1) count character occurrences, (2) replace vowels with *, (3) print string in reverse using negative indexing in a for loop, (4) reverse string into a new variable using a user-defined function, (5) palindrome check using a while loop comparing characters from both ends. (NCERT §8.6, pp. 184–186)
• UNICODE underlies all Python strings (NCERT §8.2, p. 175). Python 3 strings store sequences of Unicode code points; this is why Hindi, Bengali or emoji characters all behave identically with the same indexing and slicing rules. Each code point is counted as a single character regardless of the underlying UTF-8 byte length.
• Concatenation and repetition are O(n) operations. The + operator on strings returns a new string by copying both operands; the * operator copies the source n times. For very large strings, repeated concatenation in loops becomes inefficient — ''.join(...) is the idiomatic alternative.
• endswith(), startswith() and case-checking methods (NCERT Table 8.2, pp. 181-182). s.startswith(prefix) returns True if s begins with prefix; s.endswith(suffix) returns True if s ends with suffix. isalnum() returns True if all characters are alphanumeric; islower() / isupper() / istitle() test casing patterns; isspace() checks pure whitespace.
• title() capitalises each word (NCERT Table 8.2, p. 180). "hello world".title() → "Hello World". NTA often pits title() against capitalize() (which is not in NCERT scope); stick to the textbook list.
• Comparison of strings (NCERT §5.8.2, cross-ref). Strings are compared lexicographically using Unicode code points; 'apple' < 'banana' is True because 'a' < 'b'. CUET sometimes mixes a string-comparison MCQ into the strings unit.
• isspace() and whitespace-only strings (NCERT Table 8.2, p. 182). ' '.isspace() is True; ''.isspace() is False because the empty string has no characters at all. Beware the empty-string edge case.
• Negative indices walk from the end (NCERT §8.2.1, p. 176). For s = "Python", s[-1] = 'n', s[-2] = 'o', s[-6] = 'P'. Going below -len(s) raises IndexError.
• Strings can be used as iterables (NCERT §8.4, p. 180). for ch in s: traverses character-by-character, which underlies the palindrome and frequency-count programs.
• String repetition with zero or negative count (NCERT §8.3.2, p. 178). "ab" * 0 returns ""; "ab" * -1 also returns "" — Python clamps non-positive multipliers to 0.
• replace() returns a NEW string (NCERT Table 8.2, p. 183). Since strings are immutable, s.replace(old, new) does not modify s — you must reassign: s = s.replace(old, new).
• Implicit concatenation of adjacent string literals (Python feature, not stressed by NCERT). Avoid relying on "foo" "bar" style — use explicit + for clarity. NTA does not test this directly but exam discipline matters.

2.2 Definitions to memorise

2.3 Diagrams / processes to remember

• Table 8.1 — Indexing of characters in string 'Hello World!': A two-row table showing positive indices 0–11 and negative indices -12 to -1 mapped to each character. Must-memorise layout for output-based questions. (NCERT p. 177)
• Table 8.2 — Built-in functions for string manipulations: A multi-row table listing method name, description, and example for all major string methods. Covers len, title, lower, upper, count, find, index, endswith, startswith, isalnum, islower, isupper, isspace, istitle, lstrip, rstrip, strip, replace, join, partition, split. (NCERT pp. 180–184)
• Program 8-5 — Palindrome check logic: Uses two pointers i = 0 and j = len(st) - 1, a while(i <= j) loop, compares st[i] with st[j], returns False on first mismatch, returns True after loop ends. (NCERT p. 186)
• Reverse string using slice: str1[::-1] reverses the string in one expression — a common NTA output question. (NCERT §8.3.4, p. 180)

2.4 Common confusions / NTA trap points

• Slicing end index is exclusive: str1[1:5] on 'Hello World!' gives 'ello' (indices 1, 2, 3, 4 — NOT 5). Students often include the end index character. NTA frequently asks the output of a slice like str1[0:5] expecting students to count correctly.
• find() returns -1 vs index() raises ValueError: A favourite NTA trap — students mix up which returns -1 on failure. find('Hee') on 'Hello World!' returns -1; index('Hee') raises ValueError: substring not found.
• islower() with non-alphabet characters: islower() returns True even if the string contains digits or special symbols, as long as there is at least one lowercase alphabet and no uppercase alphabets. 'hello 1234'.islower() → True. Students incorrectly assume digits make it return False.
• Immutability confusion: Students assume str1 * 2 or str1 + str2 modifies str1. The NCERT explicitly states the original string remains the same after concatenation and repetition operations.
• Negative step reversal (NCERT §8.3.4, p. 180). str1[::-1] is a common output question. Students confuse the empty start/end with index 0 when step is negative — with step -1 and no bounds, Python starts from the last character and goes to the first.
• 'in' checks substring, not character (NCERT §8.3.3, p. 178). 'Hello' in 'Hello World!' is True; it checks substring containment for strings. NTA distractor may claim in only works on single characters.
• upper() does NOT mutate (NCERT §8.5). s.upper() returns a new string; s remains unchanged because strings are immutable. NTA trap: assumes in-place mutation.
• count() is non-overlapping (NCERT Table 8.2, p. 181). 'aaaa'.count('aa') = 2, not 3 — Python finds non-overlapping occurrences.
• Triple-quoted strings allow newlines (NCERT §8.2, p. 175). They preserve internal line breaks, unlike single/double-quoted strings.
• Slicing never raises IndexError (NCERT §8.3.4, p. 179). Out-of-range slice indices are silently truncated. s[0:1000] works even if len(s) is 5.
• split() with no argument splits on any whitespace (NCERT Table 8.2, p. 184). Multiple spaces/tabs/newlines are collapsed; "a b".split() returns ['a','b'] not ['a','','b'].