Chapter Introduction and Learning Objectives

Learning Objectives

By the end of this chapter, you should be able to:

1. 1Use random.randint(), random.random(), and random.uniform() to generate random numbers in a specified range.
2. 2Use random.choice(), random.shuffle(), and random.sample() to make random selections from sequences.
3. 3Explain what a seed is and use random.seed() to make random sequences reproducible for testing.
4. 4Use datetime.date to represent and compare calendar dates.
5. 5Format dates as readable strings using strftime() and parse date strings using strptime().
6. 6Calculate durations between dates using subtraction and datetime.timedelta.
7. 7Design and implement a simulation that runs many trials and accumulates results.
8. 8Interpret simulation results as estimates of probability, not exact values.
9. 9Trace programs that use randomness by testing representative cases.

Sections at a Glance

• 24.1Useful Tools from the Standard LibraryWhy this chapter introduces random and datetime; how they relate to the standard library pattern already established in Chapter 15; simulation as technique rather than module
• 24.2Random Numbersrandint, random(), uniform(); tracing programs that use random values; testing with representative cases at boundary conditions
• 24.3Random Choicesrandom.choice(), random.shuffle(), random.sample(); common mistake with shuffle returning None; comparison table of all three functions
• 24.4Simulating Repeated TrialsSimulation structure: parameters → trials → collect → summarize; coin flip simulation; two-dice simulation; why simulation converges toward true probability
• 24.5Randomness and TestingTesting structure vs. value; seeds and reproducibility; when to use seeds; when to remove them; random.seed() syntax
• 24.6Dates and Timesdatetime.date; date.today(); constructing specific dates; reading .year, .month, .day
• 24.7Formatting Datesstrftime() format codes; strptime() for parsing date strings; combining codes with separators
• 24.8Simple Timers and Durationstimedelta; subtracting two dates; adding or subtracting duration from a date; timing code with datetime.datetime.now()
• 24.9Building Simple SimulationsSimulation design pattern; quiz guessing simulation; collecting a distribution with a dictionary; using functions to organize simulation code
• 24.10Interpreting Simulation ResultsResults are approximate; proportion vs. exact probability; expected value; trial count and accuracy; garbage in, garbage out

Useful Tools from the Standard Library

import random
import datetime

Random Numbers

random.randint(a, b)

import random

roll = random.randint(1, 6)
print("You rolled:", roll)

random.random()

import random

chance = random.random()
print(chance)   # something like 0.4732891...

random.uniform(a, b)

import random

temperature = random.uniform(36.1, 37.2)
print(f"Simulated temperature: {temperature:.1f} degrees")

Tracing programs that use random values

Random Choices

random.choice(sequence)

import random

colors = ["red", "green", "blue", "yellow"]
picked = random.choice(colors)
print("Chosen color:", picked)

random.shuffle(list)

import random

questions = ["Q1", "Q2", "Q3", "Q4", "Q5"]
random.shuffle(questions)
print(questions)   # same five items, unpredictable order

random.sample(sequence, k)

import random

students = ["Ana", "Ben", "Cara", "Diego", "Eve", "Finn"]
selected = random.sample(students, 3)
print("Selected:", selected)   # 3 unique names, order varies

Comparing all three functions

Simulating Repeated Trials

import random

trials = 1000
count_of_interest = 0

for i in range(trials):
    # Simulate one trial
    outcome = ...  # some random result
    if outcome # meets some condition:
        count_of_interest += 1

proportion = count_of_interest / trials
print(f"Proportion: {proportion:.3f}")

import random

def flip_coin():
    return random.choice(["heads", "tails"])

trials = 10000
heads_count = 0

for i in range(trials):
    result = flip_coin()
    if result == "heads":
        heads_count += 1

proportion = heads_count / trials
print(f"Heads in {trials} flips: {heads_count}")
print(f"Proportion: {proportion:.3f}")

Heads in 10000 flips: 4987
Proportion: 0.499

import random

def roll_two_dice():
    die1 = random.randint(1, 6)
    die2 = random.randint(1, 6)
    return die1 + die2

trials = 100000
sevens = 0

for i in range(trials):
    total = roll_two_dice()
    if total == 7:
        sevens += 1

print(f"Sevens: {sevens}")
print(f"Proportion: {sevens / trials:.3f}")

Sevens: 16614
Proportion: 0.166

Randomness and Testing

Strategy 1: Test the structure, not the value

import random

result = random.randint(1, 10)
assert 1 <= result <= 10, "Result out of range"

Strategy 2: Use a seed

import random

random.seed(42)
print(random.randint(1, 6))   # same value every run when seed is 42
print(random.randint(1, 6))
print(random.randint(1, 6))

Dates and Times

Getting today's date

import datetime

today = datetime.date.today()
print(today)

2025-03-14

Creating a specific date

import datetime

birthday = datetime.date(2007, 9, 22)   # arguments: (year, month, day)
print(birthday)   # 2007-09-22

Reading parts of a date

import datetime

today = datetime.date.today()
print("Year:",  today.year)
print("Month:", today.month)
print("Day:",   today.day)

Year: 2025
Month: 3
Day: 14

Formatting Dates

Using strftime()

import datetime

today = datetime.date.today()
formatted = today.strftime("%B %d, %Y")
print(formatted)

March 14, 2025

Common format codes

import datetime

d = datetime.date(2025, 9, 22)
print(d.strftime("%A, %B %d, %Y"))   # Monday, September 22, 2025
print(d.strftime("%m/%d/%Y"))          # 09/22/2025
print(d.strftime("%d %b %Y"))           # 22 Sep 2025

Parsing a date string with strptime()

import datetime

date_string = "2025-09-22"
parsed = datetime.datetime.strptime(date_string, "%Y-%m-%d").date()
print(parsed)         # 2025-09-22
print(parsed.year)    # 2025

Simple Timers and Durations

Date arithmetic with timedelta

import datetime

today     = datetime.date.today()
new_year  = datetime.date(2026, 1, 1)
days_away = new_year - today
print(f"Days until New Year: {days_away.days}")

Adding or subtracting time

import datetime

today      = datetime.date.today()
one_week   = datetime.timedelta(days=7)
next_week  = today + one_week
print("Today:",           today)
print("One week from now:", next_week)

# Also works for deadlines
deadline      = datetime.date(2025, 12, 31)
buffer        = datetime.timedelta(days=14)
reminder_date = deadline - buffer
print("Set reminder for:", reminder_date)

Days between two dates

import datetime

start    = datetime.date(2025, 9, 1)
end      = datetime.date(2025, 12, 20)
duration = end - start
print(f"Semester length: {duration.days} days")

Timing program execution

import datetime

start_time = datetime.datetime.now()

# some code that takes time
total = 0
for i in range(10_000_000):
    total += i

end_time = datetime.datetime.now()
elapsed  = end_time - start_time
print(f"Time elapsed: {elapsed}")

Building Simple Simulations

import random

def simulate_quiz(num_questions, num_choices):
    """Simulate a student guessing randomly on every question."""
    correct = 0
    for q in range(num_questions):
        guess  = random.randint(1, num_choices)
        answer = 1   # correct answer is always choice 1
        if guess == answer:
            correct += 1
    return correct

trials        = 10000
total_correct = 0

for t in range(trials):
    total_correct += simulate_quiz(10, 4)

average = total_correct / trials
print(f"Average score from random guessing: {average:.2f} out of 10")
print(f"Expected: 2.50 out of 10")

Average score from random guessing: 2.51 out of 10
Expected: 2.50 out of 10

Collecting a distribution

import random

def simulate_quiz(num_questions, num_choices):
    correct = 0
    for q in range(num_questions):
        if random.randint(1, num_choices) == 1:
            correct += 1
    return correct

trials       = 10000
score_counts = {}

for t in range(trials):
    score = simulate_quiz(10, 4)
    if score not in score_counts:
        score_counts[score] = 0
    score_counts[score] += 1

print("Score | Count | Proportion")
print("------+-------+-----------")
for score in sorted(score_counts):
    count      = score_counts[score]
    proportion = count / trials
    print(f"  {score:2d}  | {count:5d} | {proportion:.3f}")

Score | Count | Proportion
------+-------+-----------
   0  |   563 | 0.056
   1  |  1878 | 0.188
   2  |  2814 | 0.281
   3  |  2499 | 0.250
   4  |  1460 | 0.146
   5  |   561 | 0.056
   6  |   173 | 0.017
   7  |    43 | 0.004
   8  |     8 | 0.001
   9  |     1 | 0.000
  10  |     0 | 0.000

Interpreting Simulation Results

When simulation is most useful

Chapter Summary

• Section 24.1The random and datetime modules are standard-library tools that require no installation. Both follow the same dot-notation pattern as other modules introduced earlier. Simulation is a programming technique, not a module — it uses randomness and loops to observe typical behavior over many trials.
• Section 24.2random.randint(a, b) returns a random integer in [a, b]. random.random() returns a float in [0.0, 1.0). random.uniform(a, b) returns a float in [a, b]. Tracing programs with randomness requires choosing representative values and testing near boundary conditions.
• Section 24.3random.choice(seq) returns one item. random.shuffle(lst) rearranges the list in place and returns None — assigning the result is a common mistake. random.sample(seq, k) returns a new list of k unique items without modifying the original.
• Section 24.4A simulation loops through many trials, uses randomness to model each trial, accumulates a result, and reports a proportion or average. More trials produce results closer to true mathematical probability.
• Section 24.5Testing random programs requires either testing structure (range, type) rather than exact value, or using random.seed(value) to make sequences reproducible. Remove the seed in finished programs when genuine unpredictability is needed.
• Section 24.6datetime.date represents a calendar date. datetime.date.today() returns today's date. datetime.date(year, month, day) creates a specific date. The .year, .month, and .day attributes access individual parts.
• Section 24.7strftime(format) converts a date to a formatted string using codes like %Y, %B, %d, %A. strptime(string, format) parses a date string back into a datetime object.
• Section 24.8Subtracting two date objects produces a timedelta with a .days attribute. Adding or subtracting a timedelta produces a new date in the future or past. datetime.datetime.now() can time code execution.
• Section 24.9Simulations follow a four-step structure: parameters → trials → collect → summarize. Functions keep simulation code organized. Collecting a distribution with a dictionary reveals the shape of results beyond what an average alone shows.
• Section 24.10Simulation results are approximate estimates, not exact probabilities. More trials give better estimates. Proportions estimate probability; averages estimate expected value. A simulation is only as valid as the model it uses — garbage in, garbage out.

Key Terms

Read each block carefully. Answer the questions without running the code.

import random

total = 0
for i in range(5):
    total += random.randint(1, 10)

print(total)

import random

items = ["apple", "banana", "cherry", "date"]
random.shuffle(items)
print(items[0])

import datetime

start = datetime.date(2025, 1, 15)
end   = datetime.date(2025, 3, 15)
gap   = end - start
print(gap.days)

import random

random.seed(99)
values = [random.randint(1, 100) for i in range(4)]
print(values)

random.seed(99)
values2 = [random.randint(1, 100) for i in range(4)]
print(values2)

import random

def roll():
    return random.randint(1, 6)

total = roll() + roll()
if total >= 7:
    print("High roll:", total)
else:
    print("Low roll:", total)

import random

correct = 0
for trial in range(5):
    guess = random.randint(1, 4)
    if guess == 1:
        correct += 1

print(correct)

import datetime

event     = datetime.date(2025, 6, 30)
today     = datetime.date(2025, 6, 10)
days_away = event - today

if days_away.days <= 7:
    print("Coming up soon!")
elif days_away.days <= 30:
    print("This month")
else:
    print("Further out")

Where output depends on randomness, state the possible range or list of possible outputs.

import datetime

d = datetime.date(2025, 11, 28)
print(d.strftime("%A, %B %d"))

import random

random.seed(7)
choices = random.sample([10, 20, 30, 40, 50], 3)
print(len(choices))
print(type(choices))

import datetime

today     = datetime.date(2025, 3, 1)
delta     = datetime.timedelta(days=365)
next_year = today + delta
print(next_year)

import random

items = ["red", "blue"]
for i in range(3):
    print(random.choice(items))

Each program below contains an error. Identify the error, explain what it causes, and write the corrected version.

import random

cards = ["A", "2", "3", "4", "5", "J", "Q", "K"]
cards = random.shuffle(cards)
print(cards[0])

import datetime

birthday = datetime.date(1998, 13, 5)
print(birthday)

import random

total = 0
for i in range(10):
    total = random.randint(1, 6)

print("Total:", total)

import datetime

date1 = datetime.date(2025, 5, 1)
date2 = datetime.date(2025, 8, 15)
gap   = date1 - date2
print("Days:", gap.days)

import random

random.seed(42)
result = random.choice([])
print(result)

Write clean, readable code with clear variable names.

1. Random password component. Write a program that uses random.choice() and a string of characters to generate a random 8-character password component. Include at least letters and digits in your character set. Print the result. Hint: build the result by iterating 8 times and appending each random character to a growing string.
2. Birthday countdown. Ask the user to enter an upcoming birthday in the format YYYY-MM-DD. Parse it into a datetime.date object. Calculate how many days until that birthday and print a message. Handle the case where the entered date is in the past with a clear message.
3. Shuffle and deal. Create a list representing a simplified deck using labels like "2H", "KS", "AS" for 13 cards in one suit, or simply numbers 1–52. Shuffle the deck and print the first 5 cards as a hand.
4. Day of the week finder. Ask the user to enter a date in the format MM/DD/YYYY. Convert it to a datetime.date object and print which day of the week that date falls on.
5. Random sample quiz selector. Create a list of at least 10 quiz questions as strings. Use random.sample() to select 5 questions. Print the selected 5, numbered 1 through 5.
6. Biased coin simulation. A biased coin lands heads 70% of the time and tails 30%. Simulate 10,000 flips and report the proportion of heads and tails. Hint: use random.random() and check if the result is less than 0.70.

Example session

=== Flashcard Session ===
Date: March 14, 2025

Card 1 of 8
Question: What keyword defines a function in Python?
Your answer: def
Answer: def
Correct? (y/n): y

Card 2 of 8
Question: What does len() return for an empty list?
Your answer: 0
Answer: 0
Correct? (y/n): y

...

=== Session Summary ===
Date: March 14, 2025
Cards studied: 8
Correct: 6
Score: 75.0%

Optional extensions

1. Save the session result (date, score, total) to a text file and load it at the start to show the student's history across multiple sessions.
2. Repeat missed cards at the end of the session before showing the final summary.
3. Let the user choose how many cards to study using random.sample() instead of always showing all cards.

Planning guide

1. pick_winner and run_giveaway. Write a function called pick_winner(names) that takes a list of names and returns one randomly selected name. Write a second function called run_giveaway(names, num_winners) that uses random.sample() to select multiple unique winners. Test both functions with a list of at least 6 names.
2. Sort dates from a file. Write a program that reads a list of dates from a text file (one date per line in YYYY-MM-DD format), converts each to a datetime.date object, and prints the dates in chronological order from earliest to latest. Hint: datetime.date objects support comparison operators like < and >, so you can sort a list of them.
3. simulate_guessing function. Write a function simulate_guessing(num_questions, num_choices, trials) that simulates a student guessing randomly on a quiz for the given number of trials and returns the average score as a float. Test it with several different values of num_questions and num_choices and print the results in a table.
4. Random date generator. Write a program that generates a random date within a given year and prints it in a readable format. Ask the user for the year. Use random.randint() to pick a month (1–12) and a day. To keep it simple, allow only days 1–28 (valid for every month), or handle different month lengths for a greater challenge.

Recall and Vocabulary

1. What is the difference between random.choice() and random.sample()?
2. Why does random.shuffle() return None instead of the shuffled list?
3. What is a seed, and why would you use one?
4. What does datetime.date.today() return? What type is the result?
5. What is the difference between strftime() and strptime()?
6. If you subtract two datetime.date objects, what type is the result? How do you get the number of days from it?
7. What does it mean for a simulation result to be approximate? Why does increasing the number of trials improve accuracy?

Understanding and Explanation

8. Describe a situation where simulation would give you useful information that simple arithmetic could not easily provide. Explain why simulation is the better approach in that situation.
9. A student writes this code to shuffle a list and pick the first item:
   Python — contains an error

   cards = ["A", "B", "C", "D"]
   picked = random.shuffle(cards)
   print(picked[0])

   What error will occur? What is the correct way to write this?
10. You run a simulation 100 times and find that an event occurs 23 times. You run the same simulation again and find it occurs 31 times. Is this a sign that something is wrong? Explain.
11. What does "garbage in, garbage out" mean in the context of simulation? Give a concrete example.

Application and Design

12. A board game uses three six-sided dice and rewards players who roll triples (all three dice show the same number). Design a simulation to estimate the probability of rolling triples. Write out the structure in pseudocode before writing Python. How many trials would you use, and why?
13. You want to test a function called deal_card(deck) that removes and returns a random card from a list. What would you test using assert statements? List at least three things you could check without knowing the exact card drawn.
14. A teacher wants a program that randomly assigns 24 students to 6 groups of 4. Describe which random function you would use and why. Write the key line of Python that performs the selection. What happens if the class has 25 students?