Strings

Written and reviewed by Rohit Singh, Computer Science & Commerce faculty at UniDrill (MCA, Osmania University · 6 years teaching). Based on NCERT Computer Science Class XI, Chapter 8.

Why can't you fix one wrong letter in a string?

You type Hello and realise you wanted Jello. In a word processor you would just replace the first letter. In Python, s[0] = 'J' fails with an error. That single surprise explains half of this chapter: a string is a sequence you can read letter by letter, but never edit in place. Everything else here (slicing, methods, building new strings in loops) is a consequence of that one rule.

What is a string?

A string is a sequence of one or more Unicode characters. A character can be a letter, a digit, a space or any symbol. You create a string by enclosing characters in single, double or triple quotes. Triple quotes let the string run over several lines. Python has no separate character type: a string of length one is simply a character.

All of str1 and str2 hold the same value. Only the triple quoted str3 spreads across two lines.

Indexing: every character has two addresses

Each character has a position called its index. From the left, the first character has index 0 and the last has index $n - 1$, where $n$ is the length. From the right, the last character is $-1$ and the first is $-n$. For 'Hello World!' (length 12, the space counts):

The built in len(str1) gives 12. So str1[0] is 'H', str1[6] is 'W', str1[-1] is '!', and str1[len(str1) - 1] is also '!'. The index can be any expression that evaluates to an integer, so str1[2 + 4] is 'W'.

A string is immutable

Immutable means the contents cannot change after the string is created. Trying str1[1] = 'a' raises TypeError: 'str' object does not support item assignment. If you need a changed version, you build a new string and give it a name.

Worked example: turn 'Hello' into 'Jello'.

Operations on strings

Python allows four operations on strings: concatenation, repetition, membership and slicing. None of them changes the original string.

Two details cause marks to be lost. First, + needs strings on both sides: 'a' + 1 raises a TypeError, so convert first with str(1). Second, in checks for a substring (a run of characters in the same order), not just a single character. So 'Wor' in 'Hello World!' is True, but 'Wrd' in 'Hello World!' is False, because those letters are not side by side.

Slicing: str1[n:m:k]

The slice str1[n:m] returns the characters from index $n$ (included) up to index $m$ (excluded), so it has $m - n$ characters. A third number is the step: str1[n:m:k] takes every $k$-th character. Leaving a number out uses a sensible default: the start is the beginning, the stop is the end, and the step is 1. A negative step walks from right to left.

For str1 = 'Hello World!':

Unlike an index, a slice never raises an IndexError: out of range numbers are quietly trimmed.

Worked example: a longer slicing question. Let mySubject = "Computer Science" (16 characters, indices 0 to 15, the space is index 8).

A reliable method for any slice: write the indices out, cross out the excluded stop, and read the characters.

Pause and predict: s = 'PYTHON'. What are s[1:4] and s[-1:-4:-1]?

Check your answer: s[1:4] takes indices 1, 2, 3, so it is 'YTH'. In s[-1:-4:-1] the step is negative, so it walks from index -1 (N) leftwards and stops before -4 (H): N, O, H. The answer is 'NOH'.

Traversing a string

To traverse a string means to visit each character. A for loop does it directly, and a while loop does it with an index that runs from 0 to len(str1) - 1.

Both loops print Hello World! (once each, so the text appears twice in a row). The for version stops by itself when the characters run out. The while version stops because the condition index < len(str1) becomes false. Writing <= instead of < would raise an IndexError on the last pass.

String methods and built in functions

A method is a function that belongs to an object, called with a dot: str1.upper(). The most important fact about string methods is this: they never change the string. They return a new string (or a number, or a list), which you must store or print.

Case and size

Searching and counting

Testing the content (each returns True or False)

Cleaning and restructuring

find or index? Both give the position of a substring. The difference is only what happens when it is missing: find returns -1 and the program carries on, while index raises a ValueError and stops. split or partition? split returns a list of any number of pieces, and partition returns a tuple of exactly three parts, cut at the first separator only.

Worked example: methods do not change the string. What does this program print?

Beyond the textbook. For the exam: max("Sincerity") is 'y' and min("Sincerity") is 'S', because strings are compared by character code and uppercase letters come before lowercase. In reality: the same rule decides every string comparison with < and >. Python compares two strings character by character using their Unicode code values, which you can see with ord('A'), which is 65, and ord('a'), which is 97. That is why 'Zebra' < 'apple' is True, even though Z comes late in the alphabet.

Beyond the textbook. For the exam: programs build a new string with newstr += ch inside a loop. In reality: because strings are immutable, each += makes a brand new string and copies the old one into it, which gets slow for very long text. Professional code collects the pieces in a list and joins them once at the end with ''.join(pieces). The result is the same, only faster.

Handling strings: four classic programs

The textbook turns string handling into user defined functions. Each one is a standard CUET question.

Worked example: count a character. charCount(ch, st) loops through st and adds 1 each time a character equals ch.

The string 'Today is a Holiday' has an a in Today, one alone, and one in Holiday. The count goes 0, 1, 2, 3, and the function returns 3.

Worked example: replace vowels with a star. For replaceVowel('Hello'), the function starts with an empty string newstr and examines each character.

The function returns 'H*ll*'. Notice that the original string is untouched, because the function built a new one.

Worked example: reverse a string with negative indices. The loop for i in range(-1, -len(st) - 1, -1) visits the indices -1, -2, ... down to -len(st), and adds each character to the new string. For 'abc' the length is 3, so the range is range(-1, -4, -1), giving -1, -2, -3.

The stop value is -len(st) - 1 and not -len(st), because the stop is excluded. Using -len(st) would leave out the first character. The one line st[::-1] gives the same result.

Worked example: palindrome check. A palindrome reads the same backwards. The function keeps two positions, i at the start and j at the end, compares the characters, and moves them towards each other. It returns False at the first mismatch and True if the pointers meet without one.

The common wrong step is to forget that comparison is case sensitive. For 'Madam' the first test is 'M' != 'm', so the function returns False even though the word is a palindrome in everyday terms. To ignore case, convert first with st.lower().

Pause and predict: why does the palindrome loop need only i <= j and not a pass for every character?

Check your answer: each pass checks two characters at once, one from each end, so only half the string needs to be examined. Once the pointers cross, every pair has already matched.

Exam traps

60-second revision

Where this chapter connects

• Previous: Functions explains the user defined functions, parameters and return values used in every string program here.
• Next: Lists reuses indexing, slicing and membership, but a list is mutable, which changes what you can do.
• Also related: Flow of Control provides the for, while and range() loops used to traverse strings, and Tuples and Dictionaries shows the tuple that partition() returns.