Work out what you need to learn

For a project like the one in this chapter, you have to sketch out how your game works in outline, without worrying about clever details.

This part is easy. Most computer software has the same shape. It looks like this:

1. Ask the user a question, wait for the user to click or tap a button, or load some information from a file.
2. Check that the user hasn’t made a mistake.

3. Do something useful or clever.

   For this game, it means working out how to guess a number.

4. Show a response and/or save it to a new file.
5. Check whether you’re done yet.
6. If you’re done, stop; otherwise, go back to Step 1 and go around again.

Most games wait until the user pushes a button on a hand controller or clicks a control on the screen. When something happens, the game responds by updating the position of the spaceship, or the treasure, or the cute talking candy, and maybe increasing the score — unless the spaceship blows up, a unicorn from the other team steals the treasure, or the candy disappears, in which case sound effects and sad music happen, and the player has to start again.

In computer-land, information from the outside world is called the input. The software takes the input, and after doing clever things to it, it produces an output. Information in general is called data, which means whatever you’re given to work with. Doing something clever is called processing the data. So the short version of the loop is input⇒processing ⇒output.

Make a list of things to do

After you have an outline (see Figure 9-1), you can work out what you need to learn. Make a list of your own first, and see how much it looks like the one here:

• How do I ask my player a question in Python?
• How do I get an answer from my player?
• How do I check that the answer makes sense?
• How do I guess a number in a clever way?
• How do I know when we’re done?
• How do I make my code loop back?
• How do I stop?

That’s a lot of questions for a simple game!

But wait! You don’t have to answer them all at once! You can take them one at a time. Suddenly that doesn’t look like such a huge job. It’s still a big job, but it’s not impossibly planet-sized in a too-big kind of a way.

Breaking down one hard problem like “Make a cool game” into lots of simple problems like “How do I stop?” is the only way to go. Trying to get all the parts of a game working as you type is like jumping into an alligator pit and trying to fight all the alligators at once with one hand tied to a mouse and the other tied to your head.

Taking things step by step means you can write code for each question without worrying about the other questions.

Doing everything at once will only confuse you, and give the alligators an unfair advantage. You don’t want that — even if you like alligators.

Some books about software list the code you should type, and then — if you’re lucky — they explain a little about how it works. Doing it this way looks easy, but it doesn’t teach you how to write your own code. Asking questions and thinking first looks much harder, but once you get over the scary part at the beginning, you’ll write better code more quickly, and you’ll be less likely to get stuck.

Using raw_input

Take some time to look through the top hits. Do you see how to ask a question and get an answer now? Searching the web tells you the answer: You can use a Python command called raw_input to get an answer from a user.

You need to add some code that looks something like this:

player_answer = raw_input(“Question: yes or no?”)

You can also combine print and raw_input on a single line, separated by a comma. But you don’t really need to use print. If you include your question between (round brackets) and “quote marks”, raw_input prints it on the screen anyway.

Test your new skill

It’s always good to test code as you go. Sometimes it’s easier to write a test as a small side project.

To test your question-asking code:

1. Choose File ⇒ New Window to open a new Editor window.

2. Type the following:

   player_answer = raw_input("What is your answer? ")

   print “Your answer was: “ + player_answer

3. Save the file as question_answer.py and run it.

   If you didn’t make any typos, you should see something like the messages in Figure 9-3.

raw_input doesn’t care what the user types. It’s like a dumb robot. If you type a load of gibberish, it saves the gibberish in the player_answer variable.

The next line in the code prints out whatever is in player_answer. It doesn’t care if it’s gibberish either.

But hey, you’ve ticked off two whole items on your to-do list! You know how to ask the user a question and how to get an answer.

Working out whether the answer makes sense is a different problem.

This is why it’s so cool to break any big project into lots of teeny problems. You can make progress by working on them one at a time.

Why is there a + in the second line? Because you can join two bits of text together with a +. The print command glues the two bits together because of the + and makes them appear on one line. (You can’t do math on text, and this isn’t really math. It just looks a bit like math. Sort of.)

Check for yes or no

If you spent some time playing with Scratch, you’ll know there are two ways to check whether something is true. You can use if , like this:

if something is true

    do a thing

else

    do some other thing

Or you can use repeat…until, like this:

repeat

    do a thing

until

    some test is true

if solves half the problem. You could use it to check for yes or no, but it doesn’t give you a way to keep asking the same question over and over.

repeat…until sounds perfect. It checks and loops at the same time, like this:

repeat

    answer=raw_input("Question…")

until

    answer = "yes" or answer = "no"

The question keeps appearing until the answer is yes or no. Perfect!

But, uh, unfortunately, Python doesn’t understand repeat…until.

Also — wait a minute… .

Doesn’t

answer = "yes"

mean you’re saving a value of yes in the answer variable? That’s not much use as a check, is it?

If you spotted this is wrong, you are well on your way to being a computer genius! Good job! If you didn’t, don’t worry. Most people miss it. In fact, some developers forget it, even if they’ve been writing software for years.

Check for anything at all

You have to know the magic word to check whether two things are the same. The magic word is two equals signs instead of one, like this:

repeat

    do really cool stuff

until

    answer == "yes" or answer == "no"

Why? This is one of those times where it just is. It’s a magic word, and you have to know it. That’s all.

Go around and around …

So that’s half the problem solved. What can you use in Python to do the same job as repeat…until?

If you do a web search, you’ll see it’s called while. It works like this:

while [include a test here]

    do cool stuff

    do more cool stuff

carry on from here…

Cool stuff happens over and over while the result of the test is true. The code keeps doing the cool stuff until the test is false/not true. Then Python moves on to whatever happens next.

Problem solved? Nearly. But not quite.

Check for opposites

Here’s a question for you: When should the code loop? What tests should you put in while?

Look at Table 9-1 to help you guess.

The code should loop while the player’s answer isn’t yes, and it isn’t no.

This point will either seem, like, totally obvious, or it will seem brain-meltingly weird. Some people are fine with the idea of checking for two things that aren’t true. Others find it harder. If it seems hard, skip to the code and don’t think too much about the logic.

How do you check whether something isn’t equal to something else? You need another magic word. It looks like this:

if answer != “yes”

In English, when you see != you say not equal. So the code checks whether the answer is not the same as, not equal to, and generally different to yes — which is exactly what you want.

The while test looks like this:

answer = raw_input(“Question: yes or no? ”)

while answer != “yes” and answer != ”no”:

    answer = raw_input(“Question: yes or no? ”)

You have to set up the test to fail before you go into the loop, to make sure raw_input happens at least once. You could make it blank, but it’s just as easy to ask for some useful input and check it.

The officially approved way to use a while loop in Python looks different. It starts with while True: followed by code that does the cool stuff you want done. The version here works just as well and is simpler. Often there’s more than one way to write code thatworks. The right way depends on tradition, style, and how big and scary your boss and/or teacher is.

Add colons and indentation

You also have to put a colon (“:”) after the test. Python needs to see a colon after every test in your code. (It’s another of those “Because reasons” magic word features.)

When you end a line with a colon, the Editor automatically, at no extra cost to you, indents the next line, adding a gap of a few spaces at the start.

Python uses the extra spaces to remember that the indented code goes under the while. If it didn’t do this, it wouldn’t know which code to skip after the while, and it would get very confused about what it was supposed to do.

Figure 9-4 shows a slightly remixed and expanded version of the same code. The variable is called player_answer for clarity, but it works just like the code on the previous page.

As you can see, you can type any old nonsense and the code keeps asking you for yes or no, relentlessly, like a Terminator robot. It gives up only when you enter yes or no.

Woo hoo! It works! But that was a lot of work for a simple thing, wasn’t it?

It’s normal for software to spend a lot of time checking the input. Humans are unpredictable, but good software can handle every possible thing a human might do. This can take a long time to get right because there are soooooo many possibilities.

Humans are also sneaky. Important websites, especially shopping and banking sites, have to be even more careful about checking to make sure that hackers can’t get in. Otherwise, the hackers will steal all the credit card numbers they can find and buy truckloads of nice things for themselves and their friends. (This is not a joke. It really happens.)

Count to ten

How do you count to ten? There’s more than one way to make your code do this. You could put another while loop around the code, starting with a guess of 1, adding 1 to the guess each time, and breaking out of the loop when the guess is 11.

But if you’ve played with Scratch, you know a different way, called a for loop. Unlike a while loop, a for loop includes a variable that holds a count. The counter works automatically. Every time your code goes around the for loop, the value in the counter gets bigger by one.

Use range in Python

for loops in Python are slightly weird. Instead of saying “Start from this number and end with that number” you have to give Python a range.

Here’s an example that counts from one to ten:

for my_count in range(1, 11):

    print my_count

This is almost easy to understand. In English, it would say, “Count from the start of the range (1) to the end of the range (11) and print the count each time through.”

But why is the last number of the range 11 and not 10? Because reasons! This is another of those things in Python that doesn’t really make sense. You just have to remember that when you use a for loop, the end of the range is always one more than you’d expect.

Figure 9-5 shows that you can now count to ten in Python.

All computer programming languages do some stuff that makes no sense. Python is better than most. But all languages have at least a few things that make you think “Huh? What? Why?” when you see them. When this happens, you just have to deal.

Stop the count early

What if you want to stop the count early? What if your game guesses the number before reaching ten?

You can jump out of a for loop with a magic word called break, like this:

for my_count in range(1, 11):

    print my_count

    if my_count == 4:

        break

When my_count is 4, the for loop screeches to a halt with the sound of squealing brakes and the smell of burning rubber.

Not literally. It would be fun if it did. But no.

However, it does stop early. Sometimes that’s what you want.

Convert types

It would be really useful if you could convert between the types. And you can! Python includes a toolkit that does exactly this. Table 9-4 shows you.

Did you see how int(5.9) keeps only the whole number part and throws away the rest? It doesn’t try to round up the result to 6. It just trashes everything that isn’t a whole number. Beware!

Print text and numbers

You can make the example in the “Repeat Questions” section work. Add str() around the counter variable, and suddenly you can combine a number with text:

for my_count in range(1, 11):

    print “The count is: “ + str(my_count)

Find out about functions

Functions can have four ingredients, although they don’t always need them all:

• A name
• Input variables
• Code to repeat
• A way to return a result

You don’t always need the input — for example, if you write a function to tell the time, it doesn’t need to be told the time. (Duh.)

You don’t always need to return a result. But you do always need a unique name, and some code that does something.

The input variable is sometimes called a parameter, which is another weird name that fell out of math-land. Functions can have more than one parameter.

Make and use functions

To make a function, you use the magic word def, like this:

def my_function(input variables):

    [clever code for the function goes here]

    return output

To use the function, type this:

some_value = my_function(input)

This runs all the clever code, but the function code stays in one place. You also can use it over and over by typing a single line whenever you need it in the rest of the code.

Decide what to put in a function

When you split some code into a function, you want to make the rest of the code easier to read, and you also want to create a block of code you can reuse. Either option is good, but if you can get both, that’s a total win.

In this game, it’s hard to read the lines with raw_input. You can fix this in two ways.

You can put each raw_input line into a function and use the function to replace it.

Or you can take the entire answer block of code and put that into a function, like this:

for my_guess in range (1,11):

    answer = answer_for_guess(my_guess)

    if answer == “yes”:

        print “I guessed the number!”

        break

if answer == “no”:

    print “You’re lying!”

That’s a lot easier to read, isn’t it? If you remember about breaking down a big problem into smaller problems, you can use functions to help you.

This also means you can sketch out code as a list of functions and then write the code inside them later!

Write a guess function

You’re almost ready to write your first function. You need to know that the def section goes at the start of the code.

And there’s one more thing you can do to make the code simpler. You can put the question string into a variable so that you can repeat it without having to retype it. You don’t need to write a function to do this because the string doesn’t do any processing.

Figure 9-7 shows how it works:

def answer_for_guess(this_guess):

    question_string = “Is your number “ + str(this_guess) + “ – yes or no? ”

    answer = raw_input(question_string)

    while answer != yes and answer != no:

        answer = raw_input(question_string)

    return answer

Variable names get special privileges inside a function. The rule is that whatever happens inside the function stays inside the function, unless you use return to return it.