The math & random Modules, and Nested Loops

A module is a file of code you can use in your program. Python includes many modules, but you have to import one before you can use it.

import math
print(math.sqrt(16))    # module name, a dot, then the function

from math import sqrt, pi
print(sqrt(16))         # no "math." needed
print(pi)

• Put your import lines at the top of the program.
• The dot in math.sqrt means "the sqrt that lives inside math."
• In this class, use Way 1 unless your teacher says otherwise. It is clear where each function comes from.

What Python does with math.sqrt(16)

1. It finds the name math. This only works because import math already ran.
2. It follows the dot and looks inside math for a tool named sqrt.
3. It calls sqrt, sending it the argument 16.
4. sqrt works out the answer and returns 4.0. That value takes the place of math.sqrt(16), so print shows 4.0.

Why do we need to import at all?

Python has hundreds of modules. If it loaded all of them every time, every program would start slowly and use extra memory. So Python starts with only the basics, like print, len, and range, and you ask for anything extra with import.

Uncheck the box to remove the import line, then run it.

Reading the error

Without the import, Python stops with NameError: name 'math' is not defined. A NameError means "you used a name I have never heard of." Python reads your program top to bottom, and nothing above that line created the name math.

Python 3.13 adds a hint: Did you forget to import 'math'? Always read the last line of an error first. It tells you the kind of error and usually points straight at the fix.

Pick a function and type a number. Python works it out instantly.

• Try sqrt with 2, 81, and -9. What happens with a negative number?
• Try ceil and floor with 3.2, 3.8, and -3.2.
• Try pow with 2 and 8, then 9 and 0.5. (A power of 0.5 is the same as a square root!)
• Try fabs with -12.5 and 12.5.

Why does a power of 0.5 give a square root?

Raising to the power 0.5 means "find the number that, multiplied by itself, gives x." That is exactly what a square root is. So math.pow(9, 0.5) and math.sqrt(9) both give 3.0. You will see this again in algebra as x^1/2.

Why so many decimal places?

Most square roots go on forever without repeating. A float can only hold about 16 significant digits, so Python shows as many as it can store. To show fewer, wrap the answer in round(): round(math.sqrt(2), 2) is 1.41.

Picture a number line. ceil (ceiling) moves up to the next whole number. floor moves down.

Real use: 23 students need buses that hold 10 each. math.ceil(23 / 10) is 3 buses. You cannot rent 2.3 buses!

The opposite question: how many buses can be completely full? math.floor(23 / 10) is 2. Ask yourself, "Do I need room for the leftovers (ceil), or only the full groups (floor)?"

This program finds the area of a circle and the long side of a right triangle.

• Area of a circle: pi times the radius squared: math.pi * radius ** 2
• Pythagorean theorem: c = math.sqrt(a ** 2 + b ** 2)

The ** operator also raises to a power. radius ** 2 and math.pow(radius, 2) give the same value, except that math.pow always gives a float.

Order of operations still applies

In math.pi * radius ** 2, Python does the ** first, then the *, just like PEMDAS. Only the radius is squared, not pi times the radius. If you want something done first, add parentheses.

Step by step with radius = 3, a = 3, b = 4

area = math.pi * radius ** 2
#    = math.pi * 9               radius ** 2 first
#    = 28.274333882308138        then multiply by pi

c = math.sqrt(a ** 2 + b ** 2)
#  = math.sqrt(9 + 16)           square each side
#  = math.sqrt(25)               add inside the parentheses
#  = 5.0                         the sqrt runs last

Python always works from the inside out: everything inside the parentheses of math.sqrt( ) is finished first, and only then is the square root taken.

Cleaner output: print("Circle area:", round(area, 2)) shows 28.27 instead of fifteen decimal places.

Sort them by what they work on

• Make a number: randint, randrange, and random. You give a range (or nothing), and you get one number back.
• Work with a list: choice, shuffle, and sample. You give a list (or string), and you get items from it.

Why have both randint and randrange?

randint reads like everyday speech: "a number from 1 to 6." randrange matches range(), which makes it handy for list positions. A list with 5 items has indexes 0 to 4, and random.randrange(5) gives exactly 0, 1, 2, 3, or 4. It can also take a step: random.randrange(0, 101, 10) picks from 0, 10, 20, ..., 100.

Every call is a fresh pick

Each time a line with random runs, Python makes a new pick. It does not remember earlier results and it does not try to "even things out," so rolling a 6 twice in a row is completely normal.

Need a decimal in a bigger range?

random.random() only goes from 0.0 to 1.0, but you can stretch it: random.random() * 10 gives a decimal from 0.0 up to (not including) 10.0.

This program rolls a die several times using a loop and random.randint.

• Run it a few times. The numbers change every time.
• Change sides to 20 for a twenty-sided die.
• The loop variable roll counts the rolls, and randint makes each result.

Want the same "random" numbers every time? Programmers testing a game sometimes add random.seed(42) near the top. Starting the formula from the same seed gives the same sequence on every run, which makes bugs easier to repeat. Remove it when you want real variety again.

Line by line

1. import random loads the random module once.
2. sides = 6 stores how many faces the die has, so you can change it in one place.
3. for roll in range(1, 5 + 1): runs the body 5 times. The + 1 is there because range stops before its stop value, so roll goes 1, 2, 3, 4, 5.
4. result = random.randint(1, sides) runs again on every pass of the loop, so each roll gets a new number.
5. print("Roll", roll, "->", result) shows which roll it was and what came up.

random.choice(seq)

Picks one item from a list or string. Each item has the same chance.

moves = ["rock", "paper", "scissors"]
computer = random.choice(moves)

random.random()

Gives a decimal from 0.0 up to, but not including, 1.0. It is handy for chances and percents:

if random.random() < 0.25:   # about a 25% chance
    print("Rare item found!")

choice works on strings too

A string is a sequence of characters, so random.choice("aeiou") picks one random vowel. It gives back one item, not a list.

Why does random() < 0.25 mean a 25% chance?

Picture a ruler from 0.0 to 1.0. random.random() lands anywhere on it with equal chance. The part from 0.0 to 0.25 is one quarter of the ruler, so about one call in four lands there. Change 0.25 to 0.10 for a 10% chance, or 0.5 for a coin flip.

Several outcomes from one number

Save the random number once, then check it with if / elif:

r = random.random()
if r < 0.60:
    print("Common")       # 60% of the time
elif r < 0.90:
    print("Uncommon")     # 0.60 to 0.90: 30%
else:
    print("Rare")         # the last 10%

Use r in every check. If you called random.random() again in the elif, you would be rolling a brand new number and the percentages would come out wrong.

What does "in place" mean?

"In place" means the function rearranges the very same list you gave it. There is no second copy. Since the original list already holds the new order, shuffle has nothing to hand back, so it returns None (Python's way of saying "no value").

Why can't you shuffle a string?

Strings cannot be changed after they are made, and shuffle works by changing things. sample does not change anything, so it works: random.sample("abc", 2) gives a list such as ['c', 'b'].

Want a mixed-up copy and keep the original?

Sample every item: mixed = random.sample(cards, len(cards)). Now mixed is shuffled and cards is unchanged.

About repeats: sample never picks the same position twice. If the list itself has duplicates, like ["red", "red", "blue"], you can still get "red" twice.

Step through this and watch cards in the Variables box. Notice that sample leaves it alone, and shuffle changes it.

Pick a call and run it many times. The tally shows how often each result came up.

• Compare randint(1, 6) with randrange(1, 6). Does a 6 ever show up for randrange?
• Try randrange(0, 10, 2). Which numbers can it make?
• Run sample(range(1, 50), 6). Do you ever see the same number twice in one result?

More runs, smoother bars

With only 10 runs the bars can look very uneven: one number might show up 4 times and another not at all. With 100 or more runs the bars get closer to the same height. The more times you repeat a random experiment, the closer the results get to the "fair" share. This is why games and scientists test with many runs, not just one or two.

How randrange(0, 10, 2) works

Like range(0, 10, 2), it starts at 0, counts by 2, and stops before 10. The only possible values are 0, 2, 4, 6, and 8. It picks one of those each time.

A nested loop is a loop inside the body of another loop.

for hour in range(1, 3):          # outer loop
    for minute in range(0, 3):    # inner loop
        print(hour, ":", minute)

• The inner loop runs all the way through every time the outer loop runs once.
• The inner loop is indented 4 more spaces, and its body 4 more again.
• Total runs of the inner body = (outer count) × (inner count). Here: 2 × 3 = 6.

1 : 0
1 : 1
1 : 2
2 : 0
2 : 1
2 : 2

Notice: while the inner loop is running, hour stays exactly the same. The outer variable only changes after the inner loop has used up all its values.

Counting runs: the outer loop body runs 2 times. The inner loop body runs 3 times for each of those, so 2 × 3 = 6 times total. With 10 outer and 10 inner, the inner body runs 100 times. Nested loops can do a lot of work quickly!

Indentation is how Python knows what is nested. The inner for line is indented under the outer one, so it belongs to the outer loop's body. The print is indented again, so it belongs to the inner loop's body.

Three levels of indentation, three different jobs

• print("row", row, "col", col) is indented 8 spaces, inside the inner loop. It runs rows × cols times.
• print("--- end of row", row) is indented 4 spaces, inside the outer loop but after the inner loop. It runs once per row, so rows times.
• print("Done!") has no indentation. It is outside both loops, so it runs once, at the very end.

Hint for the challenge: add up all three kinds of lines, not only the inner ones.

What to watch while you Step

• The highlighted line jumps back up to the inner for after each inner print. That is the inner loop repeating.
• After the last col, the highlight drops to the "end of row" line, then jumps back to the outer for.
• When row changes, col goes back to 1. The inner loop always starts fresh because its for line runs again from the top.

Times table

The inner loop prints one row with end="\t" (a tab). The plain print() after the inner loop ends the row.

Star triangle

Here the inner loop's range depends on the outer variable: row 1 gets 1 star, row 2 gets 2 stars, and so on.

What end= does

Normally print finishes by moving to a new line. The end= option replaces that new line with something else:

• end="\t" puts a tab after the value, so numbers line up in columns.
• end="" puts nothing after it, so the stars sit right next to each other.
• An empty print() prints nothing but the new line, which ends the current row.

In the times table, the value printed is i * j: the row number times the column number. Row 3, column 4 shows 12.

Tracing the star triangle (rows = 4)

Because the inner loop uses range(i), it gets longer each row. Total stars = 1 + 2 + 3 + 4 = 10, not 4 × 4. The "multiply the counts" rule only works when the inner loop is the same size every time.

Challenge: how could you make the triangle upside down? (Hint: what if the inner range used rows - i + 1?)

Each player rolls a die 3 times, and their rolls are added up.

• The outer loop goes through each player in a list.
• total = 0 sits inside the outer loop, so each player starts fresh.
• The inner loop rolls 3 times and adds each roll.

The accumulator pattern

An accumulator is a variable that collects a running total. It always has three parts:

1. Start it at zero: total = 0
2. Add to it inside a loop: total += random.randint(1, 6) (short for total = total + ...)
3. Use it after the loop is done: print(player, ..., total)

Where you put each part decides what gets totaled. Start it inside the outer loop for one total per player. Start it above both loops for one grand total.

One possible run, traced

Your rolls will be different, but the pattern is the same. Notice the print is indented 4 spaces, at the outer level, so it runs once per player after all 3 rolls. If it were indented 8 spaces you would see a running total after every single roll.