Strings: literals, indexing and slicing

Every name, message, file line and web page a program handles is text, and in Python text is a string, a value of type str. A string is a sequence: it holds characters in order, each at a numbered position, so you can pick out one character or a run of them. And once a string exists it never changes. Those two facts explain almost everything in this lesson.

Writing strings in your code

A string written directly in a program is a string literal. Put the text between single quotes or double quotes; both make exactly the same string, so choose whichever means less escaping:

# Single and double quotes make the same kind of string: the quotes are not part of the text.
print('chai' == "chai")

# Pick the quote that is not inside the text, or put a backslash before it.
print("It's ready")
print('She said "two cups"')
print('It\'s ready' == "It's ready")

# A backslash starts an escape sequence: \n is a newline, \t a tab, \\ one backslash.
menu = "tea\t20\ncoffee\t30"
print(menu)
print(repr(menu))
print(len("\n"), len("\\"))

# \u followed by four hex digits is a character by its Unicode number.
print("\u0905", "\u03c0")

# Triple quotes keep line breaks exactly as typed.
note = """Shop opens at 9.
Closed on Sundays."""
print(note)

# Literals written next to each other are joined into one string.
title = ("Namaste, "
         "world")
print(title)

True
It's ready
She said "two cups"
True
tea	20
coffee	30
'tea\t20\ncoffee\t30'
1 1
अ π
Shop opens at 9.
Closed on Sundays.
Namaste, world

What each part shows:

• 'chai' == "chai" is True: the quotes only mark where the text starts and ends.
• Text that contains one kind of quote is easiest to write with the other kind around it. Otherwise put a backslash in front of the quote, as in 'It\'s ready'.
• A backslash starts an escape sequence, a way to write a character that you cannot type directly or that would end the string: \n is a line break, \t a tab and \\ a single backslash. Each escape is one character, which is why len("\n") is 1.
• print() shows the text itself, with real line breaks and tabs. repr() shows the string the way you would write it in code, quotes and escapes included, which makes invisible characters visible. The interactive shell uses repr() when it echoes a value.
• \u followed by four hexadecimal digits is a character by its Unicode number: \u0905 is the Devanagari letter अ and \u03c0 is π. \N{GREEK SMALL LETTER PI} names the same character in words.
• Triple quotes (""" or ''') let a string run over several lines and keep the line breaks as typed. You will meet them again as docstrings, the descriptions at the top of functions.
• Two literals next to each other, with nothing but spaces between them (or line breaks, inside brackets), become one string. That is how the last part of the program splits a long text over two lines without a +.

Raw strings, and the Windows path mistake

Backslashes are where most string bugs start. A Windows path typed as an ordinary string silently changes:

# A Windows path typed as an ordinary string: \n and \t are escape sequences.
print("C:\new\table.csv")

# Two ways to keep every backslash: a raw string, or doubled backslashes.
print(r"C:\new\table.csv")
print("C:\\new\\table.csv")

# Forward slashes also work for paths on Windows, and need no escaping.
print("C:/new/table.csv")

C:
ew	able.csv
C:\new\table.csv
C:\new\table.csv
C:/new/table.csv

\n in C:\new became a line break and \t in \table a tab, so the first line prints a broken path and Python reports no error. A raw string, written with r before the opening quote, treats every backslash as a plain character. Doubling each backslash works too, and so do forward slashes, which Windows accepts in paths.

Raw strings are also the usual way to write regular expressions, which use backslashes a lot. A backslash followed by a letter that is not an escape, such as \d (a digit, in a regular expression), is kept as it is, but Python warns about it:

pattern = "\d+"
print(pattern, len(pattern))

fixed = r"\d+"
print(fixed, len(fixed), pattern == fixed)

\d+ 3
\d+ 3 True

regex_escape.py:1: SyntaxWarning: "\d" is an invalid escape sequence. Such sequences will not work in the future. Did you mean "\\d"? A raw string is also an option.
  pattern = "\d+"

The program still worked: both strings are a backslash, a d and a +. The warning, printed on standard error when the file is compiled, matters because the language reference says a future version will raise a SyntaxError instead, so write r"\d+" (or "\\d+") now.

A raw string has one limit: it cannot end with a single backslash, because that backslash still keeps the closing quote from ending the string:

folder = r"C:\Users\Asha\"
print(folder)

  File "raw_ending.py", line 1
    folder = r"C:\Users\Asha\"
             ^
SyntaxError: unterminated string literal (detected at line 1); perhaps you escaped the end quote?

Nothing runs, as with every syntax error, and the message (since Python 3.13) even guesses the cause. When a path must end with a separator, write "C:\\Users\\Asha\\" or "C:/Users/Asha/", or leave the separator off and add it later.

Picking out characters by position

Each character of a string has a position, its index, and word[i] gives the character at index i. Python counts from 0, so the first character is word[0]. Negative indexes count from the end: word[-1] is the last character and word[-2] the one before it.

There is no separate character type in Python: word[0] is itself a string, one character long. Asking for a position the string does not have stops the program:

word = "PLANET"
print(word[5])
print(word[6])

T

Traceback (most recent call last):
  File "past_the_end.py", line 3, in <module>
    print(word[6])
          ~~~~^^^
IndexError: string index out of range

"PLANET" has six characters, so its indexes run from 0 to 5 (or -6 to -1). Index 6 would be the seventh character. The last valid index is always len(word) - 1, and a loop or calculation that ends one step too far is one of the most common causes of an IndexError.

Slices: a run of characters

A slice takes several characters at once. word[start:stop] begins at index start and stops before index stop, so word[1:5] takes indexes 1, 2, 3 and 4. A third number, the step, says how far to move each time. This program prints each expression next to its value (the = inside the braces of an f-string does that; the f-strings lesson explains it):

word = "PLANET"

# One character: positions count from 0 at the left, or from -1 at the right.
print(f"{word[0]=}  {word[5]=}  {word[-1]=}  {word[-6]=}")

# A slice [start:stop] starts at start and stops just before stop.
print(f"{word[0:4]=}")
print(f"{word[1:5]=}")
print(f"{word[3:]=}")
print(f"{word[-3:]=}")
print(f"{word[:2]=}")

# A third number is the step: every second character, or backwards.
print(f"{word[::2]=}")
print(f"{word[::-1]=}")

# Out-of-range positions never fail in a slice: they are cut back, or the slice is empty.
print(f"{word[4:100]=}")
print(f"{word[10:]=}")
print(f"{word[4:2]=}")

word[0]='P'  word[5]='T'  word[-1]='T'  word[-6]='P'
word[0:4]='PLAN'
word[1:5]='LANE'
word[3:]='NET'
word[-3:]='NET'
word[:2]='PL'
word[::2]='PAE'
word[::-1]='TENALP'
word[4:100]='ET'
word[10:]=''
word[4:2]=''

Some rules to take from it:

• Leave out start to begin at the start, and leave out stop to run to the end: word[:2] is the first two characters and word[3:] everything from index 3 on.
• Negative numbers work in slices as they do in indexes. word[-3:], the last three characters, is the usual way to get the end of a string whatever its length.
• Because the stop is excluded, word[:i] + word[i:] is always the whole string again, and word[i:j] has j - i characters when 0 <= i <= j <= len(word).
• A step of -1 walks backwards, so word[::-1] is the string reversed.
• Slices are forgiving where indexes are not. A stop past the end is cut back to the end, a start past the end gives the empty string '', and a start after the stop gives '' too. None of them raises an error (only a step of 0 does), so a slice that silently comes back empty usually means one of its numbers is wrong.

Strings never change

Strings are immutable: once a string exists, nothing can change its characters. You can build a new string from pieces of an old one, but you cannot assign to one of its positions:

word = "PLANET"

# Build a new string from pieces of the old one.
changed = "J" + word[1:]
print(changed, word)

# Changing a character in place is not allowed.
word[0] = "J"

JLANET PLANET

Traceback (most recent call last):
  File "immutable.py", line 8, in <module>
    word[0] = "J"
    ~~~~^^^
TypeError: 'str' object does not support item assignment

The new string "JLANET" was printed next to the old one, which is still "PLANET". Then word[0] = "J" failed. This has some everyday consequences:

• To “change” a string, build a new one and bind a name to it: word = "J" + word[1:] makes word refer to the new string, while the old one is untouched (and is thrown away once nothing refers to it).
• Every string method, such as upper() or replace(), returns a new string and leaves the original alone, so you must keep the result: name.upper() on a line of its own does nothing useful. The next lesson covers the methods.
• When a program builds one long text from many small pieces, adding them one at a time with += creates a new string each time. The Python documentation warns that the total time can then grow with the square of the text’s length, and suggests putting the pieces in a list and calling "".join(pieces) once at the end.
• Because a string cannot change, it is safe to share: two names bound to the same string can never surprise each other. That is also why strings can be dictionary keys.

What len() counts

len() returns the number of items in a string, and each item is a Unicode code point: a number that the Unicode standard gives to a letter, a digit, a sign or an emoji. Most of the time one code point is one letter you see, but not always:

import unicodedata

greeting = "नमस्ते"  # "namaste" in Hindi
print(len(greeting))

# Each item of a string is one Unicode code point: a number with a name.
for ch in greeting:
    print(f"U+{ord(ch):04X} {unicodedata.name(ch)}")

# Slices count code points too, so they can split what looks like one letter.
print(greeting[:3], greeting[:4])

# Two ways to write é: one code point, or e followed by a combining accent.
one = "\u00e9"
two = "e\u0301"
print(one, two, len(one), len(two), one == two)

6
U+0928 DEVANAGARI LETTER NA
U+092E DEVANAGARI LETTER MA
U+0938 DEVANAGARI LETTER SA
U+094D DEVANAGARI SIGN VIRAMA
U+0924 DEVANAGARI LETTER TA
U+0947 DEVANAGARI VOWEL SIGN E
नमस नमस्
é é 1 2 False

"नमस्ते" looks like three or four letters, yet it is six code points. In Devanagari the vowel sign े and the virama ्, which removes the vowel from स so that it joins the next letter, are code points of their own that combine with the letters around them. Slices count code points as well, so greeting[:4] ends with the virama and shows half of a joined letter. The last line shows the same effect in a Latin script: an é can be one code point or two (an e followed by a combining accent). Both look the same, but Python compares code points, so they are not equal.

Key takeaways

• Single and double quotes make the same string; escapes such as \n, \t, \\ and \u0905 write characters you cannot type, and triple quotes keep line breaks.
• A raw string (r"…") keeps every backslash, which suits Windows paths and regular expressions, but it cannot end with a single backslash.
• word[i] counts from 0 at the left and from -1 at the right; a position past the end raises IndexError.
• word[start:stop:step] includes the start and excludes the stop, and positions out of range never raise an error; word[::-1] reverses.
• Strings are immutable: build new strings instead of changing them, keep the results of string methods, and join many pieces with "".join().
• len() counts Unicode code points, which are not always the letters you see.