Python String Methods, Operators, Arithmetic & Assignment Operators

Before diving in, make sure you are comfortable with the following ideas from earlier lessons:

• Variables: A named container that stores a value (e.g., market = "Lagos Island Market").
• Strings: Text enclosed in single or double quotes (e.g., "Jollof rice is delicious").
• print(): The function that displays output to the screen.
• Data Types: You know that "hello" is a string (str) and 10 is an integer (int).

If any of these feel unclear, revisit Lessons 02 to 04 before continuing.

Section 1.1 · What Is a Method?

Imagine you have a brand-new Nokia phone fresh out of the box. The phone itself is the object · in Python terms, that is your string. The phone comes with buttons and features built in: you can call someone, take a photo, or send an SMS. Those built-in features are called methods in Python.

A method is a special function that is already built into an object. You call it by writing the object's name, then a dot ., then the method name, followed by parentheses ().

object.method()

For strings, a method is a tool you use on a piece of text to transform or examine it.

One critical rule you must never forget:

All string methods return a new value. They do NOT change the original string.

This is unlike editing a document · it is more like making a photocopy and changing the copy. The original stays untouched.

Section 1.2 · Case-Changing Methods

These methods change the capitalisation of text. They are incredibly useful when you receive user input that may be typed inconsistently · for example, someone types "ABUJA" or "abuja" when you want "Abuja".

upper() · Convert Everything to UPPERCASE

Why it exists: Useful when you want to emphasise text, create headings, or standardise input for comparison.

How it works: Every letter in the string is converted to its capital form.

city = "lagos"
print(city.upper())

Expected output in the terminal:

LAGOS

Notice that city still holds "lagos" · the original is untouched. Only the printed result changed.

lower() · Convert Everything to lowercase

Why it exists: Useful for normalising input. For example, when checking if an email address or username already exists, you want to compare everything in lowercase so "Amaka@mail.com" and "amaka@mail.com" are treated the same.

email = "AMAKA@GMAIL.COM"
print(email.lower())

Expected output:

amaka@gmail.com

capitalize() · Capitalise ONLY the First Letter

Why it exists: Useful for proper names, titles, or the first word of a sentence when the input came in all-lowercase or mixed case.

How it works: The very first character of the entire string is made uppercase, and every other character is made lowercase.

dish = "egusi soup"
print(dish.capitalize())

Expected output:

Egusi soup

Thinking Prompt: What happens if the string is "EGUSI SOUP"? Try it mentally · capitalize() makes the first letter upper and ALL others lower. The result would still be "Egusi soup".

title() · Capitalise the First Letter of Every Word

Why it exists: Perfect for formatting names, book titles, city names, or article headings.

How it works: The first character of each word is made uppercase.

meal = "pounded yam and egusi soup"
print(meal.title())

Expected output:

Pounded Yam And Egusi Soup

swapcase() · Flip Every Letter's Case

Why it exists: Occasionally used for creative text effects or decoding puzzles.

How it works: Any uppercase letter becomes lowercase, and any lowercase letter becomes uppercase.

greeting = "Good Morning Lagos"
print(greeting.swapcase())

Expected output:

gOOD mORNING lAGOS

casefold() · Aggressive Lowercase for Comparisons

Why it exists: casefold() goes even further than lower() when comparing strings across different languages and special characters. For everyday Python in English, it behaves the same as lower(), but it is the recommended method for text comparisons.

name1 = "CHUKWUEMEKA"
name2 = "chukwuemeka"
print(name1.casefold() == name2.casefold())

Expected output:

True

Section 1.3 · Searching Inside Strings

These methods let you look for something inside a string, similar to using Ctrl+F in a document editor.

find() · Find a Substring's Position

Why it exists: You need to know where a word or character appears inside a string · for example, scanning a customer complaint for the word "refund".

How it works: find(substring) searches the string from left to right. It returns the index position (position number) where the substring first appears. If it cannot find it, it returns -1.

Quick reminder: Index positions in Python start at 0, not 1. So the first character is at position 0, the second at position 1, and so on.

message = "Please send the Ankara fabric to Kano"
position = message.find("Ankara")
print(position)

Expected output:

17

This means the word "Ankara" starts at position 17 in the string.

# What if the word is not found?
print(message.find("Aso-Oke"))

Expected output:

-1

The value -1 is Python's way of saying "not found."

index() · Like find(), but Raises an Error if Not Found

Why it exists: When you are absolutely certain a word should be there and want Python to crash loudly if it is not (so you notice the bug immediately).

text = "Dangote is a major Nigerian business group"
print(text.index("Nigerian"))

Expected output:

23

If the word is not there, index() raises a ValueError error · unlike find() which quietly returns -1. For beginners, find() is usually safer.

count() · Count How Many Times a Substring Appears

Why it exists: Useful in data analysis · for example, counting how many times a customer said "broken" in a product review.

review = "The suya was good. The pepper was good. The service was good."
print(review.count("good"))

Expected output:

3

startswith() · Does the String Begin with This?

Why it exists: Quickly check if a filename, URL, phone number, or code starts with the expected characters.

phone = "0801-234-5678"
print(phone.startswith("0801"))

Expected output:

True

print(phone.startswith("0902"))

Expected output:

False

endswith() · Does the String Finish with This?

Why it exists: Check file types, extensions, or suffixes. For example, check if a filename is a PDF.

filename = "WAEC_Result_2024.pdf"
print(filename.endswith(".pdf"))

Expected output:

True

rfind() · Find the LAST Occurrence of a Substring

Why it exists: If a word appears multiple times, sometimes you want the position of the last one, not the first.

sentence = "Eko is great. Lagos is great. Nigeria is great."
print(sentence.rfind("great"))

Expected output:

40

Section 1.4 · Replacing and Splitting Text

replace() · Swap One Word for Another

Why it exists: Update text without rewriting the whole thing · like Find & Replace in Microsoft Word.

How it works: replace(old, new) takes two arguments: the text to find, and the text to replace it with.

menu = "We serve Jollof rice with chicken"
updated_menu = menu.replace("chicken", "catfish")
print(updated_menu)

Expected output:

We serve Jollof rice with catfish

# Replace ALL occurrences
prices = "Price: ₦500. Discount Price: ₦500. Bulk Price: ₦500."
print(prices.replace("₦500", "₦450"))

Expected output:

Price: ₦450. Discount Price: ₦450. Bulk Price: ₦450.

You can also limit how many replacements are made by providing a third argument:

print(prices.replace("₦500", "₦450", 1))  # Replace only the first occurrence

Expected output:

Price: ₦450. Discount Price: ₦500. Bulk Price: ₦500.

split() · Break a String into a List of Pieces

Why it exists: When you receive a string of comma-separated values, or a sentence of words, and you need to process each part separately.

How it works: split(separator) cuts the string at every point where the separator occurs, and returns a list (a collection of items).

states = "Lagos,Abuja,Kano,Rivers,Enugu"
state_list = states.split(",")
print(state_list)

Expected output:

['Lagos', 'Abuja', 'Kano', 'Rivers', 'Enugu']

Without a separator, split() splits on any whitespace (spaces, tabs):

sentence = "My name is Tunde"
words = sentence.split()
print(words)

Expected output:

['My', 'name', 'is', 'Tunde']

join() · Join a List of Strings into One

Why it exists: The opposite of split(). It takes a list of words and glues them together with a separator.

How it works: You call join() on the separator string and pass it the list.

words = ["Fried", "plantain", "is", "delicious"]
sentence = " ".join(words)  # Join using a space
print(sentence)

Expected output:

Fried plantain is delicious

items = ["beans", "yam", "palm oil"]
shopping = ", ".join(items)
print(shopping)

Expected output:

beans, yam, palm oil

splitlines() · Split a Multi-Line String at Line Breaks

Why it exists: When you read a text file or multi-line message, you often want to handle each line separately.

address = "No. 12 Adeola Odeku Street\nVictoria Island\nLagos"
lines = address.splitlines()
print(lines)

Expected output:

['No. 12 Adeola Odeku Street', 'Victoria Island', 'Lagos']

Section 1.5 · Stripping Whitespace and Padding Text

Whitespace means invisible characters like spaces, tabs, or newlines that appear at the beginning or end of a string. They are often the culprit when user input doesn't match what you expect.

strip() · Remove Whitespace from BOTH Ends

name = "   Funmilayo   "
print(name.strip())

Expected output:

Funmilayo

lstrip() · Remove Whitespace from the LEFT Only

name = "   Funmilayo   "
print(name.lstrip())

Expected output:

Funmilayo   

rstrip() · Remove Whitespace from the RIGHT Only

name = "   Funmilayo   "
print(name.rstrip())

Expected output:

   Funmilayo

Real-world use: When users type their name into a form and accidentally add spaces, strip() cleans the input before your program uses it. This prevents bugs like "Lagos" != " Lagos".

center(), ljust(), rjust() · Aligning Text with Padding

These methods position text within a fixed-width field, filling empty space with a character (default is a space).

# center() — centre the text in a field of 30 characters
print("LAGBAJA MARKET".center(30))
print("LAGBAJA MARKET".center(30, "-"))

Expected output:

        LAGBAJA MARKET        
--------LAGBAJA MARKET--------

# ljust() — left-align in a field of 30 characters
print("Beans".ljust(20, "."))
print("Jollof Rice".ljust(20, "."))
print("Pounded Yam".ljust(20, "."))

Expected output:

Beans...............
Jollof Rice.........
Pounded Yam.........

# rjust() — right-align
print("₦1500".rjust(15))
print("₦200".rjust(15))

Expected output:

          ₦1500
           ₦200

zfill() · Pad a String on the Left with Zeros

Why it exists: Useful for formatting order numbers, student IDs, bank account numbers, or phone extension codes that must always have a fixed number of digits.

order_id = "42"
print(order_id.zfill(6))   # Pad to 6 digits

Expected output:

000042

Section 1.6 · Checking What a String Contains

These methods inspect a string and return either True or False. They are perfect for validating input · checking if what the user typed matches the expected format.

isalpha() · Are ALL Characters Letters?

print("Ngozi".isalpha())      # True — only letters
print("Ngozi123".isalpha())   # False — has digits
print("Ngozi Obi".isalpha())  # False — has a space

Expected output:

True
False
False

isdigit() · Are ALL Characters Digits?

print("12345".isdigit())    # True
print("123.45".isdigit())   # False — decimal point is not a digit
print("₦500".isdigit())     # False — currency symbol is not a digit

Expected output:

True
False
False

isalnum() · Are ALL Characters Letters OR Digits?

print("Student123".isalnum())   # True
print("Student 123".isalnum())  # False — space is not allowed

Expected output:

True
False

isnumeric() · A Broader Check for Numeric Characters

Similar to isdigit() but also accepts characters like fractions and superscripts used in other writing systems.

isspace() · Is the String ONLY Whitespace?

print("   ".isspace())    # True — only spaces
print("  a  ".isspace())  # False — contains a letter

Expected output:

True
False

islower() and isupper() · Check Letter Case

print("hello".islower())   # True
print("HELLO".isupper())   # True
print("Hello".isupper())   # False

Expected output:

True
True
False

istitle() · Does It Follow Title Case Rules?

print("The Lagos State Government".istitle())  # True
print("the lagos state government".istitle())  # False

Expected output:

True
False

Section 1.7 · Encoding and Translating

encode() · Encode the String as Bytes

Why it exists: When you send data over a network or save it to a file, it is sometimes stored as raw bytes rather than human-readable text. This method converts the string into that byte format.

text = "Abuja"
print(text.encode())

Expected output:

b'Abuja'

The b in front means "this is bytes, not a regular string."

partition() and rpartition() · Split a String into Exactly Three Parts

partition(sep) finds the first occurrence of a separator and returns a tuple (a fixed group) of three parts: the text before, the separator itself, and the text after.

data = "Name: Emeka Eze"
result = data.partition(": ")
print(result)

Expected output:

('Name', ': ', 'Emeka Eze')

rpartition() does the same but from the right (last occurrence).

format() · Insert Values into a String Template

You have already used f-strings. The format() method does the same thing in a slightly older style using {} placeholders.

template = "Hello, {}! You have {} new messages."
message = template.format("Chidinma", 5)
print(message)

Expected output:

Hello, Chidinma! You have 5 new messages.

expandtabs() · Control Tab Width

When strings contain tab characters (\t), this method sets how wide each tab should appear.

text = "Name\tCity\tAge"
print(text.expandtabs(15))

Expected output:

Name           City           Age

maketrans() and translate() · Character Substitution Table

These two methods work together to create a character-by-character replacement map.

# Replace 'a' → '4', 'e' → '3', 'o' → '0'
table = str.maketrans("aeo", "430")
text = "Suya and pepper soup"
print(text.translate(table))

Expected output:

Suy4 4nd p3pp3r s0up

Section 1.8 · The Full String Methods Reference Table

Here is a complete reference of every built-in Python string method:

Section 2.1 · What Is an Operator?

An operator is a symbol that tells Python to perform a specific action on one or more values. You already know the most famous one: +. When you write 5 + 3, the + is the operator, and 5 and 3 are the operands (the values being operated on).

Think of operators like the buttons on your calculator. Each button tells the calculator what to do with the numbers you have entered.

print(10 + 5)    # The + operator adds two numbers

Expected output:

15

Operators can also work with variables:

naira_price = 100
vat = 50
total = naira_price + vat    # 100 + 50
print(total)

Expected output:

150

And variables can be combined with each other:

cost_price = 5000
markup    = cost_price + 1000   # 6000
selling_price = markup + markup  # 12000
print(selling_price)

Expected output:

12000

Section 2.2 · The Seven Groups of Python Operators

Python organises its operators into seven groups based on what they do:

1. Arithmetic Operators · do maths (+, -, *, /, etc.)
2. Assignment Operators · store values in variables (=, +=, etc.)
3. Comparison Operators · compare two values and return True or False (==, >, <, etc.)
4. Logical Operators · combine conditions (and, or, not)
5. Identity Operators · check if two variables point to the same object (is, is not)
6. Membership Operators · check if a value exists in a sequence (in, not in)
7. Bitwise Operators · work on binary representations of numbers (&, |, ^, etc.)

In this lesson we cover Groups 1 and 2 in full depth. The other groups will be taught as they become relevant.

Section 3.1 · What Are Arithmetic Operators?

Arithmetic operators are used with numeric values to perform common mathematical operations · the same operations you learned in primary school. Python supports seven of them.

Here is the complete table:

Let us learn each one carefully.

Section 3.2 · Addition +

What it does: Adds two numbers together.

bags_of_rice = 20
bags_donated = 5
total_bags = bags_of_rice + bags_donated
print(total_bags)

Expected output:

25

The + operator also works on strings (it concatenates them · joins them together):

first_name = "Amina"
last_name = " Bello"
full_name = first_name + last_name
print(full_name)

Expected output:

Amina Bello

Section 3.3 · Subtraction -

What it does: Subtracts the second number from the first.

budget = 50000      # ₦50,000 market budget
spent = 23500       # ₦23,500 spent
remaining = budget - spent
print(remaining)

Expected output:

26500

Section 3.4 · Multiplication *

What it does: Multiplies two numbers.

price_per_sachet = 50    # ₦50 per sachet of pure water
sachets_sold = 200
total_revenue = price_per_sachet * sachets_sold
print(total_revenue)

Expected output:

10000

The * operator also works on strings · it repeats them:

print("Ha" * 3)

Expected output:

HaHaHa

Section 3.5 · Division /

What it does: Divides the first number by the second.

Important: Division in Python always returns a float (a decimal number), even if the result is a whole number.

total_akara = 30
people = 6
each_person_gets = total_akara / people
print(each_person_gets)

Expected output:

5.0

Notice the .0 at the end · that is the float. Even though 30 ÷ 6 = 5 exactly, Python still gives you 5.0.

# Another example showing float result
print(12 / 5)

Expected output:

2.4

Section 3.6 · Modulus %

What it does: Returns the remainder left over after division. This is sometimes called the "modulo" operator.

Think back to primary school long division. When you divide 17 by 5, you get 3 with a remainder of 2. The modulus operator gives you that remainder · which is 2.

print(17 % 5)

Expected output:

2

Real-world examples:

# Sharing yam portions: 25 tubers among 4 families
tubers = 25
families = 4
leftover = tubers % families
print("Leftover tubers:", leftover)

Expected output:

Leftover tubers: 1

# Checking if a number is even (remainder when divided by 2 is 0)
number = 46
print(number % 2)    # Even numbers have remainder 0

Expected output:

0

number = 47
print(number % 2)    # Odd numbers have remainder 1

Expected output:

1

This is one of the most useful tricks in programming · checking whether a number is even or odd by seeing if number % 2 equals 0.

Section 3.7 · Exponentiation **

What it does: Raises a number to a power. In mathematics, this is written as x^y (x to the power of y).

# 2 to the power of 10
print(2 ** 10)

Expected output:

1024

# Area of a square plot of land with side 15 metres
side = 15
area = side ** 2    # Side squared
print("Area:", area, "square metres")

Expected output:

Area: 225 square metres

# Volume of a cube
side = 4
volume = side ** 3
print("Volume:", volume, "cubic metres")

Expected output:

Volume: 64 cubic metres

Section 3.8 · Floor Division //

What it does: Divides and then rounds DOWN to the nearest whole number (integer). This is also called "integer division."

Why it exists: Sometimes you need a whole-number result, not a decimal. For example, if you are distributing items, you cannot give someone half a loaf of bread.

# Regular division — gives a float
print(12 / 5)

Expected output:

2.4

# Floor division — rounds DOWN to an integer
print(12 // 5)

Expected output:

2

Notice that 12 // 5 gives 2, not 3 · it always rounds down, never up.

# Sharing kola nuts: 25 nuts among 4 people
total_kola = 25
guests = 4
per_person = total_kola // guests   # How many each person gets (whole number)
leftover = total_kola % guests      # How many are left over
print("Each person gets:", per_person)
print("Left over:", leftover)

Expected output:

Each person gets: 6
Left over: 1

Thinking Prompt: What is the relationship between // and %? If 25 // 4 = 6, and 6 * 4 = 24, then 25 - 24 = 1, which is exactly what 25 % 4 gives us. Floor division and modulus are two sides of the same coin!

Section 3.9 · Using All Arithmetic Operators Together

x = 15
y = 4

print("Addition:       ", x + y)    # 15 + 4
print("Subtraction:    ", x - y)    # 15 - 4
print("Multiplication: ", x * y)    # 15 × 4
print("Division:       ", x / y)    # 15 ÷ 4
print("Modulus:        ", x % y)    # Remainder of 15 ÷ 4
print("Exponentiation: ", x ** y)   # 15 to the power of 4
print("Floor Division: ", x // y)   # 15 ÷ 4 rounded down

Expected output:

Addition:        19
Subtraction:     11
Multiplication:  60
Division:        3.75
Modulus:         3
Exponentiation:  50625
Floor Division:  3

Section 4.1 · What Is an Assignment Operator?

You have been using the basic assignment operator since Lesson 02:

city = "Abuja"

That = is the assignment operator. It takes the value on the right side and stores it into the variable on the left side.

But Python also gives you shorthand assignment operators that combine arithmetic with assignment. These save you from writing the variable name twice when updating its value.

The problem they solve:

Imagine you have ₦500 in a variable and you want to add ₦200 to it. The long way is:

balance = 500
balance = balance + 200   # Take the old value, add 200, store it back
print(balance)

Expected output:

700

That works, but you have to write balance twice. The shorthand operator += does the same thing more cleanly:

balance = 500
balance += 200    # Same as: balance = balance + 200
print(balance)

Expected output:

700

Section 4.2 · The Complete Assignment Operators Table

Here is every assignment operator Python provides:

The bitwise operators (&=, |=, ^=, >>=, <<=) work on the binary representation of numbers and are used in advanced topics. For now, master the first eight.

Section 4.3 · Each Assignment Operator with Examples

Let us go through each of the main ones with a practical Nigerian example.

= · Basic Assignment

kola_nuts = 30   # Assign 30 to kola_nuts
print(kola_nuts)

Expected output:

30

+= · Add and Assign

You receive more kola nuts in the market:

kola_nuts = 30
kola_nuts += 12   # Someone brings 12 more
print(kola_nuts)

Expected output:

42

+= also works on strings · it appends (adds to the end):

greeting = "Good"
greeting += " morning"
greeting += ", Sade!"
print(greeting)

Expected output:

Good morning, Sade!

-= · Subtract and Assign

Customers buy some items:

stock = 100          # 100 bags of garri in the store
stock -= 35          # 35 bags sold today
print(stock)

Expected output:

65

*= · Multiply and Assign

Price doubles due to market inflation:

price = 800      # ₦800 per kg of beef
price *= 2       # Price doubles
print(price)

Expected output:

1600

/= · Divide and Assign

Splitting a pot of money among partners:

partnership_profit = 900000   # ₦900,000 total profit
partnership_profit /= 3       # Split equally among 3 partners
print(partnership_profit)

Expected output:

300000.0

Note the .0 because /= always produces a float.

%= · Modulus and Assign

Check what is left after packing into complete groups:

akara_count = 47
akara_count %= 10    # How many remain after packing into groups of 10?
print(akara_count)   # 47 = 4 groups of 10, plus 7 remaining

Expected output:

7

//= · Floor Divide and Assign

How many complete cartons can be filled?

bottles = 250
bottles //= 12        # 12 bottles per carton
print(bottles)        # 250 ÷ 12 = 20 complete cartons (with 10 left over)

Expected output:

20

**= · Exponentiate and Assign

Investment grows (this is a simplified model):

investment = 10000    # ₦10,000 invested
investment **= 2      # Just for illustration
print(investment)

Expected output:

100000000

Section 4.4 · The Walrus Operator :=

Python 3.8 introduced the walrus operator :=. Its nickname comes from the fact that := looks a little like a walrus · two eyes (:) and a pair of tusks (=).

What it does: It assigns a value to a variable and uses that value in the same expression · all in one step. Previously, you needed two separate lines.

The old way (two lines):

numbers = [1, 2, 3, 4, 5]
count = len(numbers)          # Line 1: count how many
if count > 3:                 # Line 2: check the count
    print(f"List has {count} elements")

The walrus way (one step):

numbers = [1, 2, 3, 4, 5]
if (count := len(numbers)) > 3:    # Assign AND check in one go
    print(f"List has {count} elements")

Expected output (both examples):

List has 5 elements

Note for beginners: The walrus operator is an advanced feature. You do not need to use it right away. Understand what it does, and you will encounter it when reading other people's code.

Challenge 1

What is the output of the following code?

text = "  Nigerian Naira  "
print(text.strip().upper().replace("NAIRA", "₦"))

Answer:

NIGERIAN ₦

Explanation: strip() removes the spaces, upper() capitalises everything, and replace() swaps the word "NAIRA" with the currency symbol.

Challenge 2

What is the output?

x = 17
x %= 5
x += 1
print(x)

Answer:

3

Explanation: 17 % 5 = 2 (remainder), then 2 + 1 = 3.

Challenge 3

Fill in the blank so the output is "Akara":

foods = "akara,puff-puff,boli,moimoi"
first_item = foods.split(",")[_]
print(first_item.capitalize())

Answer: Replace _ with 0 (the first item in the list is at index 0).

Challenge 4

Write a single line of code that converts "welcome to lagos" to "WELCOME TO LAGOS".

Answer:

print("welcome to lagos".upper())

Mistake 1 · Thinking string methods change the original

Wrong assumption:

name = "emeka"
name.upper()          # This does NOT change name
print(name)           # Still prints "emeka"

Correct approach:

name = "emeka"
name = name.upper()   # Reassign the result back to name
print(name)           # Now prints "EMEKA"

Mistake 2 · Confusing = and ==

= means assign (store a value). == means compare (check if two things are equal).

Wrong:

# This tries to ASSIGN inside a condition — causes an error in most contexts
if score = 90:
    print("Excellent")

Correct:

score = 90            # Assign with =
if score == 90:       # Compare with ==
    print("Excellent")

Mistake 3 · Using / when you want a whole number

apples = 10
people = 3
each_gets = apples / people   # Returns 3.3333...
print(each_gets)

Output:

3.3333333333333335

If you want whole-number division, use //:

each_gets = apples // people   # Returns 3
print(each_gets)

Output:

3

Mistake 4 · Forgetting that find() returns -1, not False

sentence = "I love suya"
result = sentence.find("pizza")

# Beginner mistake: testing result as True/False
if result:
    print("Found!")
else:
    print("Not found")

Output (incorrect logic):

Not found

This accidentally works for -1 because -1 is "truthy" in Python, but 0 is "falsy". If the word appears at position 0, result would be 0, and the if block would incorrectly skip! Always compare explicitly:

if result != -1:
    print("Found!")
else:
    print("Not found")

Mistake 5 · Confusing and *

print(3 * 3)    # 9 — multiplication: 3 × 3
print(3 ** 3)   # 27 — exponentiation: 3³ (3 to the power of 3)

One star = multiply. Two stars = power.

Mistake 6 · Expecting += to work before the variable is defined

# This causes an error: NameError
total += 500    # Python doesn't know what total was before

Correct:

total = 0       # Define the variable first
total += 500    # Now it works