Game — Number Guesser, Part 1 (Core Loop)

By the end of this lesson you can:

• Pick a secret integer with random.randint(1, 100).
• Convert a user's text input into a number, safely — and handle the case where they typed nonsense.
• Loop until the guess matches, counting the number of tries it took.

You've met everything we need. random.randint from PY-L1-41, int() conversion from PY-L1-07, a while loop from PY-L1-12, and comparisons from PY-L1-09. Today we glue them together.

Predict the output. What does this print?

secret = 42
guess = 30
tries = 1

while guess != secret:
    if guess < secret:
        print("higher")
    else:
        print("lower")
    guess = guess + 5
    tries = tries + 1

print("Got it in", tries, "tries.")

higher
higher
higher
Got it in 4 tries.

higher
higher
higher
lower
lower
lower
... (forever, because 5 doesn't hit 42)

Pick the secret

import random
secret = random.randint(1, 100)

Both ends inclusive — the secret can be 1, 100, or anything in between. From PY-L1-41 — same function we used for dragon damage.

Read a guess, safely

Naive code:

guess = int(input("Guess (1-100): "))

One line, but it crashes if the user types banana instead of a number — Python raises ValueError and the whole program dies. We don't know try/except yet (that's Level 2), so the simplest defence is to check the input is numeric before converting:

raw = input("Guess (1-100): ").strip()
if not raw.isdigit():
    print("Please type a whole number.")
    continue
guess = int(raw)

str.isdigit() returns True only if every character is a digit. It does the validation; int() does the conversion. Two steps, but the program never crashes on bad input.

.isdigit() doesn't like negatives

Small caveat: "-5".isdigit() is False because the minus sign isn't a digit. Since our valid range is 1-100, that's fine — negatives are invalid anyway. For Number Guesser, isdigit is exactly the right check.

The core loop

tries = 0

while True:
    raw = input("Guess (1-100): ").strip()
    if not raw.isdigit():
        print("Whole numbers only, please.")
        continue
    guess = int(raw)

    tries = tries + 1

    if guess < secret:
        print("⬆️  Higher.")
    elif guess > secret:
        print("⬇️  Lower.")
    else:
        print("🎉 Got it in", tries, "tries!")
        break

while True with a break on the success branch. continue on invalid input. tries counts only the valid guesses. Three little helpers from PY-L1-12 and PY-L1-32 working together.

Why count tries inside the validation block, not before it?

Look closely — tries = tries + 1 happens after we've checked the input is a digit. Typing banana shouldn't cost the player a guess. This is the same fairness principle from PY-L1-36 (Hangman): only real attempts count.

The full file

Save as guesser.py:

Code

# guesser.py — Number Guesser, Part 1

import random

LOW = 1
HIGH = 100

print("=" * 40)
print("       Number Guesser")
print("=" * 40)
print("I'm thinking of a number between", LOW, "and", HIGH, ".")
print()

secret = random.randint(LOW, HIGH)
tries = 0

while True:
    raw = input("Your guess: ").strip()

    if not raw.isdigit():
        print("Whole numbers only, please.")
        continue

    guess = int(raw)

    if guess < LOW or guess > HIGH:
        print("Out of range. Stick between", LOW, "and", HIGH, ".")
        continue

    tries = tries + 1

    if guess < secret:
        print("⬆️  Higher.")
    elif guess > secret:
        print("⬇️  Lower.")
    else:
        print("🎉 Correct! Got it in", tries, "tries.")
        break

print()
print("Thanks for playing!")

Sample run

========================================
       Number Guesser
========================================
I'm thinking of a number between 1 and 100 .

Your guess: 50
⬆️  Higher.
Your guess: 75
⬇️  Lower.
Your guess: 62
⬇️  Lower.
Your guess: 57
⬆️  Higher.
Your guess: 60
🎉 Correct! Got it in 5 tries.

Thanks for playing!

Three things to notice

• Two continues. One for non-digit input, one for out-of-range numbers. Both bounce back to the top of the loop without consuming a try.
• Constants at the top. LOW = 1 and HIGH = 100 in CAPS. Changing the range to 1-50 takes one edit. Tomorrow we'll make these depend on a difficulty choice.
• The hint is binary. Just "higher" or "lower" — not "ten higher" or "close!". That keeps the game easy to extend (Part 2's difficulty) and means optimal play is about 7 guesses for 1-100 (think about why — half the range each time).

Three tasks. Build the bones, then sharpen the edges.

secret = 42

while True:
    guess = int(input("Guess: "))
    if guess < secret:
        print("higher")
    elif guess > secret:
        print("lower")
    else:
        print("got it!")
        break

import random

secret = random.randint(1, 100)
tries = 0

while True:
    guess = int(input("Guess: "))
    tries = tries + 1
    if guess < secret:
        print("higher")
    elif guess > secret:
        print("lower")
    else:
        print("got it in", tries, "tries!")
        break

while True:
    raw = input("Guess: ").strip()
    if not raw.isdigit():
        print("Whole numbers only.")
        continue
    guess = int(raw)
    if guess < 1 or guess > 100:
        print("Stick to 1-100.")
        continue

    tries = tries + 1
    # ... compare and react ...

The core Number Guesser is a tight while True loop with three branches inside: continue on invalid input (don't count it), continue on out-of-range numbers (don't count those either), and a comparison that prints "higher" / "lower" / "correct". The secret comes from random.randint(1, 100). The validation gate uses str.isdigit() to dodge the crash from int("banana"). Tomorrow we add difficulty levels — the player picks Easy / Medium / Hard and the range plus try-cap change to match. The core loop you wrote today doesn't change a line.