Chapter 4. Making Decisions

So far, you have only seen how to manipulate data directly or through names to which the data is bound. Now that you have the basic understanding of how those data types can be manipulated manually, you can begin to exercise your knowledge of data types and use your data to make decisions.

In this chapter, you learn about how Python makes decisions using True and False and how to make more complex decisions based on whether a condition is True or False.

In this chapter you learn:

  • How to create situations in which you can repeat the same actions using loops that give you the capability to automate stepping through lists, tuples, and dictionaries.

  • How to use lists or tuples with dictionaries cooperatively to explore the contents of a dictionary.

  • How to use exception handling to write your programs to cope with problematic situations that you can handle within the program.

Comparing Values — Are They the Same?

You saw True and False in Chapter 3, but you weren't introduced to how they can be used. True and False are the results of comparing values, asking questions, and performing other actions. However, anything that can be given a value and a name can be compared with the set of comparison operations that return True and False.

Try It Out: Comparing Values for Sameness

Testing for equality is done with two equal signs — remember that the single equal sign will bind data to a name, which is different from what you want to do here, which is elicit a True or False:

>>> 1 == 1
True
>>> 1 == 2
False

How It Works

When you use the equality comparison, Python compares the values on both sides. If the numbers are different, False will be the result. If the numbers are the same, True will be the result.

If you have different types of numbers, Python will still be able to compare them and give you the correct answer:

>>> 1.23 == 1
False
>>> 1.0 == 1
True

You can also use the double equals to test whether strings have the same contents, and you can even restrict this test to ranges within the strings (remember from the last chapter that slices create copies of the part of the strings they reference, so you're really comparing two strings that represent just the range that a slice covers):

>>> a = "Mackintosh apples"
>>> b = "Black Berries"
>>> c = "Golden Delicious apples"
>>> a == b
False
>>> b == c
False
>>> a[-len("apples"):−1] == c[-len("apples"):−1]
True

Sequences can be compared in Python with the double equals as well. Python considers two sequences to be equal when every element in the same position is the same in each list. Therefore, if you have three items each in two sequences and they contain the same data but in a different order, they are not equal:

>>> apples = ["Mackintosh", "Golden Delicious", "Fuji", "Mitsu"]
>>> apple_trees = ["Golden Delicious", "Fuji", "Mitsu", "Mackintosh"]
>>> apples == apple_trees
False
>>> apple_trees = ["Mackintosh", "Golden Delicious", "Fuji", "Mitsu"]
>>> apples == apple_trees
True

In addition, dictionaries can be compared. Like lists, every key and value (paired, together) in one dictionary has to have a key and value in the other dictionary in which the key in the first is equal to the key in the second, and the value in the first is equal to the value in the second:

>>> tuesday_breakfast_sold = {"pancakes":10, "french toast": 4, "bagels":32,
"omelets":12, "eggs and sausages":13}
>>> wednesday_breakfast_sold = {"pancakes":8, "french toast": 5, "bagels":22,
"omelets":16, "eggs and sausages":22}
>>> tuesday_breakfast_sold == wednesday_breakfast_sold
False
>>> thursday_breakfast_sold = {"pancakes":10, "french toast": 4, "bagels":32,
"omelets":12, "eggs and sausages":13}
>>> tuesday_breakfast_sold == thursday_breakfast_sold
True

Doing the Opposite — Not Equal

There is an opposite operation to the equality comparison. If you use the exclamation and equals together, you are asking Python for a comparison between any two values that are not equal (by the same set of rules of equality that you saw for the double equal signs) to result in a True value.

Try It Out: Comparing Values for Difference

Try out the following examples to see how Python evaluates these comparisons:

>>> 3 == 3
True
>>> 3 != 3
False
>>> 5 != 4
True

How It Works

Every pair of numbers that would generate a True result when they're compared using the == will now generate a False, and any two numbers that would have generated a False when compared using == will now result in True.

These rules hold true for all of the more complex types, like sequences and dictionaries:

>>> tuesday_breakfast_sold != wednesday_breakfast_sold
True
>>> tuesday_breakfast_sold != thursday_breakfast_sold
False

Like numbers, any situation that would be True with == will be False with != with these types.

Comparing Values — Which One Is More?

Equality isn't the only way to find out what you want to know. Sometimes you will want to know whether a quantity of something is greater than that of another, or whether a value is less than some other value. Python has greater than and less than operations that can be invoked with the > and < characters, respectively. These are the same symbols you are familiar with from math books, and the question is always asking whether the value on the left is greater than (>) or less than (<) the value on the right.

Try It Out: Comparing Greater Than and Less Than

>>> 5 < 3
False
>>> 10 > 2
True

How It Works

The number on the left is compared to the number on the right. You can compare letters, too. A few conditions exist where this might not do what you expect, such as trying to compare letters to numbers. (The question just doesn't come up in many cases, so what you expect and what Python expects is probably not the same.) The values of the letters in the alphabet run roughly this way: A capital "A" is the lowest letter. "B" is the next, followed by "C" and so on until "Z". This is followed by the lowercase letters, with "a" being the lowest lowercase letter and "z" the highest. However, "a" is higher than "Z":

>>> "a" > "b"
False
>>> "A" > "b"
False
>>> "A" > "a"
False
>>> "b" > "A"
True
>>> "Z" > "a"
False

If you want to compare two strings that are longer than a single character, Python will look at each letter until it finds one that's different. When that happens, the outcome will depend on that one difference. If the strings are completely different, the first letter will decide the outcome:

>>> "Zebra" > "aardvark"
False
>>> "Zebra" > "Zebrb"
False
>>> "Zebra" < "Zebrb"
True

You can avoid the problem of trying to compare two words that are similar but have differences in capitalization by using a special method of strings called lower, which acts on its string and returns a new string with all lowercase letters. There is also a corresponding upper method. These are available for every string in Python:

>>> "Pumpkin" == "pumpkin"
False
>>> "Pumpkin".lower() == "pumpkin".lower()
True
>>> "Pumpkin".lower()
'pumpkin'
>>> "Pumpkin".upper() == "pumpkin".upper()
True
>>> "pumpkin".upper()
'PUMPKIN'

Note that you could have also written the preceding code in the following manner:

>>> "Pumpkin".lower() == "pumpkin"
True

Because "pumpkin" is already lowercase, there is no real need to change it, though doing so may be safer. For instance, if someone types in a string incorrectly, capitalizing one of the letters in one of the strings, converting them both would solve any errors. Observe the following:

>>> "Pumpkin".lower() == "puMpkin"
False
>>> "Pumpkin".lower() == "puMpkin".lower()
True

When you have a string referenced by a name, you can still access all of the methods that strings normally have:

>>> gourd = "Calabash"
>>> gourd
'Calabash'
>>> gourd.lower()
'calabash'
>>> gourd.upper()
'CALABASH'

More Than or Equal, Less Than or Equal

There is a useful variation on greater than and less than. It's common to think of things in terms of greater than or equal to or less than or equal to. You can use a simple shorthand to do that. Join the two symbols in a way that makes sense when you look at it:

>>> 1 > 1
False
>>> 1 >= 2
False
>>> 10 < 10
False
>>> 10 <= 10
True

Reversing True and False

When you are creating situations and comparing their outcomes, sometimes you want to know whether something is true, and sometimes you want to know whether something is not true. Sensibly enough, Python has an operation to create the opposite situation — the word not provides the opposite of the truth value that follows it.

Try It Out: Reversing the Outcome of a Test

>>> not True
False
>>> not 5
False
>>> not 0
True
>>> Not True
SyntaxError: invalid syntax (<pyshell#30>, line 1)

Note the error in the last line of code. Be sure not to capitalize the not operator, or you will receive an error message similar to the one shown here.

How It Works

The not operation applies to any test that results in a True or False. However, remember from Chapter 3 that anything that's not zero will be seen as True, so you can use not in many situations where you wouldn't expect it or where it doesn't necessarily make sense:

>>> not 5 > 2
False
>>> not "A" < 3
True
>>> not "A" < "z"
False

Looking for the Results of More Than One Comparison

You can also combine the results of more than one operation, which enables your programs to make more complex decisions by evaluating the truth values of more than one operation.

One kind of combination is the and operation, which says "if the operation, value, or object on my left evaluates to being True, move to my right and evaluate that. If it doesn't evaluate to True, just stop and say False — don't do any more."

>>> True and True
True
>>> False and True
False
>>> True and False
False
>>> False and False
False

The other kind of combining operation is the or operator. Using the or tells Python to evaluate the expression on the left, and if it is False, Python will evaluate the expression on the right. If it is True, Python will stop evaluation of any more expressions:

>>> True or True
True
>>> True or False
True
>>> False or True
True
>>> False or False
False

You may also want to place sequences of these together based on actions you want to happen. In these cases, evaluation starts with the leftmost and or or and continues following the previous rules — in other words, until a False value is evaluated for and, or until a True value is evaluated for or.

How to Get Decisions Made

Python has a very simple way of letting you make decisions. The reserved word for decision making is if, and it is followed by a test for the truth of a condition, and the test is ended with a colon, so you'll see it referred to here as if ... :. It can be used with anything that evaluates to True or False to say "if something is true, do what follows":

>>> if 1 > 2:
...     print("No it is not!")
...
>>> if 2 > 1:
...     print("Yes it is!")
...
Yes, it is!

Only when the statements to be evaluated between the if and the colon evaluate to True will the indented statements below be visited by Python to be evaluated. The indentation indicates that the code that follows it is a part of the program but is executed only if the right conditions occur. For the if ... : statement, the proper condition is when the comparison being made evaluates to True.

You have just seen one of the most distinctive visual aspects of Python and the one that most people remark on when they encounter Python.

When you see the colon in Python programs, it's an indication that Python is entering a part of its program that is partially isolated from the rest of the program. At this point, indentation becomes important. The indentation is how Python knows that a particular block of code is separate from the code around it. The number of spaces used is important, and a Python-oriented programming editor will always carefully help you maintain the proper indentation for the code that is being written. The number of spaces is relevant, so it is important to use the editor to determine your indentation and not change the number of spaces manually.

You will see more keywords paired with the colon; and in all cases, you need to pay attention to the indentation. Python will warn you with an error if your program has changes in indentation that it doesn't understand.

You can place if ... : statements within the indentation of other if ... : statements to perform more complex decisions than what can be achieved with and and or because using if ... : enables you to perform any series of statements that you may need before evaluating the indented if ... : statement.

Try It Out: Placing Tests within Tests

Try the following example, in which one if ...: appears within another:

>>> omelet_ingredients = {"egg":2, "mushroom":5, "pepper":1, "cheese":1,
"milk":1}
>>> fridge_contents = {"egg":10, "mushroom":20, "pepper":3, "cheese":2,
"tomato":4, "milk":15}
>>> have_ingredients = [False]
>>> if fridge_contents["egg"] > omelet_ingredients["egg"]:
...    have_ingredients[0] = True
... have_ingredients.append("egg")
...
>>> print(have_ingredients)
[True, 'egg']
>>> if fridge_contents["mushroom"] > omelet_ingredients["mushroom"]:
...     if have_ingredients[0] == False:
...         have_ingredients[0] = True
...    have_ingredients.append("mushroom")
...
>>> print(have_ingredients)
[True, 'egg', 'mushroom']

How It Works

After a condition is tested with an if ...: and there is an additional level of indentation, Python will continue to evaluate the rest of the code that you've placed in the indentation. If the first if ...: isn't true, none of the code below it will be evaluated — it would be skipped entirely.

However, if the first if ...: statement is true, the second one at the same level will be evaluated. The outcome of a comparison only determines whether the indented code beneath it will be run. Code at the same level, or above, won't be stopped without something special happening, such as an error or another condition that would prevent the program from continuing to run.

As you can see from the print() functions, when Python checked to see if you had more eggs and mushrooms in your fridge than the omelet recipe called for, it appended those two items to your have_ingredients variable.

To complete the example, you could enter the rest of this (if you want to make a computer representation of an omelet):

>>> if fridge_contents["pepper"] > omelet_ingredients["pepper"]:
...     if have_ingredients[0] == True:
...        have_ingredients[0] = False
...    have_ingredients.append("pepper")
...
>>> if fridge_contents["cheese"] > omelet_ingredients["cheese"]:
...     if have_ingredients[0] == False:
...        have_ingredients[0] = True
...    have_ingredients.append("cheese")
...
>>> if fridge_contents["milk"] > omelet_ingredients["milk"]:
...     if have_ingredients[0] == True:
...        have_ingredients[0] = False
...    have_ingredients.append("milk")
...
>>> if have_ingredients[0] == True :
...     print("I have the ingredients to make an omelet!")
...
I have the ingredients to make an omelet!

You can create a chain of tests beginning with if ... : using elif ... :. elif ... : enables a variety of conditions to be tested for but only if a prior condition wasn't met. If you use a series of if ... : statements they will all be executed. If you use an if ... : followed by an elif ... :, the elif ... : will be evaluated only if the if ... : results in a False value:

>>> milk_price = 1.50
>>> if milk_price < 1.25:
...     print("Buy two cartons of milk, they're on sale")
... elif milk_price < 2.00:
...    print("Buy one carton of milk, prices are normal")
... elif milk_price > 2.00:
...     print("Go somewhere else!  Milk costs too much here")
...
Buy one carton of milk, prices are normal

There is also a fall-through statement that you can insert to handle those cases where none of the prior tests resulted in a True value: the else: statement. If none of the if ... : or elif ... : statements have test conditions that evaluate to True, the else: clause is invoked:

>>> OJ_price = 2.50
>>> if OJ_price < 1.25:
...    print("Get one, I'm thirsty.")
... elif OJ_price <= 2.00:
...    print("Ummm... sure, but I'll drink it slowly.")
... else:
...     print("I don't have enough money.  Never mind.")
...
I don't have enough money.  Never mind.

Repetition

You have seen how many times every element in a sequence, or every element in a dictionary, needs to be examined and compared. Doing this manually is impossibly boring and error prone for a person, even a fast touch-typist. In addition, if you enter these things in manually, you'll be caught off guard when the inevitable typo happens, or when something that you're evaluating is changed elsewhere, and your manually entered code can't easily accommodate that change.

To perform repetitive tasks, Python offers two kinds of repetition operations. Both are similar — in fact, they're almost identical — but each one lets you think about what you're doing differently so each one should have its place in your skill set.

How to Do Something — Again and Again

The two operations that enable you to initiate and control repetitive tasks are the while and for operations. The while operation tests for one truth condition, so it will be referred to as while ... :. The for operation uses each value from within a list, so it will be referred to as for ... in ... :.

The while ... : operation will first check for its test condition (the ... between the while and the :) and if it's True, it will evaluate the statements in its indented block a first time. After it reaches the end of its indented block, which can include other indented blocks, it will once again evaluate its test condition to see whether it is still True. If it is, it will repeat its actions again; however, if it is False, Python leaves the indented section and continues to evaluate the rest of the program after the while ...: section. If names are used in the test condition, then between the first repetition and the next (and the next, and so on), the value referred to by the name could have changed and on and on until there is some reason to stop.

Try It Out: Using a while Loop

>>> i = 10
>>>while i > 0:
print("Lift off in:")
print(i)
i=i - 1

Lift off in:
10
Lift off in:
9
Lift off in:
8
Lift off in:
7
Lift off in:
6
Lift off in:
5
Lift off in:
4
Lift off in:
3
Lift off in:
2
Lift off in:
1

How It Works

In the preceding code, you create a variable named i and assign it the value of 10 (note that the variable could have any legal name). Next, you create a while loop that states "While the value of i is greater than 0, do this." You then have Python print the sentence Lift off in: followed by the current value of i. Finally, you deduct −1 from i each time through the loop, causing the sequence to occur over and over until the value of i is equal to 0.

Doing this the other way, with the for ... in ... : form of repetition, is, as shown before, very similar to the while ... : form, but it saves you a couple of steps. In the first part, the for ..., you once more assign a variable name (again you use i, a common practice, because it is short for index). In the second part, the in ... : part, you provide a sequence, such as a list, tuple, or in this course, a range, which takes each element and assigns the value of the element to the name you provided in the first part:

>>> for i in range(10, 0, −1):
print("T-minus: ")
print(i)
...
T-minus:
10
T-minus:
9
T-minus:
8
T-minus:
7
T-minus:
6
T-minus:
5
T-minus:
4
T-minus:
3
T-minus:
2
T-minus:
1

As you can see, this works in a very similar method to your while loop, giving you just about the same results (it would have returned the same exact results had I not changed the text to be printed). This version of the for loop is a bit more complicated. For an easier version, try this code:

>>>for i in range(10):
print(i)
...
1
2
3
4
5
6
7
8
9

Here, you simply tell the for loop to iterate or repeat the process until i is equal to ten. Because you are working with range, it automatically adds one to your variable, causing the program to run once and loop nine more times.

Stopping the Repetition

The common term infinite loop refers to a sequence of code that will repeat forever. A simple example just sets up a while ... : statement that tests against something that is always going to result in True. For instance, just using True will always work. You should not type in the following code, because it's the kind of thing that's better to see than to have to do yourself:

>>> while True:
...     print ("You're going to get bored with this quickly")
...
You're going to get bored with this quickly
You're going to get bored with this quickly
You're going to get bored with this quickly
You're going to get bored with this quickly
You're going to get bored with this quickly

The preceding code continues forever, or until you break out of it. Inconvenient as it seems at first glance to have something that repeats forever, sometimes you may want this — for instance, repeating code is useful in a program that waits for the user to type something in, and when the user is done, returns to waiting.

However, sometimes you will want to know that if certain conditions are met, such as the right time of day, when the water has run out, when there are no more eggs to be made into omelets, and so on, that the repetition can be broken out of even when there is no explicit test in the top of the while ... : or when the list that's being used in the for ... in ... : doesn't have an end.

Infinite loops can be exited by using the break statement. When you try this out, make sure your indentation matches what's on the page:

>>>age=0
>>> while True:
how_old=input("Enter your age: ")
if how_old=="No":
    print("Don't be ashamed of your age!")
    break
num=int(how_old)
age=age+num
print("Your age is :")
print(age)
print("That is old!")
...
Enter your age: 1
Your age is :
1
That is old!
Enter your age: 2
Your age is :
3
That is old!
Enter your age: −3
Your age is :
0
That is old!
Enter your age: 50
Your age is :
50
That is old!
Enter your age: No
Don't be ashamed of your age!
>>>

In the preceding program, While, as you may recall, is always equal to True; therefore, the statement while True will always loop if left to its own devices. To solve this, you prompt the user for some info; in this case, their age. So long as they enter in a number, the program will add it to their age, giving them a total age and making it appear that they are getting older (unless they are savvy and enter in a negative number, in which case they will get younger!). If they enter only numbers, the program will run forever. However, if they ever enter in the string, No, the program will print Don't be ashamed of your age! and break out of the loop.

Note the position of the print statement and the break; if you place the print after the break instead of before, it will execute every time the program loops, instead of just when you break out of the loop. So be careful where you place your statements!

If you use break, it will only take you out of the most recent loop — if you have a while ... : loop that contains a for ... in ... : loop indented within it, a break within the for ... in ... : will not break out of the while ... :.

Both while ... : and for ... in ... : loops can have an else: statement at the end of the loop, but it will be run only if the loop doesn't end due to a break statement. In this case, else: could be better named something like done or on_completion, but else: is a convenient name because you've already seen it, and it's not hard to remember.

Try It Out: Using else While Repeating

>>> for food in ("pate", "cheese", "crackers", "yogurt"):
...     if food == "yogurt":
...            break
... else:
...    print("There is no yogurt!")
...
>>> for food in ("pate", "cheese", "crackers"):
...     if food == "yogurt":
...            break
... else:
...    print("There is no yogurt!")
...
There is no yogurt!

How It Works

In each example, there is a test to determine whether there is any yogurt. If there is, the while ... : is terminated by using a break. However, in the second loop, there is no yogurt in the list, so when the loop terminates after reaching the end of the list, the else: condition is invoked.

There is one other commonly used feature for loops: the continue statement. When continue is used, you're telling Python that you do not want the loop to be terminated, but that you want to skip the rest of the current repetition of the loop, and if you're in a for ... in ...: loop, re-evaluate the conditions and the list for the next round.

Try It Out: Using continue to Keep Repeating

>>> for food in ("pate", "cheese", "rotten apples", "crackers", "whip cream",
"tomato soup"):
...     if food[0:6] == "rotten":
...        continue
...    print("Hey you can %s" % food)
...
Hey, you can eat pate
Hey, you can eat cheese
Hey, you can eat crackers
Hey, you can eat whip cream
Hey, you can eat tomato soup

How It Works

Because you've used an if ... : test to determine whether the first part of each item in the food list contains the string "rotten", the "rotten apples" element will be skipped by the continue, whereas everything else is printed as safe to eat.

Handling Errors

You have seen examples of how Python reports errors in Chapter 2 and Chapter 3. Those errors usually contain a lot of information pertaining to what failed and how:

>>> fridge_contents = {"egg":8, "mushroom":20, "pepper":3, "cheese":2,
"tomato":4, "milk":13}
>>> if fridge_contents["orange juice"] > 3:
...     print("Sure, let's have some juice!")
...
Traceback (most recent call last):
  File "<pyshell#3>", line 1, in <module>
    if fridge_contents["orange juice"] > 3:
KeyError: 'orange juice'

Oops. There is no orange juice in the fridge right now, but it would be nice to be able to learn this without having to crash out of the program.

You have already learned one way to find out about the keys that are present in a dictionary, by using the keys method of the dictionary and then searching through the list of keys to determine whether the key you want is present. However, there's no reason not to take a shortcut. The last line of the error shown in the preceding code is:

KeyError: 'orange juice'

This says that the error Python encountered was an error with the key in the fridge_contents dictionary. You can use the error that Python has told you about to brace the program against that particular class of error. You do this with the special word try: telling Python to prepare for an error.

Trying Things Out

A try: statement sets up a situation in which an except: statement can follow it. Each except: statement handles the error, which is formally named an exception that was just raised when Python evaluated the code within the try: statement instead of failing. To start with, use except: to handle one type of error — for instance, the KeyError that you get when trying to check the fridge.

Multiple kinds of exceptions exist, and each one's name reflects the problem that's occurred and, when possible, the condition under which it can happen. Because dictionaries have keys and values, the KeyError indicates that the key that was requested from a dictionary isn't present. Similarly, a TypeError indicates that while Python was expecting one type of data (such as a string or an integer), another type was provided that can't do what's needed.

In addition, when an exception occurs, the message that you would have otherwise seen when the program stops (when you run interactively) can be accessed.

When you've learned more, you'll be able to define your own types of exceptions for conditions that require it.

You have only one line in which to handle the error, which may seem restrictive, but in Chapter 5 you learn how to write your own functions so you can handle errors with more flexibility.

>>> fridge_contents = {"egg":8, "mushroom":20, "pepper":3, "cheese":2,
"tomato":4, "milk":13}
>>> try:
...     if fridge_contents["orange juice"] > 3:
...         print("Sure, let's have some juice!")
... except KeyError:
...     print("Awww, there is no juice. Let's go shopping!")
...
Aww, there's no juice.  Lets go shopping

You may find that you need to print more information about the error itself, and this is the information that you have access to.

Try It Out: Creating an Exception with Its Explanation

>>> fridge_contents = {"egg":8, "mushroom":20, "pepper":3, "cheese":2,
"tomato":4, "milk":13}
>>> try:
...     if fridge_contents["orange juice"] > 3:
...        print("Sure, let's have some juice")
... except (KeyError)as error:
...    print("Woah!  There is no %s" % error)
...
Woah!  There is no 'orange juice'

How It Works

Because there is no key in the fridge_contents dictionary for "orange juice", a KeyError is raised by Python to let you know that no such key is available. In addition, you specified the name error, which Python will use to reference a string that contains any information about the error that Python can offer. We achieve this by using the as keyword to assign the value of the KeyError to error. In this case, the string relates to the key that was requested but not present in the fridge_contents dictionary (which is, again, "orange juice").

There may be times when you handle more than one type of error in exactly the same way; and in those cases, you can use a tuple with all of those exception types described:

>>> fridge_contents = {"egg":8, "mushroom":20, "pepper":3, "cheese":2,
"tomato":4, "milk":13}
>>> try:
...     if fridge_contents["orange juice"] > 3:
...        print("Sure, let's have some juice")
... except (KeyError, TypeError)as error:
...    print("Woah!  There is no %s" % error)
...
Woah!  There is no 'orange juice'

If you have an exception that you need to handle, but you want to handle it by not doing anything (for cases in which failure isn't actually a big deal), Python will let you skip that case by using the special word pass:

>>> fridge_contents = {"egg":8, "mushroom":20, "pepper":3, "cheese":2,
"tomato":4, "milk":13}
>>> try:
...     if fridge_contents["orange juice"] > 3:
...        print("Sure, let's have some juice")
... except (KeyError) as error:
...    print("Woah!  There is no %s" % error)
... except (TypeError):
...     pass
...
Woah!  There is no 'orange juice'

There is also an else: clause that can be put at the end of the try: block of code. This will only be run when there are no errors to be caught. Like before, else may not be the obvious choice for a name that could better be described as "in case it all works" or "all_clear" or something like that. By now, however, you can see how else: has become a flexible catch-all that means "in case something happens" although it's not consistent. In any case, it's there for you to use.

Summary

In this chapter, you learned about the methods for making decisions that Python offers. Any operation that results in True or False can be used by if ... : statements to determine whether a program will evaluate an indented block of code.

You have seen for the first time the important role that indentation plays in Python programs. Even in the interactive Python shell the number of spaces in the indentation matters.

You now have the knowledge to use sequence and dictionary elements in repetition loops. By using repetitions, you can perform operations on every element in a list and make decisions about the values of each list element.

The two types of repeating loops that Python offers you are the while ... : loop and the for ... in ... : loop. They perform similar jobs, continuing until a condition causes them to finish. The difference between the two lies in the conditions that will permit them to evaluate their indented block of code. The while ... : loop only tests for True or False in its test case, while the for ... in ... : loop will take a sequence you provide in the in ... : section, and each element from first to last in the sequence will be assigned to the value provided in the for ... section.

Both types of repeating loops can be exited before their test conditions are met by using the break operation. The break operation will cause the loop that is being evaluated to stop without further evaluations of any more code in the loop's code block. However, if a break operation is performed, the optional else: condition for a loop will not be run. In addition to break is the continue operation, which will skip the rest of the current loop but return to the top of the loop and evaluate the next test case.

You also learned about one other kind of decision making, which is handling the exceptions that Python uses to report errors. These exceptions are how any error is reported. If they are not accommodated, these errors will result in your program stopping at the point at which the error occurred. However, if you enclose code that may cause an error in a code block indented beneath a try: you can specify how to prevent the program from exiting, even going so far as handling the error and continuing with the program. The errors that you anticipate encountering will be specified in the except ... : clause, where the first value provided defines the type of the error (or types if a tuple of error types is provided); and, optionally, the word as followed by a name used to refer to data containing information about the error, can be provided.

The key things to take away from this chapter are:

  • You can test for equality using two equal signs (==). If the answer is True, True will be returned. If False, False will be returned. Double equals can also be used to determine if two variables hold the same data.

  • If you need to know if two values are not equal, you can use the not equal operator (!=). In this instance, True means that the values compared are not equal and False means that the compared values are equal.

  • To compare if a value is greater or less than another value, you can use the greater than (>) and less than (<) operators, respectively. If you need to know if a value is equal to or greater/lesser than, you would use the greater- than-or-equal-to operator (>=) or the less-than-or-equal-to operator (<=).

  • If you need a program to make a decision based on if a value is true or false, you can use the if statement, which simply states, if this is true, do that. To have your program do something if one value is true, and something else if it is not, you can use if...elif.

  • Sometimes you will need to loop through a certain action a number of times. Using the while loop, you can repeat or iterate the action for as long as the while condition equals true, or literally speaking, while this is true, do this.

  • If you need to loop through an action a set number of times, you can do so using the for loop, which uses a loop counter to tell how many times to repeat a given action.

  • A try: statement sets up a situation in which an except: statement can follow it. Each except: statement handles the error, which is formally named an exception that was just raised when Python evaluated the code within the try: statement instead of failing.

Exercises

Perform all of the following in the codeEditor Python shell:

  1. Using a series of if ... : statements, evaluate whether the numbers from 0 through 4 are True or False by creating five separate tests.

  2. Create a test using a single if ... : statement that will tell you whether a value is between 0 and 9 inclusively (that is, the number can be 0 or 9 as well as all of the numbers in between, not just 1-8) and print a message if it's a success. Test it.

  3. Using if ... :, elif,...: and else:, create a test for whether a value referred to by a name is in the first two elements of a sequence. Use the if ... : to test for the first element of the list; use elif ... : to test the second value referenced in the sequence; and use the else: clause to print a message indicating whether the element being searched for is not in the list.

  4. Create a dictionary containing foods in an imaginary refrigerator, using the name fridge. The name of the food will be the key, and the corresponding value of each food item should be a string that describes the food. Then create a name that refers to a string containing the name of a food. Call the name food_sought. Modify the test from Exercise 3 to be a simple if ... : test (no elif ... : or else: will be needed here) for each key and value in the refrigerator using a for ... in ... : loop to test every key contained in the fridge. If a match is found, print a message that contains the key and the value and then use break to leave the loop. Use an else ... : statement at the end of the for loop to print a message for cases in which the element wasn't found.

  5. Modify Exercise 3 to use a while ... : loop by creating a separate list called fridge_list that will contain the values given by fridge.keys. As well, use a variable named, current_key that will refer to the value of the current element in the loop that will be obtained by the method fridge_list.pop. Remember to place fridge_list.pop as the last line of the while ... : loop so that the repetition will end normally. Use the same else: statement at the end of the while loop as the one used at the end of Exercise 3.

  6. Query the fridge dictionary created in Exercise 3 for a key that is not present, and elicit an error. In cases like this, the KeyError can be used as a shortcut to determining whether or not the value you want is in the list. Modify the solution to Exercise 3 so that instead of using a for ... in ... : a try: block is used.

..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset
3.142.36.146