String Cheatsheet

A string is a sequence of characters: letters, digits, spaces, and punctuation. This sheet collects everything from Chapter 8 and class in one place. Every example can be pasted into a file and run.

String Literals

"Hello, World!"      # double quotes
'Hello, World!'      # single quotes, same thing
""                   # the empty string: no characters
f"Hello, {name}!"    # formatted string literal, or f-string

In an f-string, {name} is replaced with the value of name. Use the other kind of quote when the text contains one: "It's here" or 'She said "hi"'.

Special Characters

print("Line one\nLine two")

Line one
Line two

Space, tab, and newline are whitespace characters.

Joining, Repeating, and Converting

first = "Jane"
greeting = "Hello, " + first   # "Hello, Jane"   + joins
greeting += "!"                # "Hello, Jane!"  += adds more
line = "-" * 20                # "--------------------"

+ joins (concatenates) two strings, += glues more onto the end, and * repeats. Strings and numbers do not mix:

age = 21
print("Age: " + age)        # TypeError
print("Age: " + str(age))   # Age: 21
print(f"Age: {age}")        # Age: 21   f-strings convert

The error message is can only concatenate str (not "int") to str.

input always gives back a string, even when the user types a number. int("abc") and int("3.5") are both a ValueError.

Indexing

   H   e   l   l   o   ,       W   o   r   l   d   !
   0   1   2   3   4   5   6   7   8   9  10  11  12

greeting = "Hello, World!"

greeting[0]                  # "H"   counting starts at 0
greeting[7]                  # "W"
greeting[6]                  # " "   the space is a character
greeting[len(greeting) - 1]  # "!"   the last index is len - 1
greeting[-1]                 # "!"   negative: from the end
greeting[13]                 # IndexError

Indexing an empty string is always an IndexError, so check len(text) > 0 first when the text comes from input.

Slicing

greeting = "Hello, World!"

greeting[0:5]      # "Hello"          up to, not including, 5
greeting[7:12]     # "World"
greeting[:5]       # "Hello"          start defaults to 0
greeting[7:]       # "World!"         end defaults to len
greeting[7:100]    # "World!"         past the end is fine
greeting[3:3]      # ""               nothing between 3 and 3
greeting[::2]      # "Hlo ol!"        every other character
greeting[::-1]     # "!dlroW ,olleH"  step backwards: reversed

The full form is text[start:end:step], and the end is never included, same as range. The piece you get back (a substring) is a new string; the original is untouched.

phone = "(800) 555-1357"

phone[1:4]     # "800"
phone[6:9]     # "555"
phone[10:]     # "1357"

Looping Over a String

word = "banana"

for i in range(len(word)):   # by index: i is 0, 1, 2, ...
    print(i, word[i])

for ch in word:              # by character: "b", "a", "n", ...
    print(ch)

Use the index version when you need the position. Use the character version when you only need the character. (Note: we won't be covering the second loop for ch in word until we get to Lists in chapter 6.)

Searching

Watch out: "" in s is always True, and "EM" in "EMO" is True. To check for one letter, check the length too: len(status) == 1 and status in "EMO".

find gives back an index, which is exactly what slicing needs:

full_name = "Jane Doe"
space = full_name.find(" ")     # 4

first = full_name[:space]       # "Jane"
last = full_name[space + 1:]    # "Doe"

Methods That Give Back a New String

Strings are immutable: no method changes the string it is called on. Each one gives back a new string, so keep it in a variable.

text = "hello"
text.upper()          # "HELLO" is built and thrown away
text = text.upper()   # text is now "HELLO"

After the second line, text is still "hello". After the third, it is "HELLO".

strip matters with input: users type extra spaces without noticing. It can also remove other characters: "$1,250".strip("$") is "1,250". Cleaning input often chains several methods, since each one gives back a string:

price = "  $ 1,250.50 "
clean = price.replace(" ", "")   # "$1,250.50"
clean = clean.replace("$", "")   # "1,250.50"
clean = clean.replace(",", "")   # "1250.50"
amount = float(clean)            # 1250.5

The three replace lines can be chained into one: price.replace(" ", "").replace("$", "").replace(",", "").

Checking Strings

Each gives back True or False. On the empty string, all of them give back False except isascii and isprintable.

"3.5".isdigit() and "-3".isdigit() are both False: the dot and the minus sign are not digits. For plain digits, isdigit, isdecimal, and isnumeric agree; they differ only on unusual characters.

password = input("Enter a password: ")
has_digit = False

for ch in password:
    if ch.isdigit():
        has_digit = True

Splitting

parts = "Jane Doe".split(" ")   # ['Jane', 'Doe']

parts[0]                        # "Jane"
parts[1]                        # "Doe"
len(parts)                      # 2

split cuts the string at every separator and gives back the pieces. The result is not a string. It is a new kind of value (a list, which gets its own lecture later) that holds several strings; indexing and len work on it. The pieces are strings, so they go through int or float before any math:

date = "2026-09-18"
parts = date.split("-")
year = int(parts[0]) # 2026

"a,b,,c".split(",")     # ['a', 'b', '', 'c']
"a   b".split()         # ['a', 'b']
"one\ntwo".splitlines() # ['one', 'two']
"-".join(parts)         # "2026-09-18"

Two separators in a row give an empty piece between them. With no separator, split cuts on any whitespace and ignores extras. splitlines cuts at every newline. join is the reverse of split: it glues the pieces back together with the string in front of the dot between them. The textbook also lists partition, which cuts at the first match and gives back three pieces: "jdoe@example.com".partition("@") is ('jdoe', '@', 'example.com').

Comparing Strings

"apple" == "apple"     # True    same characters, same order
"apple" == "Apple"     # False   case matters
"apple" != "pear"      # True
"apple" < "banana"     # True    alphabetical
"apple" < "Banana"     # False   uppercase before lowercase
"10" < "9"             # True    text: "1" is before "9"

< and > compare one character at a time, left to right, and every uppercase letter comes before every lowercase letter. Numbers stored as strings compare as text, so "10" comes before "9". To compare without caring about case, lowercase both sides: a.lower() == b.lower().

Characters Are Numbers Underneath

Every character has a number, its ASCII code, and < compares those numbers. ord gives the code for a character; chr gives the character for a code.

ord("A")            # 65
ord("a")            # 97
chr(66)             # "B"
chr(ord("a") + 1)   # "b"

Digits come before uppercase letters, and uppercase letters come before lowercase letters. That is why "Zebra" < "apple" is True.

Format Strings

Inside an f-string, {value:spec} controls how the value is printed.

Width is handy for lining up columns:

for row in range(1, 6):
    for col in range(1, 6):
        print(f"{row * col:3}", end="")

    print()

end="" keeps print from moving to the next line; print() on its own ends the line. The textbook also uses the older "Hello, {}!".format(name), which does the same thing as f"Hello, {name}!".

Common Mistakes

Glossary

• ASCII: The standard numbering of characters. ord and chr convert between a character and its number.
• character: A single letter, digit, symbol, or whitespace. A string is a sequence of characters.
• concatenation: Joining strings end to end with +.
• empty string: A string with no characters, written "".
• escape sequence: A backslash followed by a character, such as \n or \", that stands for a character you cannot type directly.
• immutable: Cannot be changed after it is created. Strings are immutable; string methods give back new strings.
• index: The position of a character in a string, counting from 0.
• newline: The special character denoted as \n, which represents a new line.
• separator: The string that split cuts on, such as " ", ",", or "-". The textbook calls it a delimiter.
• slicing: Generating a substring from a string using brackets and colons, for example s[0:5].
• str: The Python type for representing strings as a sequence of characters, which provides methods for working with strings.
• str(): The Python function to convert a value of another data type to a string.
• string literal: A string constant, defined as a set of characters between apostrophes or quotes.
• string method: A method that can work with a string to generate a result; depending on the method, the result is of a particular type such as string, Boolean, integer, or list.
• string variable: A variable that refers to a string.
• substring: A piece of a string, such as what slicing gives back.
• whitespace: A character such as space, tab, or newline.
• zero-indexing: Counting positions from 0 rather than 1, so the first character is at index 0 and the last is at len(s) - 1.