Project 1: a number guessing game

What you will be able to do

After this lesson you can

• plan a program with rules, a table of expected answers, and steps,
• use random.randint to pick a number,
• keep the thinking of a program in small functions that can be tested,
• build a loop that has two reasons to stop, and
• test every way in which the game can end.

Plan first

A good programmer thinks before typing. A program that you build without a plan grows in a strange shape, and a fault is hard to find. The plan of this game has two parts: the rules, and the expected answers.

The rules.

1. The computer picks a secret number from 1 to 100.
2. The player has at most 7 guesses.
3. After each wrong guess, the computer says Too low or Too high.
4. The game ends when the number is found, or when the guesses run out.
5. The score is 100 for the first guess, and 10 less for each extra guess, and never below 0.

The expected answers. Before you write any code, work out some answers by hand. For a secret of 42: a guess of 30 is Too low, 50 is Too high, 42 is Correct. The score is 100 on the 1st try, 90 on the 2nd, 70 on the 4th, and 40 on the 7th.

A new tool: random

Python has toolboxes of ready-made code. They are called modules. You bring one in with import. The module random has the function random.randint(1, 100), which gives a whole number from 1 to 100, both ends included. It is a different number every time you run the program.

Step 1: put the thinking in functions

Here is an idea that makes a program much easier to test. Do not mix thinking with asking and showing. The thinking is "how does this guess compare with the secret?" and "what is the score for this many tries?". The asking is input() and the showing is print(). We put each piece of thinking into a small function, with parameters and return, and no input() or print() inside.

This is a habit worth keeping: the part that thinks is a function. The part that talks to the user is the main program.

Because score_for() has no input() and no print(), it can be tested with a few calls before the game exists.

Step 2: the game

Now the main program uses the two functions.

Type some guesses in the Input box, one on each line, and press Run. Type more than you think you need. A game that asks for more guesses than the Input box has stops with an EOFError.

Step 3: test every ending

A game can end in three ways, and each needs a test. To test it, you can set secret = 42 instead of the random line for a moment.

The third row is the edge: the winning guess is the seventh. An off-by-one fault shows there. Remember to put the random line back after the test.

Step 4: extend it

Pick one or two, and do them without looking at a solution. Write the expected answers first.

1. A closer hint. Say Very close when the guess is within 5 of the secret. Where does it go: in judge, or in the main program? (Hint: the thinking goes in judge.)
2. A harder game. Change the range to 1 to 1000, and the tries to 10. What is the best strategy to find the number in 10 tries?
3. Play again. Wrap the whole game in a loop that asks Play again? (y/n).
4. A best score. Keep the best score over several games.

Common mistakes

• No plan. The program grows in a strange shape.
• print inside the function that thinks. You cannot use its answer.
• Forgetting the flag, so that after the loop you do not know whether the player won.
• Not testing the last try. The off-by-one fault hides there.
• Not changing the text from input() into a number.

Practice

Start with two quick questions. Each New numbers gives you a fresh one, so you can practise as long as you like.

Then the labs and the problems:

1. Warm-up. Open the lab Test the judge function. You write the function, and the checker tries it on many guesses.
2. Build. Open the problem Limit the guesses and the problem The score of the game.
3. Stretch. Open the lab Play the guessing game and add the closer hint.

Remember these

• Plan the rules and the expected answers first.
• Keep the thinking in functions without input() or print(). Then you can test them alone.
• Two reasons to stop a loop are joined with and. A flag remembers what happened.
• Test every way the program can end, and the edge: the win on the last try.

Check yourself

Try each one on your own first. If you are stuck, open a hint. Then check with Show the answer.

1. Which numbers can random.randint(1, 6) give?

2. What is score_for(3)?

3. Why is judge better as a function without print?