Learning If-Else by Inventing Branching Logic

Import the libraries used throughout this chapter.

import random
import matplotlib.pyplot as plt

random.random() returns a random decimal number between 0 (inclusive) and 1 (exclusive) — something like 0.3741....

Before coding:

1. If you multiply a number in [0, 1) by 6, what range does the result fall in?
2. If you then take the integer part (int(...)), what range of whole numbers do you get?
3. How would you shift that range so it becomes 1 to 6 instead of 0 to 5 — like a die?

Your derivation:

• random.random() * 6 is in the range: ...
• int(random.random() * 6) is in the range: ...
• To shift to 1--6: ...

Write a function roll_die() that returns a random integer between 1 and 6 (inclusive), using only random.random() — no if needed yet, just the expression you derived above.

Run it a bunch of times to make sure you only ever see 1 through 6.

def roll_die():
    """
    Returns a random integer between 1 and 6 (inclusive).
    """
    pass  # replace this


for _ in range(20):
    print(roll_die(), end=" ")

Now for an actual decision. random.random() < 0.5 is True about half the time, False the other half.

Write a function coin_toss() that returns the string "Heads" or "Tails", using an if/else on random.random() < 0.5.

Tasks:

1. Implement coin_toss().
2. Call it 20 times and print the results.
3. Call it 10,000 times and count how many times you got "Heads". Is it close to 5,000?

def coin_toss():
    """
    Returns "Heads" or "Tails", each with roughly 50% probability.
    """
    pass  # replace this


print([coin_toss() for _ in range(20)])

heads_count = 0
for _ in range(10000):
    if coin_toss() == "Heads":
        heads_count = heads_count  # fill in: count heads
print(f"Heads: {heads_count} / 10000")

if/else only gives you two outcomes. if/elif/else gives you more.

Write a function classify_roll(n) that takes a die result n (1 through 6) and returns:

• "Low" if n is 1 or 2
• "Mid" if n is 3 or 4
• "High" if n is 5 or 6

Tasks:

1. Implement it using if/elif/else.
2. Roll the die 20 times with roll_die() and classify each result. Print both the roll and its class.

def classify_roll(n):
    """
    Returns "Low" (1-2), "Mid" (3-4), or "High" (5-6).
    """
    pass  # replace this


for _ in range(20):
    n = roll_die()
    print(f"{n} -> {classify_roll(n)}")

You're given three points on a 2D plane: P, A, and B. You want to know whether P is closer to A or to B.

You could compute the real distances (with a square root), but for comparing two distances, you don't need to — the one with the smaller squared distance is also the one with the smaller actual distance. (Square root is increasing, so it never flips the order.)

Before coding:

For P=(1, 2), A=(0, 0), B=(5, 5):

1. Compute the squared distance from P to A: (px - ax)**2 + (py - ay)**2.
2. Compute the squared distance from P to B.
3. Which is smaller? So which point is P closer to?

Your derivation:

• squared distance P to A: ...
• squared distance P to B: ...
• closer point: ...

Write a function closer_point(p, a, b) where p, a, b are each (x, y) tuples. It should return:

• 'A' if p is closer to a
• 'B' if p is closer to b
• 'Equal' if the distances are the same

This needs a three-way branch — if/elif/else.

Example:

closer_point((1, 2), (0, 0), (5, 5))     # Output: 'A'
closer_point((4, 4), (0, 0), (8, 8))     # Output: 'Equal'
closer_point((7, 3), (2, 3), (10, 3))    # Output: 'B'

def closer_point(p, a, b):
    """
    p, a, b are (x, y) tuples.
    Returns 'A' if p is closer to a, 'B' if closer to b, 'Equal' if tied.
    """
    pass  # replace this


print(closer_point((1, 2), (0, 0), (5, 5)))     # A
print(closer_point((4, 4), (0, 0), (8, 8)))     # Equal
print(closer_point((7, 3), (2, 3), (10, 3)))    # B

Tasks:

1. Pick three new points where you can predict the answer just by sketching them on paper. Verify your function agrees.
2. Pick a point exactly halfway between A and B. What does closer_point say?

print(closer_point((0, 0), (-10, 0), (10, 0)))   # halfway -> ?
print(closer_point((3, 0), (0, 0), (10, 10)))

On a number line, you have two points a and b, and a third point p. You want to know if p lies between a and b (including the endpoints).

The tricky part: you're not told whether a < b or a > b.

Before coding:

1. If a = 5 and b = 2, what are the actual lower and upper bounds of the segment?
2. Python's built-in min() and max() can take two arguments. How would you use them to get the lower and upper bounds regardless of which of a, b is bigger?

Your derivation:

• lower bound = ...
• upper bound = ...

Write is_point_on_line_1d(a, b, p) that returns True if p lies between a and b (inclusive), regardless of which of a, b is larger.

Example:

is_point_on_line_1d(2, 5, 3)      # Output: True
is_point_on_line_1d(5, 2, 3)      # Output: True   (order doesn't matter)
is_point_on_line_1d(2, 5, 6)      # Output: False
is_point_on_line_1d(4, 4, 4)      # Output: True   (a single point)
is_point_on_line_1d(4, 4, 5)      # Output: False

def is_point_on_line_1d(a, b, p):
    """
    Returns True if p lies between a and b (inclusive), regardless of order.
    """
    pass  # replace this


print(is_point_on_line_1d(2, 5, 3))      # True
print(is_point_on_line_1d(5, 2, 3))      # True
print(is_point_on_line_1d(2, 5, 6))      # False
print(is_point_on_line_1d(4, 4, 4))      # True
print(is_point_on_line_1d(4, 4, 5))      # False

A good function shouldn't need special-casing for negative numbers if the logic is right.

Tasks: test is_point_on_line_1d on these and check the results match the comments.

is_point_on_line_1d(-5, -2, -3)   # Output: True
is_point_on_line_1d(-5, -2, -6)   # Output: False
is_point_on_line_1d(-2, -5, -4)   # Output: True
is_point_on_line_1d(-1, 3, 0)     # Output: True

print(is_point_on_line_1d(-5, -2, -3))   # True
print(is_point_on_line_1d(-5, -2, -6))   # False
print(is_point_on_line_1d(-2, -5, -4))   # True
print(is_point_on_line_1d(-1, 3, 0))     # True

You now have two segments on the number line: segment 1 from start1 to end1, and segment 2 from start2 to end2 (and again, you can't assume start < end for either one).

It's easier to reason about when they're completely separate first, then negate it.

Before coding:

1. After sorting each segment so you know its true lo and hi, when is segment 1 entirely to the left of segment 2? Write the condition.
2. When is segment 1 entirely to the right of segment 2?
3. The segments touch or overlap exactly when neither of those is true. Using not and or (or by flipping the logic directly), write the combined condition for "touching or overlapping".

Your derivation:

• segment 1 entirely left of segment 2 when: ...
• segment 1 entirely right of segment 2 when: ...
• touching or overlapping when: ...

Write are_lines_touching_or_overlapping(start1, end1, start2, end2) that returns True if the two segments touch or overlap, False if they're completely separate. Remember to handle the case where start > end for either segment, just like in Part 3.

Example:

are_lines_touching_or_overlapping(1, 4, 3, 6)        # Output: True   (overlap 3 to 4)
are_lines_touching_or_overlapping(1, 3, 3, 5)        # Output: True   (touch at 3)
are_lines_touching_or_overlapping(1, 2, 3, 4)        # Output: False  (separate)

def are_lines_touching_or_overlapping(start1, end1, start2, end2):
    """
    Returns True if the 1D segments [start1, end1] and [start2, end2]
    touch or overlap, False if they are completely separate.
    Works regardless of whether start < end for either segment.
    """
    pass  # replace this


print(are_lines_touching_or_overlapping(1, 4, 3, 6))        # True
print(are_lines_touching_or_overlapping(1, 3, 3, 5))        # True
print(are_lines_touching_or_overlapping(1, 2, 3, 4))        # False

Tasks: verify these all match the comments — pay special attention to the last one, where both segments are given "backwards".

are_lines_touching_or_overlapping(-3, 1, 0, 4)       # Output: True   (overlap 0 to 1)
are_lines_touching_or_overlapping(-5, -2, -2, 3)     # Output: True   (touch at -2)
are_lines_touching_or_overlapping(-10, -6, -5, -1)   # Output: False  (no touch or overlap)
are_lines_touching_or_overlapping(-2, -7, -4, -3)    # Output: True   (overlap, even with reversed inputs)

print(are_lines_touching_or_overlapping(-3, 1, 0, 4))       # True
print(are_lines_touching_or_overlapping(-5, -2, -2, 3))     # True
print(are_lines_touching_or_overlapping(-10, -6, -5, -1))   # False
print(are_lines_touching_or_overlapping(-2, -7, -4, -3))    # True

A rectangle with sides parallel to the axes is defined by its bottom-left corner (x1, y1) and top-right corner (x2, y2) (with x1 < x2 and y1 < y2). A point (px, py) is inside it if its x is between x1 and x2, and its y is between y1 and y2.

Look closely — "is px between x1 and x2" is exactly the function you wrote in Part 3!

Before coding: write out, in words, how is_point_inside_rectangle could be built using two calls to is_point_on_line_1d instead of writing brand-new comparison logic.

Your plan:

is_point_inside_rectangle(x1, y1, x2, y2, px, py) = is_point_on_line_1d(...) and is_point_on_line_1d(...)

Write is_point_inside_rectangle(x1, y1, x2, y2, px, py) by reusing is_point_on_line_1d — don't rewrite the comparison logic from scratch.

Example:

is_point_inside_rectangle(0, 0, 10, 5, 3, 2)   # Output: True
is_point_inside_rectangle(0, 0, 10, 5, 10, 5)  # Output: True  (on the corner)
is_point_inside_rectangle(0, 0, 10, 5, 11, 5)  # Output: False
is_point_inside_rectangle(-5, -5, 5, 5, 0, 0)  # Output: True

def is_point_inside_rectangle(x1, y1, x2, y2, px, py):
    """
    Returns True if (px, py) is inside or on the boundary of the rectangle
    with bottom-left (x1, y1) and top-right (x2, y2).
    Reuses is_point_on_line_1d for each axis.
    """
    pass  # replace this


print(is_point_inside_rectangle(0, 0, 10, 5, 3, 2))    # True
print(is_point_inside_rectangle(0, 0, 10, 5, 10, 5))   # True
print(is_point_inside_rectangle(0, 0, 10, 5, 11, 5))   # False
print(is_point_inside_rectangle(-5, -5, 5, 5, 0, 0))   # True

Use the plotting helper below to see a rectangle and a point together, colour-coded by whether the point is inside.

Tasks: Try a few of your own points and rectangles to build intuition.

plot_rectangle_and_point(0, 0, 10, 5, 3, 2)
plot_rectangle_and_point(0, 0, 10, 5, 11, 5)

def plot_rectangle_and_point(x1, y1, x2, y2, px, py, title=None):
    inside = is_point_inside_rectangle(x1, y1, x2, y2, px, py)
    fig, ax = plt.subplots(figsize=(5, 5))
    ax.add_patch(plt.Rectangle((x1, y1), x2 - x1, y2 - y1,
                                fill=False, edgecolor='blue', linewidth=2))
    ax.scatter([px], [py], color='green' if inside else 'red', s=100, zorder=5)
    margin = max(x2 - x1, y2 - y1) * 0.3 + 1
    ax.set_xlim(min(x1, px) - margin, max(x2, px) + margin)
    ax.set_ylim(min(y1, py) - margin, max(y2, py) + margin)
    ax.set_aspect('equal')
    ax.set_title(title or f"Inside: {inside}")
    ax.grid(True)
    plt.show()

A rectangle is just two independent ranges glued together: an x-range and a y-range. Two rectangles intersect exactly when their x-ranges touch/overlap and their y-ranges touch/overlap.

This is the same trick as Part 5 — except now you reuse the Part 4 function (segment overlap) instead of the Part 3 function (point between).

A rectangle here is represented as ((x1, y1), (x2, y2)) — bottom-left and top-right corners.

Before coding: write out, in words, how are_rectangles_intersecting(rect1, rect2) could be built using two calls to are_lines_touching_or_overlapping — one for the x-coordinates of both rectangles, one for the y-coordinates.

Your plan:

are_rectangles_intersecting(rect1, rect2) = are_lines_touching_or_overlapping(...) and are_lines_touching_or_overlapping(...)

Write are_rectangles_intersecting(rect1, rect2) by reusing are_lines_touching_or_overlapping on the x-coordinates and on the y-coordinates.

Example:

are_rectangles_intersecting(((0, 0), (3, 3)), ((2, 2), (5, 5)))   # Output: True
are_rectangles_intersecting(((0, 0), (1, 1)), ((2, 2), (3, 3)))   # Output: False
are_rectangles_intersecting(((0, 0), (2, 2)), ((2, 2), (4, 4)))   # Output: True  (touching at a corner)
are_rectangles_intersecting(((0, 0), (5, 5)), ((1, 1), (2, 2)))   # Output: True  (one inside another)

def are_rectangles_intersecting(rect1, rect2):
    """
    rect1, rect2 are each ((x1, y1), (x2, y2)) - bottom-left, top-right corners.
    Returns True if the two rectangles touch or overlap.
    Reuses are_lines_touching_or_overlapping for each axis.
    """
    pass  # replace this


print(are_rectangles_intersecting(((0, 0), (3, 3)), ((2, 2), (5, 5))))   # True
print(are_rectangles_intersecting(((0, 0), (1, 1)), ((2, 2), (3, 3))))   # False
print(are_rectangles_intersecting(((0, 0), (2, 2)), ((2, 2), (4, 4))))   # True
print(are_rectangles_intersecting(((0, 0), (5, 5)), ((1, 1), (2, 2))))   # True

Use the plotting helper below to see both rectangles, colour-coded by whether they intersect.

Tasks: Try a few of your own rectangle pairs to build intuition.

plot_rectangles(((0, 0), (3, 3)), ((2, 2), (5, 5)))
plot_rectangles(((0, 0), (1, 1)), ((2, 2), (3, 3)))

def plot_rectangles(rect1, rect2, title=None):
    intersecting = are_rectangles_intersecting(rect1, rect2)
    color = 'green' if intersecting else 'red'
    fig, ax = plt.subplots(figsize=(5, 5))
    for rect, style in [(rect1, '-'), (rect2, '--')]:
        (x1, y1), (x2, y2) = rect
        ax.add_patch(plt.Rectangle((x1, y1), x2 - x1, y2 - y1,
                                    fill=False, edgecolor=color, linewidth=2, linestyle=style))
    all_x = [rect1[0][0], rect1[1][0], rect2[0][0], rect2[1][0]]
    all_y = [rect1[0][1], rect1[1][1], rect2[0][1], rect2[1][1]]
    margin = max(max(all_x) - min(all_x), max(all_y) - min(all_y)) * 0.3 + 1
    ax.set_xlim(min(all_x) - margin, max(all_x) + margin)
    ax.set_ylim(min(all_y) - margin, max(all_y) + margin)
    ax.set_aspect('equal')
    ax.set_title(title or f"Intersecting: {intersecting}")
    ax.grid(True)
    plt.show()

In machine learning (you'll meet this properly in the Decision Trees chapter), we often need a number that says how "mixed" a set is between two classes.

Write my_impurity(c1, c2) where c1 and c2 are counts (not fractions) of two classes. Your formula must satisfy:

1. If c1 = 0 or c2 = 0 (all one class), impurity should be 0.
2. Impurity should increase as the counts become more evenly balanced.
3. Impurity should be maximum when c1 == c2.

There's no single right answer — invent a formula, test it against the three conditions, and adjust if it doesn't satisfy them. (One possible formula: (2 * min(c1, c2)) / (c1 + c2).)

def my_impurity(c1, c2):
    pass


for c1, c2 in [(0, 5), (5, 5), (7, 3), (9, 1)]:
    print(f"my_impurity({c1}, {c2}) = {my_impurity(c1, c2)}")

You generalised "point between two numbers" into "point inside a rectangle" by checking the x-axis and y-axis independently. Push it one step further.

A 3D box is ((x1, y1, z1), (x2, y2, z2)) — its two opposite corners. Write are_boxes_intersecting(box1, box2) by reusing are_lines_touching_or_overlapping three times — once per axis.

def are_boxes_intersecting(box1, box2):
    pass

Take a moment to answer these questions in your own words.

1. What's the difference between if/else and if/elif/else? When do you need the second form?
2. Why is comparing squared distances enough, without ever computing a square root?
3. In Part 3, why did you need min()/max() instead of just assuming a < b?
4. What was the key trick that let you turn the 1D "is point between" function into the 2D "is point inside a rectangle" function?
5. What was the key trick that let you turn the 1D "segments overlap" function into the 2D "rectangles intersect" function?
6. In your own words: what general strategy do Parts 5 and 6 both use to turn a 2D (or 3D) problem into something easier?