The modulus operatorEdit
The modulus operator works on integers (and integer expressions) and yields the remainder when the first operand is divided by the second. In Python, the modulus operator is a percent sign (%). The syntax is the same as for other operators:
So 7 divided by 3 is 2 with 1 left over.
The modulus operator turns out to be surprisingly useful. For example, you can check whether one number is divisible by another---if x % y is zero, then x is divisible by y.
Also, you can extract the right-most digit or digits from a number. For example, x % 10 yields the right-most digit of x (in base 10). Similarly x % 100 yields the last two digits.
Boolean values and expressionsEdit
The Python type for storing true and false values is called bool, named after the British mathematician, George Boole. George Boole created Boolean algebra, which is the basis of all modern computer arithmetic.
There are only two boolean values: True and False. Capitalization is important, since true and false are not boolean values.
A boolean expression is an expression that evaluates to a boolean value. The operator == compares two values and produces a boolean value:
In the first statement, the two operands are equal, so the expression evaluates to True; in the second statement, 5 is not equal to 6, so we get False.
The == operator is one of the comparison operators; the others are:
Although these operations are probably familiar to you, the Python symbols are different from the mathematical symbols. A common error is to use a single equal sign (=) instead of a double equal sign (==). Remember that = is an assignment operator and == is a comparison operator. Also, there is no such thing as =< or =>.
There are three logical operators: and, or, and not. The semantics (meaning) of these operators is similar to their meaning in English. For example, x > 0 and x < 10 is true only if x is greater than 0 and less than 10.
n % 2 == 0 or n % 3 == 0 is true if either of the conditions is true, that is, if the number is divisible by 2 or 3.
Finally, the not operator negates a boolean expression, so not(x > y) is true if (x > y) is false, that is, if x is less than or equal to y.
In order to write useful programs, we almost always need the ability to check conditions and change the behavior of the program accordingly. Conditional statements give us this ability. The simplest form is the * if statement*:
The boolean expression after the if statement is called the condition. If it is true, then the indented statement gets executed. If not, nothing happens.
The syntax for an if statement looks like this:
As with the function definition from last chapter and other compound statements, the if statement consists of a header and a body. The header begins with the keyword if followed by a boolean expression and ends with a colon (:).
The indented statements that follow are called a block. The first unindented statement marks the end of the block. A statement block inside a compound statement is called the body of the statement.
Each of the statements inside the body are executed in order if the boolean expression evaluates to True. The entire block is skipped if the boolean expression evaluates to False.
There is no limit on the number of statements that can appear in the body of an if statement, but there has to be at least one. Occasionally, it is useful to have a body with no statements (usually as a place keeper for code you haven't written yet). In that case, you can use the pass statement, which does nothing.
A second form of the if statement is alternative execution, in which there are two possibilities and the condition determines which one gets executed. The syntax looks like this:
If the remainder when x is divided by 2 is 0, then we know that x is even, and the program displays a message to that effect. If the condition is false, the second set of statements is executed. Since the condition must be true or false, exactly one of the alternatives will be executed. The alternatives are called branches, because they are branches in the flow of execution.
As an aside, if you need to check the parity (evenness or oddness) of numbers often, you might wrap this code in a function:
For any value of x, print_parity displays an appropriate message. When you call it, you can provide any integer expression as an argument.
Sometimes there are more than two possibilities and we need more than two branches. One way to express a computation like that is a chained conditional:
elif is an abbreviation of else if . Again, exactly one branch will be executed. There is no limit of the number of elif statements but only a single (and optional) else statement is allowed and it must be the last branch in the statement:
Each condition is checked in order. If the first is false, the next is checked, and so on. If one of them is true, the corresponding branch executes, and the statement ends. Even if more than one condition is true, only the first true branch executes.
One conditional can also be nested within another. We could have written the trichotomy example as follows:
The outer conditional contains two branches. The first branch contains a simple output statement. The second branch contains another if statement, which has two branches of its own. Those two branches are both output statements, although they could have been conditional statements as well.
Although the indentation of the statements makes the structure apparent, nested conditionals become difficult to read very quickly. In general, it is a good idea to avoid them when you can.
Logical operators often provide a way to simplify nested conditional statements. For example, we can rewrite the following code using a single conditional:
The print statement is executed only if we make it past both the conditionals, so we can use the and operator:
These kinds of conditions are common, so Python provides an alternative syntax that is similar to mathematical notation:
This condition is semantically the same as the compound boolean expression and the nested conditional.
The return statementEdit
The return statement allows you to terminate the execution of a function before you reach the end. One reason to use it is if you detect an error condition:
The function print_square_root has a parameter named x. The first thing it does is check whether x is less than or equal to 0, in which case it displays an error message and then uses return to exit the function. The flow of execution immediately returns to the caller, and the remaining lines of the function are not executed.
In :ref:`input` we were introduced to Python's built-in functions that get input from the keyboard: raw_input and input. Now let's look at these again in greater depth.
When either of these functions are called, the program stops and waits for the user to type something. When the user presses Return or the Enter key, the program resumes and raw_input returns what the user typed as a string:
Before calling raw_input, it is a good idea to print a message telling the user what to input. This message is called a prompt. We can supply a prompt as an argument to raw_input:
Notice that the prompt is a string, so it must be enclosed in quotation marks.
If we expect the response to be an integer, we can use the input function which evaluates the response as a Python expression:
If the user types a string of digits, it is converted to an integer and assigned to speed. Unfortunately, if the user types characters that do not make up a valid Python expression, the program crashes:
In the last example, if the user had made the response a valid Python expression by putting quotes around it, it would not have given an error:
To avoid this kind of error, it is a good idea to use raw_input to get a string and then use conversion commands to convert it to other types.
Each Python type comes with a built-in command that attempts to convert values of another type into that type. The int(ARGUMENT) command, for example, takes any value and converts it to an integer, if possible, or complains otherwise:
int can also convert floating-point values to integers, but remember that it truncates the fractional part:
The float(ARGUMENT) command converts integers and strings to floating-point numbers:
It may seem odd that Python distinguishes the integer value 1 from the floating-point value 1.0. They may represent the same number, but they belong to different types. The reason is that they are represented differently inside the computer.
The str(ARGUMENT) command converts any argument given to it to type string:
str(ARGUMENT) will work with any value and convert it into a string. As mentioned earlier, True is boolean value; true is not.
For boolean values, the situation is especially interesting:
Python assigns boolean values to values of other types. For numerical types like integers and floating-points, zero values are false and non-zero values are true. For strings, empty strings are false and non-empty strings are true.
GASP (G raphics A PI for S tudents of P ython) will enable us to write programs involving graphics. Before you can use GASP, it needs to be installed on your machine. If you are running Ubuntu GNU/Linux, see :ref:`installing-gasp` in Appendix A_. Current instructions for installing GASP on other platforms can be found at http://dev.laptop.org/pub/gasp/downloads.
After installing gasp, try the following python script:
The second to the last command pauses and waits until a key is pressed. Without it, the screen would flash by so quickly you wouldn't see it.
Running this script, you should see a graphics window that looks like this:
GASP illustration 1 We will be using gasp from here on to illustrate (pun intended) computer programming concepts and to add to our fun while learning. You can find out more about the GASP module by reading Appendix B_.
- #. Try to evaluate the following numerical expressions in your head, then use
the Python interpreter to check your results:
- >>> 5 % 2
- >>> 9 % 5
- >>> 15 % 12
- >>> 12 % 15
- >>> 6 % 6
- >>> 0 % 7
- >>> 7 % 0
What happened with the last example? Why? If you were able to correctly anticipate the computer's response in all but the last one, it is time to move on. If not, take time now to make up examples of your own. Explore the modulus operator until you are confident you understand how it works.
Wrap this code in a function called compare(x, y). Call compare three times: one each where the first argument is less than, greater than, and equal to the second argument.
- #. To better understand boolean expressions, it is helpful to construct truth
tables. Two boolean expressions are logically equivalent if and only if they have the same truth table.
The following Python script prints out the truth table for the any boolean expression in two variables: p and q:
You will learn how this script works in later chapters. For now, you will use it to learn about boolean expressions. Copy this program to a file named p_and_q.py, then run it from the command line and give it: p or q, when prompted for a boolean expression. You should get the following output:
p q p or q
===================== True True True True False True False True True False False False
Now that we see how it works, let's wrap it in a function to make it easier to use:
We can import it into a Python shell and call truth_table with a string containing our boolean expression in p and q as an argument:
Use the truth_table functions with the following boolean expressions, recording the truth table produced each time:
- not(p or q)
- p and q
- not(p and q)
- not(p) or not(q)
- not(p) and not(q)
Which of these are logically equivalent?
- . Enter the following expressions into the Python shell:
Analyze these results. What observations can you make about values of different types and logical operators? Can you write these observations in the form of simple rules about and and or expressions?
Wrap this code in a function called dispatch(choice). Then define function_a, function_b, and function_c so that they print out a message saying they were called. For example:
Put the four functions ( dispatch, function_a, function_b, and function_c into a script named ch04e05.py. At the bottom of this script add a call to dispatch('b'). Your output should be:
function_b was called...
Finally, modify the script so that user can enter 'a', 'b', or 'c'. Test it by importing your script into the Python shell.
- #. Write a function named is_divisible_by_3 that takes a single integer as
an argument and prints "This number is divisible by three." if the argument is evenly divisible by 3 and "This number is not divisible by three." otherwise.
Now write a similar function named is_divisible_by_5.
- #. Generalize the functions you wrote in the previous exercise into a function
named is_divisible_by_n(x, n) that takes two integer arguments and prints out whether the first is divisible by the second. Save this in a file named ch04e07.py. Import it into a shell and try it out. A sample session might look like this:
What will be the output of the following?Explain what happened and why it happened.
The following gasp script, in a file named house.py, draws a simple house on a gasp canvas:
Run this script and confirm that you get a window that looks like this:
GASP illustration 2
- Wrap the house code in a function named draw_house().
- Run the script now. Do you see a house? Why not?
- Add a call to draw_house() at the botton of the script so that the house returns to the screen.
- Parameterize the function with x and y parameters -- the header should then become def draw_house(x, y):, so that you can pass in the location of the house on the canvas.
- #. Use draw_house to place five houses on the canvas in different
Exploration: Read over Appendix B_ and write a script named houses.py that produces the following when run:
GASP illustration 3
hint: You will need to use a Polygon for the roof instead of two Lines to get filled=True to work with it.