Strings

Make a day03 folder for today’s files, open it in your editor, and run each script from its terminal, as on Days 1 and 2.

Since Day 1 you have written text like "Hello". Python calls a piece of text a string, and its type is str. A string is a sequence of characters: letters, digits, spaces, punctuation, each one a single symbol. Today you learn to take strings apart, change them, and build them into neat output. First, how do you put a quote mark inside a string, when quote marks are what start and end it?

Python lets you write a string with either kind of quote, "double" or 'single'. Both make exactly the same string. Having two kinds means you can use one kind to hold the other:

print("Hello, Ana")
print('Hello, Ana')
print("It's raining")
print('She said "hi"')

Hello, Ana
Hello, Ana
It's raining
She said "hi"

Lines 1 and 2 print the same thing: the quotes are not part of the text. In line 3 the apostrophe is safe because the string is in double quotes, and in line 4 the double quotes are safe inside single quotes. This course uses double quotes unless the text holds a ".

print('It's raining')

  File ".../day03/apostrophe_in_single.py", line 1
    print('It's raining')
                       ^
SyntaxError: unterminated string literal (detected at line 1)

Sometimes you need both kinds of quote, or a character you cannot type into a string at all, such as a line break. For these, Python uses an escape character: a backslash \ followed by a letter or symbol, which together stand for one special character. (“Escape” because the backslash escapes the normal meaning of the next character.)

print("Line one\nLine two")
print("Name:\tAna")
print("She said \"hi\"")
print('It\'s raining')
print("C:\\new_folder")

Line one
Line two
Name:	Ana
She said "hi"
It's raining
C:\new_folder

For text that spans several lines, such as a poem or a menu, writing \n everywhere is hard to read. A triple-quoted string starts and ends with three quote marks, """ (or '''), and can run over several lines. Every line break inside it becomes part of the string:

poem = """Roses are red,
violets are blue,
this string has three lines."""
print(poem)

Roses are red,
violets are blue,
this string has three lines.

Finally, the REPL shows a string differently from print. The REPL shows a string as you would type it into code: in quotes (single unless the text holds an apostrophe), with escapes written out. print shows the characters themselves:

>>> "It's raining"
"It's raining"
>>> 'Hello'
'Hello'
>>> "Line one\nLine two"
'Line one\nLine two'
>>> print("Line one\nLine two")
Line one
Line two

print("Ready,\nset,\ngo!")
print("Say \"cheese\"")
print('Don\'t type \\n')

Ready,
set,
go!
Say "cheese"
Don't type \n

Once text is in a string, the first questions are often simple: how long is it, can I stick two strings together, and does it contain some word? Python answers each with one short piece of syntax.

• The built-in function len() gives the length of a string: how many characters it has. Spaces and punctuation count, and the empty string "" has length 0.
• Concatenation means joining strings end to end, and + does it for strings. Python adds nothing between them; a space appears only if you include one.
• Repetition: * with a string and an int repeats the string that many times.

>>> len("Python")
6
>>> len("New York")
8
>>> len("")
0
>>> "snow" + "ball"
'snowball'
>>> "snow" + " " + "ball"
'snow ball'
>>> "ha" * 3
'hahaha'
>>> "-" * 10
'----------'

Notice that + and * mean something different for strings than for numbers. The type of the values decides what an operator does, as Day 2 showed with /.

first_name = "Grace"
last_name = "Hopper"
full_name = first_name + " " + last_name
border = "*" * (len(full_name) + 4)
print(border)
print("* " + full_name + " *")
print(border)
print("Characters:", len(full_name))

****************
* Grace Hopper *
****************
Characters: 12

Two more operators ask yes-or-no questions about strings, so they give a bool (Day 2):

• in asks whether one string appears inside another: "York" in "New York" is True. The part you look for is a substring, a run of characters inside a string.
• == asks whether two values are equal: "stop" == "stop" is True. It is two equals signs; a single = assigns. Day 4 covers comparisons fully; today you only need == to check whether two strings match.

>>> "York" in "New York"
True
>>> "york" in "New York"
False
>>> "ark" in "parking"
True
>>> "stop" == "stop"
True
>>> "stop" == "Stop"
False

Both are case-sensitive: "y" and "Y" are different characters, so "york" is not in "New York".

age = 15
print("Age: " + age)

Traceback (most recent call last):
  File ".../day03/age_label.py", line 2, in <module>
    print("Age: " + age)
          ~~~~~~~~^~~~~
TypeError: can only concatenate str (not "int") to str

>>> len("hi there")
>>> "ab" * 2 + "c"
>>> "3" + "4"
>>> "car" in "Scar"

>>> len("hi there")
8
>>> "ab" * 2 + "c"
'ababc'
>>> "3" + "4"
'34'
>>> "car" in "Scar"
True

To print someone’s initials, you need the first character of a name, not the whole string. Python numbers every character’s position so you can ask for one.

The position of a character is its index. Indexes start at 0, not 1: the first character is at index 0, the second at index 1, and so on. Think of the index as “how many characters come before this one”: the first character has 0 before it. To get the character at an index, write the index in square brackets after the string. This is called indexing.

Python also counts from the end with negative indexes: -1 is the last character, -2 the one before it. Here are both numberings for "Python":

>>> word = "Python"
>>> word[0]
'P'
>>> word[3]
'h'
>>> word[5]
'n'
>>> word[-1]
'n'
>>> word[-6]
'P'
>>> word[len(word) - 1]
'n'

A string of 6 characters has indexes 0 to 5, so the last index is always len(word) - 1. word[-1] is a shorter way to say the same thing, and it works for a string of any length. Indexing gives a new string of length 1; Python has no separate type for a single character.

Now vary the index past the end:

word = "Python"
print(word[6])

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

An IndexError means you asked for a position that does not exist. "Python" has 6 characters, but because counting starts at 0, there is no index 6.

>>> city = "Lisbon"
>>> city[1]
>>> city[-2]
>>> city[len(city) - 3]

>>> city = "Lisbon"
>>> city[1]
'i'
>>> city[-2]
'o'
>>> city[len(city) - 3]
'b'

A date stored as "2026-10-09" holds a year, a month, and a day. Indexing gets one character at a time; to get the four-character year you need a range of positions.

A slice is a part of a string taken from a range of indexes, written text[start:stop]. It starts at start and stops before stop: the character at stop is not included. So word[0:2] is index 0 and index 1, two characters. A handy check: a slice has stop - start characters.

Either number can be left out. Leave out start and the slice begins at the start of the string; leave out stop and it runs to the end.

>>> word = "Python"
>>> word[0:2]
'Py'
>>> word[2:5]
'tho'
>>> word[:3]
'Pyt'
>>> word[3:]
'hon'
>>> word[-3:]
'hon'
>>> word[:]
'Python'
>>> word[4:100]
'on'

• word[2:5] takes indexes 2, 3, and 4: 'tho'.
• word[:3] is the first three characters, and word[3:] is everything from index 3 on. Together they rebuild "Python".
• word[-3:] starts three from the end: the last three characters.
• word[4:100] goes past the end, but a slice never causes an IndexError: it stops at the end of the string. Only indexing a single position does.

date = "2026-10-09"
year = date[0:4]
month = date[5:7]
day = date[8:]
print("Year:", year)
print("Month:", month)
print("Day:", day)

Year: 2026
Month: 10
Day: 09

A slice can take a third number, the step: text[start:stop:step] takes every step-th character. A step of 2 takes every second character. A negative step walks backwards, so text[::-1], with start and stop left out, is the whole string reversed.

>>> letters = "abcdefgh"
>>> letters[0:6:2]
'ace'
>>> letters[::2]
'aceg'
>>> letters[1::2]
'bdfh'
>>> letters[::-1]
'hgfedcba'
>>> "stressed"[::-1]
'desserts'

letters[0:6:2] takes indexes 0, 2, and 4. letters[1::2] starts at 1 and takes every second character to the end. [::-1] is the usual way to reverse a string in Python, and with == from 3.2 it tells you whether a word reads the same both ways.

>>> item = "notebook"
>>> item[0:4]
>>> item[4:]
>>> item[1:6:2]
>>> item[::-1]

>>> item = "notebook"
>>> item[0:4]
'note'
>>> item[4:]
'book'
>>> item[1:6:2]
'oeo'
>>> item[::-1]
'koobeton'

Suppose word holds "cat" and you want "bat". Indexing reads a character, so it seems you could assign to one:

word = "cat"
word[0] = "b"
print(word)

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

Python refuses. A string is immutable: once made, its characters can never change. (“Item assignment” means assigning to one position.) You can still get "bat". Build a new string from the pieces you want, and point the name at it:

word = "cat"
word = "b" + word[1:]
print(word)

bat

Line 2 makes a new string, "b" + "at", and rebinds word to it (rebinding is from Day 2). The old "cat" is not changed; the name simply refers to a different string now.

Why make strings unchangeable? Because a value that cannot change is safe to share. If two names refer to the same string, nothing done through one name can surprise the other. It also means every string operation you learn today, slices and the methods in 3.6, leaves the original alone and gives you a new string.

title = "hello world"
title[0] = title[0].upper()
print(title)

TypeError: 'str' object does not support item assignment

title = "hello world"
title = title[0].upper() + title[1:]
print(title)

Hello world

Text that people type is messy: extra spaces, random capitals, the wrong punctuation. Cleaning it with slices alone would be slow. Python gives every string a set of ready-made tools for these jobs.

A method is a function that belongs to a value. You call it by writing the value, a dot, the method’s name, and parentheses: name.upper(). The value before the dot is what the method works on, and any arguments go inside the parentheses, as with print and len. Because strings are immutable (3.5), a method never changes the string: it returns (gives back) a new value.

Spaces, tabs, and new lines are together called whitespace; strip removes it from both ends but not from the middle.

>>> name = "  Ada Lovelace  "
>>> name.strip()
'Ada Lovelace'
>>> name.upper()
'  ADA LOVELACE  '
>>> name.strip().lower()
'ada lovelace'
>>> name
'  Ada Lovelace  '

The last line shows name itself is unchanged, spaces and all. name.strip().lower() is a method chain: Python runs it left to right, so strip() returns 'Ada Lovelace' and lower() works on that new string.

The other four methods search and replace:

>>> sentence = "the cat sat on the mat"
>>> sentence.replace("cat", "dog")
'the dog sat on the mat'
>>> sentence.count("at")
3
>>> sentence.find("sat")
8
>>> sentence.find("dog")
-1
>>> sentence.startswith("the")
True
>>> sentence.startswith("cat")
False

• replace changed every "cat" (there is one).
• count("at") finds at in “cat”, “sat”, and “mat”: 3.
• find("sat") is 8: “the cat “ is 8 characters before it. find gives -1 when the part is missing, because -1 can never be a real starting position.
• startswith gives a bool, like in, but checks only the beginning.

raw_email = "  Maya.Lopez@Example.com  "
email = raw_email.strip().lower()
at_position = email.find("@")
print("Cleaned:", email)
print("Name part:", email[:at_position])
print("Domain:", email[at_position + 1:])
print("Dots:", email.count("."))

Cleaned: maya.lopez@example.com
Name part: maya.lopez
Domain: example.com
Dots: 2

name = "ada"
name.upper()
print(name)

ada

>>> code = " ab-12-ab "
>>> code.strip().upper()
>>> code.count("ab")
>>> code.replace("-", "")
>>> code.find("12")

>>> code = " ab-12-ab "
>>> code.strip().upper()
'AB-12-AB'
>>> code.count("ab")
2
>>> code.replace("-", "")
' ab12ab '
>>> code.find("12")
4

A sentence is made of words, and a date of numbers separated by dashes. Often you want the separate pieces, or you want to glue pieces back together with something new between them. Two more methods do exactly that.

split() breaks a string into pieces. With no argument it splits wherever there is whitespace, and ignores extra spaces. With an argument, such as split("-"), it splits at each copy of that separator and drops the separators.

join() does the opposite: it glues pieces together, putting the string it is called on between each pair. Read "-".join(pieces) as “join the pieces with a dash”.

>>> "Ada Lovelace".split()
['Ada', 'Lovelace']
>>> "  red   green blue ".split()
['red', 'green', 'blue']
>>> "2026-10-09".split("-")
['2026', '10', '09']
>>> "-".join("abc")
'a-b-c'
>>> "/".join("2026-10-09".split("-"))
'2026/10/09'

The result of split is shown in square brackets, like ['Ada', 'Lovelace']. That is a list: one value holding several values in order. Lists get a whole day of their own (Day 6). Today, just read the printed result as “these strings, in this order”.

join needs the pieces to glue. A string is a sequence of characters, so "-".join("abc") puts a dash between each character. The last line splits a date at its dashes and joins the pieces with slashes, turning 2026-10-09 into 2026/10/09. ("2026-10-09".replace("-", "/") gives the same here.)

>>> "one,two,,three".split(",")
>>> "+".join("123")
>>> " ".join("to   be or not".split())
>>> "".join("a b c".split())

>>> "one,two,,three".split(",")
['one', 'two', '', 'three']
>>> "+".join("123")
'1+2+3'
>>> " ".join("to   be or not".split())
'to be or not'
>>> "".join("a b c".split())
'abc'

Day 2 left a promise: round(2.50, 2) shows 2.5, and a price should show as 2.50. And building a line like "Total: " + str(total) with + and str() is clumsy. One tool fixes both.

An f-string is a string with the letter f just before its opening quote. Inside it, anything in curly braces { } is worked out as an expression, and its value is placed into the text. A value placed into a string this way is said to be interpolated. The expression can be a name or any calculation, and Python converts the value to text for you, so there is no need for str().

name = "Ana"
tickets = 3
price = 12.5
print(f"{name} bought {tickets} tickets.")
print(f"Total: {tickets * price}")
print(f"Total: {tickets * price:.2f}")

Ana bought 3 tickets.
Total: 37.5
Total: 37.50

The :.2f is a format specifier: instructions, after a colon inside the braces, for how to show the value. Take .2f apart:

• : separates the expression from the instructions.
• .2 means two digits after the decimal point.
• f means fixed-point: always show exactly that many decimal places, rounding or adding zeros as needed.

Change the 2 to get a different number of places: :.1f for one, :.3f for three.

>>> price = 2.5
>>> f"{price:.2f}"
'2.50'
>>> f"{3.14159:.3f}"
'3.142'
>>> f"{0.1 + 0.2:.2f}"
'0.30'
>>> f"{7:.2f}"
'7.00'
>>> round(2.5, 2)
2.5

Each line gives a string with exactly the decimals asked for: 2.50, 3.142 (rounded), 0.30 (the floating-point error from Day 2 is hidden in the display), and 7.00 from a plain int. Compare round and :.2f side by side:

name = "Ana"
print("Hello, {name}!")

Hello, {name}!

>>> width = 4
>>> height = 2.5
>>> f"{width} x {height} = {width * height}"
>>> f"Area: {width * height:.1f} m"
>>> f"{1 / 3:.2f}"
>>> f"{2 / 3:.2f}"

>>> width = 4
>>> height = 2.5
>>> f"{width} x {height} = {width * height}"
'4 x 2.5 = 10.0'
>>> f"Area: {width * height:.1f} m"
'Area: 10.0 m'
>>> f"{1 / 3:.2f}"
'0.33'
>>> f"{2 / 3:.2f}"
'0.67'

Every program so far has used the same values each time it ran. To ask the user something, such as their name or age, a program needs to read what they type.

The built-in function input() shows a message, called a prompt, then waits. The user types a line and presses Enter, and input() returns what they typed, without the Enter, as a string. Put a space at the end of the prompt so the typing does not touch it.

name = input("What is your name? ")
print(f"Nice to meet you, {name}!")

When you run it and type Ana, the terminal shows:

What is your name? Ana
Nice to meet you, Ana!

Line 1 prints the prompt and pauses until Enter is pressed. Then name refers to "Ana", and line 2 places it into an f-string.

Now vary the program to ask for two numbers and add them. Watch what happens when the user types 5 and 3:

first = input("First number: ")
second = input("Second number: ")
print("Sum:", first + second)

First number: 5
Second number: 3
Sum: 53

The sum is 53, with no error message. input() always returns a string, whatever the user types. first is "5" and second is "3", so + joins them (3.2). input cannot know you wanted a number: someone might type a name, a phone number with a leading 0, or “maybe”, so Python leaves the converting to you.

Convert with int() or float() from Day 2. You can wrap the call around input() directly:

first = int(input("First number: "))
second = int(input("Second number: "))
print("Sum:", first + second)

First number: 5
Second number: 3
Sum: 8

Python works out int(input("First number: ")) from the inside out: input runs first and returns "5", then int("5") gives the int 5. Use float(input(...)) for decimals such as prices. If the user types something that is not a number, such as five, the conversion stops with the ValueError from Day 2; Day 15 shows how to handle bad input.

age = input("How old are you? ")
print("Next year you will be", age + 1)

How old are you? 15
Traceback (most recent call last):
  File ".../day03/age_next_year.py", line 2, in <module>
    print("Next year you will be", age + 1)
                                   ~~~~^~~
TypeError: can only concatenate str (not "int") to str

city = input("City: ")
nights = input("Nights: ")
print(city.upper(), nights * 2)
print(f"{city[:3]}-{int(nights) * 2}")

City: Oslo
Nights: 3
OSLO 33
Osl-6

A café wants a small program that prints an order slip. The user types a name (with stray spaces), a drink, the number of cups, and the price per cup. This run types Sam, Latte, 2, and 3.75:

# Coffee order receipt
name = input("Name: ").strip()
drink = input("Drink: ").strip().lower()
cups = int(input("Cups: "))
price = float(input("Price per cup: "))

total = cups * price
order_code = name[:3].upper() + str(cups)

print("-" * 24)
print(f"Order {order_code} for {name}")
print(f"{cups} x {drink}")
print(f"Total: {total:.2f}")
print("-" * 24)

Name:   Sam
Drink: Latte
Cups: 2
Price per cup: 3.75
------------------------
Order SAM2 for Sam
2 x latte
Total: 7.50
------------------------

Lines 2 and 3 call methods straight on what input returns, so the stray spaces never reach a variable. Line 8 slices the name, makes it capitals, and joins the cup count as a string: + needs both sides to be strings, so str(cups) is required. Lines 11 to 13 build the slip with f-strings, and :.2f shows 7.5 as 7.50.

• A string is text in single, double, or triple quotes. Escape characters such as \n, \", and \\ stand for characters you cannot type directly.
• len() counts characters, + joins strings, * repeats them, and in and == give True or False.
• Indexes start at 0, and negative indexes count from the end. A slice text[start:stop:step] stops before stop, and text[::-1] reverses.
• Strings are immutable, so slices and methods (upper, lower, strip, replace, find, startswith, count, split, join) return new values and leave the original alone.
• An f-string places values into text, and :.2f shows exactly two decimal places.
• input() always returns a string; convert with int() or float() before doing math.

Do these in your day03 folder. Type each program yourself, run it, and only then open the answer. Run each one several times with different typed input.

full_name = input("Full name: ").strip()
space = full_name.find(" ")
first_initial = full_name[0].upper()
last_initial = full_name[space + 1].upper()
print(f"Initials: {first_initial}.{last_initial}.")

Full name: ada lovelace
Initials: A.L.

word = input("Word: ").strip().lower()
reversed_word = word[::-1]
print(f"Reversed: {reversed_word}")
print("Palindrome:", word == reversed_word)

Word: Racecar
Reversed: racecar
Palindrome: True

price = float(input("Price: "))
quantity = int(input("Quantity: "))
total = price * quantity
print(f"{quantity} x {price:.2f} = {total:.2f}")

Price: 4.5
Quantity: 3
3 x 4.50 = 13.50

title = "  the hobbit  "
clean = title.strip()
print(clean.upper())
print(clean[4:].replace("b", "B"))
print(len(clean), clean.count("t"))

THE HOBBIT
hoBBit
10 2

word = "stone"
word.upper()
new_word = word.replace("s", "")
word = word + "s"
print(word, new_word)
print(word.find("t"), new_word.find("s"))

stones tone
1 -1

tickets = input("Tickets: ")
total = tickets * 12.5
print(f"Total: {total:.2f}")

Tickets: 3
Traceback (most recent call last):
  File ".../day03/ticket_cost.py", line 2, in <module>
    total = tickets * 12.5
            ~~~~~~~~^~~~~~
TypeError: can't multiply sequence by non-int of type 'float'

tickets = int(input("Tickets: "))
total = tickets * 12.5
print(f"Total: {total:.2f}")

Tickets: 3
Total: 37.50

card = "4111222233334444"
masked = "*" * (len(card) - 4) + card[-4:]
print(masked)

************4444

The official Python Tutorial covers strings, indexing, and slicing in An Informal Introduction to Python: Text, and f-strings in Input and Output: Formatted String Literals.

Check each statement. If the answer is “not yet,” reread the linked subsection.

• I can write strings with quotes inside them and use escape characters. Reread
• I can use len, +, *, in, and == with strings. Reread
• I can get any character with a positive or negative index. Reread
• I can slice any part of a string, use a step, and reverse a string. Reread
• I can explain why a string cannot be changed in place, and build a new one instead. Reread
• I can clean and search text with string methods. Reread
• I can split a string into pieces and join pieces back together. Reread
• I can build formatted output with f-strings and :.2f. Reread
• I can read input and convert it to a number. Reread