Hacking Raspberry Pi (2014)

---

Writing a Simple Game

Next we are going to write a simple number-guessing game that gives you the opportunity to practice with some common Python code constructions and perhaps have a bit of fun in the process.

Start with the guessing_game.py file you created in the preceding section. Take a look at the following code sample (don’t include the line numbers) and then follow that up by studying my annotations for each line of code.

For reference, check out Figure 11.2 to see what the completed script looks like on my Raspberry Pi.

1. /usr/bin/env python
2. #Number guessing game adapted from
#inventwithpython.com
3. import random
4. guesscount = 0
5. number = random.randint(1, 10)
6. print("I thought of a number between 1 and 10. Can you guess it in three
tries?\n")
7. while guesscount < 3:
8. guess = input()
9. guess = int(guess)
10. guesscount = guesscount + 1
11. if guess < number:
print("Too low.")
12. if guess > number:
print("Too high.")
13 if guess == number:
break
14. if guess == number:
15. guesscount = str(guesscount)
16. print("Congratulations! You guessed the correct number in " +
guesscount+ " guesses!")
17. if guess != number:
number = str(number)
print("Sorry. The number I thought of was " + number + ".")

FIGURE 11.2 The number guessing game source code

On to the purpose of each line in the program:

1. This is the “shebang” line that points Raspbian to the location of the Python interpreter.

2. These are two single-line comments that give credit to the developer on whose code this example is based on. Incidentally, multiline comments in Python are done using the triple quote (""") punctuation before and after the comment.

3. Use the import function to bring in external code modules into the Python environment. Modules are discussed in greater detail later in the chapter. For now, understand that random is a module that ships with Python and gives you access to functions related to (what else?) random number generation.

4. Create a variable to store the running count of user guesses and initialize the value of the variable to zero.

5. Define a variable to hold the randomly selected number. Specifically, you call the randint function inside of the random module and ask the Python interpreter to generate an integer (whole number) between 1 and 10, inclusive.

6. This print statement explains the game to the player and inserts a new line between this prompt and the user’s first guess.

7. The while statement is an example of looping logic. It says “keep repeating whatever code is indented underneath until the guesscount variable reaches 3.”

8. Populate the guess variable with the user’s typed response.

9. Use the int function to ensure that the user’s input is typed as an integer. This is an example of type casting, in which you can convert data from one type to another.

10. Increment the guesscount variable by one each time you loop through the indented while code.

11. The if statement is probably the most common looping function in Python. Here it tests the guess variable against the computer’s generated number. If the user’s guess is below the number, it tells the user.

12. This if block does the same thing as 11, but here it tests if the user’s guess is above the correct value.

13. If the user’s guess matches the computer’s randomly selected number, then you break out of the while loop and continue with whatever code comes next in the script.

14. This if statement (and the next one) are necessary because if you break out of the while loop with a correct response, you want to end the game. This line of code also uses concatenation to combine static text and variable data. More on that later.

15. Convert the guesscount variable, which was created as an integer, to a string value. It’s common practice to cast numbers to strings when you want to print output for the user.

16. Concatenate, or combine, static text and variable data using the plus (+) operator. This can get confusing because you can also use the plus sign to perform arithmetic addition.

17. The purpose of this block is to handle the situation in which you leave the while loop because the user’s guess count exceeds three tries. Here you verify that the user’s guess does not match the computer’s number (!= is the programmatic equivalent of “not equal to”), convert the number to a string, and then inform the user.

Delving into a Bit More Detail

You can close your Python script file; let’s work directly in the Python Shell. First, I want to discuss three Python programming features in a bit more detail:

variables

type casting

concatenation

I’m calling out these three programming tools because they are so fundamental not only to Python, but to any programming language. For instance, most computer programs take data and perform some sort of processing and evaluation on it. How and where do you store that data? What if you need to convert data from one form to another—how is that done in Python? Finally, how do you combine multiple pieces of dynamic data?

Read on, friend...read on.

Variables

As previously discussed, a variable is a named placeholder for data. Variable naming in Python 3 is flexible, but there are a few rules that you need to keep in mind:

Python key words cannot be used as a variable name (naming a variable print is not allowed, for instance).

Variable names cannot contain spaces (underscores are okay, though).

Uppercase and lowercase characters are distinct (Var1 and var1 are considered two separate variables).

The first character of a variable name must be a letter a through z, A through Z, or an underscore character (no numbers to start variable names because this confuses the Python interpreter).

After the first character, you can use the digits 0 through 9 and underscores in variable names.

The equal sign (=) is used to assign value to a variable. This is in stark contrast to the double equals (==) that are used to test equality between two values. For instance:

var1 = 2 : This statement says, “The value of the variable named var2 is 2.”

var1 == 2 : This asks the question, “Does the value of the variable named var1 equal 2?”

Type Casting

In programming, a variable needs to be associated with a data type. The data type constrains, or limits, the kind of data stored by the variable. For instance, does the variable x below store a number or a string of characters? How about the variable y? How do you think Python computes the result of the variable z in the third code example?

x = "234"
y = 432
z = x + y

In some programming languages, the variable x in the previous example would be assumed to be a string because of the quotation marks. Therefore, the expression x+ y would fail because you can’t add a string and a number together.

Strictly typed programming languages like C require that you declare not only a variable’s name, but also the type of data that it can hold. Python isn’t like that; it’s much more lax.

Yes indeed—Python is pretty forgiving, data type-wise. You can use the type function to check the data type that Python associated with a variable. Try the following:

type(x)

Python 3 supports the following native data types:

Boolean: Possible values are True or False.

Numbers: Integers (whole numbers); Floats (decimal or fractional numbers), or complex numbers.

Strings: Character sequences.

Bytes: Binary data such as images or other media files.

Lists: Ordered value sequences.

Tuples: Ordered values that are different from lists inasmuch as lists can change their values (mutable), but tuples cannot (immutable).

Sets: Unordered value sequences.

Dictionaries: Unordered key-value pairs.

You can use type-casting functions to manually convert data from one data type to another. This is useful when you want to ensure that Python receives variable data in a particular format.

For instance, try this:

vara = "100"
type(vara)

The result of the above code is that Python sees “100” as a string rather than as an integer. Does that result surprise you? It shouldn’t. When the Python interpreter saw data contained within quotes, it assumed you wanted to use the str (string) data type instead of int (integer). You can fix it, though, by converting the string you assigned to the variable to an integer:

varb = int(vara)
type(varb)

In other words, Python infers a data type based upon how you type. If you use quotes, then dollars to donuts Python assumes you’re talking about a string value. If you supply a number without quotes, then Python selects one of the numeric data types depending upon the number.

For instance, a variable value of 100 is an integer, and 100.1 is a float. Understand?

Concatenation

In Python, string concatenation enables you to patch together bits of code. To do this, simply use the plus sign (+). Consider the following examples, all of which you can try out in the Python Shell:

str1, str2 = "abc", "def": Two things—you can create and initialize more than one variable in one shot, and you can use single or double quotes to contain string data.

str1 + str2: Note that when you concatenate strings, no extra space is included. The result of this operation is abcdef.

str1 + " " + str2: You can pad spaces by passing in the space character(s) as a separate string literal. In this example, the result is “abc def”. Pretty cool, huh?

print("The combined string value is: " + str1 + str2): You can concatenate string literal data with variable data to provide the user with customized output.

Modules

In Python, modules are .py script files that contain one or more related code blocks. What is so cool about modules is that they make programming much more modular. Think of it: Would you rather write (or copy/paste) a bunch of functions you created that pertain to several different Python programs you’re working on, or would you rather have those functions stored in a module that you can load and unload at your convenience?

Earlier in this chapter I briefly introduced the random module that ships with the so-called reference version of Python 3. As you can see in Figure 11.3, the contents of the module are stored in plain text and can be viewed and analyzed by anyone.

FIGURE 11.3 Python modules are note encrypted, but boy, are they useful! Here you can see the code behind the randint function used earlier in the chapter.