Fixing a Python while-else mistake: the self-comparison bug that hides your final if in a dice game

Why a Python while-else isn’t to blame when the final if won’t run: a dice game shows a self-comparison bug and the fix: compare p1_points to p2_points.

Debugging a Python while–else that “skips” an if: a simple dice game case study

What’s going wrong

You build a two‑player dice rolling game, loop over a chosen number of rounds, and then decide the winner. Everything runs, but the final if block after the while never prints the expected result. The suspicion falls on the while–else. In reality, the issue is simpler: a self‑comparison in the final condition that can never be true.

Problematic example

The snippet below mirrors the original logic and control flow, including the bug that prevents the winner from being announced. Names are changed for clarity, but the behavior is the same.

import random

# Pretend these are set up earlier from a file, etc.
seen_count = 0  # how many times "game" appeared before
token = "game"
next_game = seen_count + 1

p1_points = 0
p2_points = 0


def play_round():
    global p1_points, p2_points
    p1_roll = random.randint(0, 20)
    p2_roll = random.randint(0, 20)
    print("player 1 rolled", p1_roll)
    print("player 2 rolled", p2_roll)

    if p1_roll > p2_roll:
        print("Player 1 Wins!!" + "\n")
        p1_points += 1
    elif p1_roll < p2_roll:
        print("Player 2 Wins!!" + "\n")
        p2_points += 1
    else:
        print("It's a Tie!!" + "\n")


def run_match():
    global p1_points, p2_points
    total_rounds = int(input('How many rounds do you want?: '))
    limit = total_rounds
    idx = 0
    while idx < limit:
        play_round()
        idx += 1
    else:
        # BUG: comparing p1_points with itself
        if p1_points > p1_points:
            print("Player 1 Wins Game", seen_count)
        elif p1_points < p1_points:
            print("Player 2 Wins Game", seen_count)

Why the if never triggers

The core issue is the final comparison. The condition checks p1_points against p1_points, not against p2_points. A value cannot be greater than itself, and it cannot be less than itself. Both comparisons are always false, so nothing prints. The while–else construct isn’t the culprit here. The else block of a while runs when the loop finishes without a break. Because there is no break at all, the else will always run, but the comparisons inside it are simply impossible to satisfy.

There’s a second mismatch: the displayed game index is taken from seen_count, which represents the number of past occurrences of the word “game” in a file, while the intention is to print the upcoming game number. That should use seen_count + 1.

The fix

Compare the two players’ totals, not a value to itself, and use the next game number when printing. The rest of the flow remains the same.

def run_match():
    global p1_points, p2_points
    total_rounds = int(input('How many rounds do you want?: '))
    limit = total_rounds
    idx = 0
    while idx < limit:
        play_round()
        idx += 1
    else:
        if p1_points > p2_points:
            print("Player 1 Wins Game", seen_count + 1)
        elif p1_points < p2_points:
            print("Player 2 Wins Game", seen_count + 1)
        else:
            print("It's a Draw!")

If you keep the while–else shape, this version does what you expect: it finishes the rounds, enters the else, and reports the correct outcome. Without a break inside the loop, the else clause is functionally redundant and could be replaced by code that follows the loop normally; the behavior would be the same.

Why this matters

This is a classic example of a logical error masquerading as a control‑flow bug. It’s easy to blame the while–else when the last branch appears to be ignored, but the real problem is a self‑comparison that can never evaluate to true. Catching issues like this early keeps you from rewriting working control structures and helps you focus on the actual condition checks that drive game results or business rules.

Takeaways

When an if statement “refuses to execute,” verify the operands first. Ensure you’re comparing the right variables, especially after copy‑pasting similar lines. For loop‑finalization code, remember how Python’s while–else works: without a break, the else will always run. If you track counters from external sources like a leaderboard file, distinguish clearly between a historical count and the next sequence number you want to display. As a small style tip, global names are often written in CONSTANT_CASING, which makes shared state more obvious during reviews.

Keep the control flow simple, double‑check the comparisons, and validate user‑visible numbers like game indices against their intended meaning. That’s usually all it takes to make post‑loop summaries behave predictably.