Keep asking: numbers

In the last lesson, you learned how to keep asking the user for a text input until they gave a valid value. Now, let's ask them to type in a float, and keep asking until we get a good one.

I/O

Here's a sample of the I/O we want.

There are two types of errors users can make:

• Entering nonnumeric data. Lines 2 and 4 show what error message we want.
• Entering a number that's out of range, that is, too small or too big. See lines 6 and 8 show you the error message.

Asking one time

Here's the code we used earlier to validate that user input is numeric. The nonlooping version.

Line 2 gets data from the user.

Right.

Lines 5...

...tries to convert what the user typed (which is in user_input) into a float. It might fail, so we wrap line 5 in a try/except block.

If there's a ValueError - which is what we'll get if user_input isn't numeric - the code in the except block will run. It will output a message, and stop the program.

Checking for integers

Here's the code again:

This checks whether the user entered a float value, like 22.44. In an earlier lesson, we talked about integers. Integers are whole numbers. So 32 is an integer, but 3.2 is not.

This is from the earlier lesson:

Integers are primarily used for counting things. For example, if you're counting people, you have 23 people or 24 people, not 23.4 people. I wouldn't want 0.4 of a person at a party. Eeewwww.

Say we wanted users to tell us how many people were invited to a party. Here's some code:

Only one thing has changed: float has become int. Python has more data types, and strings can be converted into most of them. We'll only about the ones we need for this course.

Going loopy

We'll wrap the code in a while loop, just as we did for the string validation loop.

With string validation, there was one kind of error: not one of the valid options. Now, there are two kinds of errors people can make: nonnumeric and out-of-range.

However, in general, there can be any number of kinds of errors. For example, suppose you have an order form on a website. Customers enter the number of items they want to buy.

Vegemite is yummy! Well, to me.

Possible errors include:

• User types nonnumeric data.
• User types an out-of-range value, like -3 or 191,299,133.
• User types a number, but we don't have that many in stock.

Kinda, but the top value varies depending on inventory. Today, you can order up to, say, 58. Tomorrow, up to 42, because we sold some.

Business policies might mean we add other errors. For example, maybe new customers can only order up to 5 jars. So trying to order 6 might or might not be an error, depending on who's placing the order.

The point is, there can be any number of kinds of errors.

It'd be nice if we had a way to write a validation loop we could easily add and remove error tests.

A better way

Here's a way to do it that works well. Let's start with a pseudocode version.

We need a variable to keep track of whether the input is OK or not. Let's call it is_input_ok.

(Remember, this is not real code yet.)

Each time through the loop, we start by assuming the input is OK (line 3). Then we get the input from the user (line 4). Then we have a buncha tests. In each one, if there's a problem, we remember the data is bad.

By the time we get to the end of the loop's code block (after line 9 is done), we have only two possibilities for is_input_ok:

• If none of the tests shows the data is bad, is_input_ok will still be Yes. It's set to Yes in line 3, and never changes to No.
• If any of the tests show there's a problem, is_input_ok is No.

Then loop back to the while (line 2). If is_input_ok is No, run the loop again. Keep running it while is_input_ok is No.

Aye, that's it.

Let's look at a more Pythony version.

is_input_ok is a boolean variable. We have strings, floats, integers, and now we have another data type: boolean. Boolean variables can only be True or False. They're mainly used to remember whether something happened or not, like whether a program found an error in user input.

Let's break it down. Line 1...

... creates the variable and sets it to False. False is a boolean constant. There are only two boolean constants, since a boolean can only be true or false. Python wants the first letter of true and false to be uppercase. I don't know why.

Line 2...

... keeps running its code block until is_input_ok is True, that is, is not False. In English, it would be: while the input isn't OK.

We're about to do the first pass through this code:

Start by assuming the input we're about to get is OK (line 3). Get the input (line 4). Then a buncha tests, as many as we like. If any fail, do is_input_ok = False.

When the code block is done, go back up to the while (line 2):

If is_input_ok is False, ask the user again.

Aye. I like to explain things in small steps, though. There was enough new stuff in that lesson without adding booleans as well.

Here's the code from then, and a new version.

# Initialize service_level service_level = '' # Is the service level valid? while service_level != 'g' and service_level != 'o' and service_level != 's':     # Don't have a valid service level yet     # Ask user to input the service level     service_level = input('Service level (g=great, o=ok, s=sucked)? ')     # Normalize input     service_level = service_level.strip().lower()     # Is the service level valid?     if service_level != 'g' and service_level != 'o' and service_level != 's:         # Show error message         print('Please enter G, O, or S.')

is_input_ok = False while not is_input_ok:     # Start off assuming data is OK.     is_input_ok = True     service_level = input('Service level (g=great, o=ok, s=sucked)? ')     # Normalize service level     service_level = service_level.strip().lower()     # Validate service level     if service_level != 'g' and service_level != 'o' and service_level != 's':         is_input_ok = False         print('Please enter G, O, or S.')

Indeed. Using patterns, comments, and meaningful variable names help you with the deets. Managing your brain's load is important for programmers. The real name for "brain load" is cognitive load.

The next part of the course is about functions, another way of reducing cognitive load.

The flag pattern

is_input_ok is a flag variable. The word "flag" is used in various ways in programming. To keep it simple, we'll use it one way.

When you start a new project, you can use the pattern catalog to remind yourself of useful chunks of code.

Right. That's part of software cost and quality control.

Aye! That's exactly right! Breaking code into independent chunks makes life easier. The flag pattern helps with that.

Back to meal cost

OK, let's use this stuff to make a meal cost validation loop for the tip program. Remember, the pattern is:

Let's change it to Python.

Who wants to start?

Pseudocode	Python
is_input_ok = No While is_input_ok is No:     is_input_ok = Yes     Get input     if data is bad for some reason:         is_input_ok = No     if data is bad for some other reason:         is_input_ok = No     As many tests as we want	# Get the cost of the meal. is_input_ok = False while not is_input_ok:     # Start off assuming data is OK.     is_input_ok = True     # Get input from the user.     user_input = input('Meal cost? ')

Good! Now, we want to add two tests.

Right.

I'll add some comments to remind us.

Pseudocode	Python
is_input_ok = No While is_input_ok is No:     is_input_ok = Yes     Get input     if data is bad for some reason:         is_input_ok = No     if data is bad for some other reason:         is_input_ok = No     As many tests as we want	# Get the cost of the meal. is_input_ok = False while not is_input_ok:     # Start off assuming data is OK.     is_input_ok = True     # Get input from the user.     user_input = input('Meal cost? ')     # Is the input numeric?       # Check the range.

Who wants to do the range check?

Good!

Let's put it all together.

Pseudocode

Python

is_input_ok = No While is_input_ok is No:     is_input_ok = Yes     Get input     if data is bad for some reason:         is_input_ok = No     if data is bad for some other reason:         is_input_ok = No     As many tests as we want

# Get the cost of the meal. is_input_ok = False while not is_input_ok:     # Start off assuming data is OK.     is_input_ok = True     # Get input from the user.     user_input = input('Meal cost? ')     # Is the input numeric?     try:         meal_cost = float(user_input)     except ValueError:         print('Sorry, you must enter a number.')         is_input_ok = False     # Check the range.     if is_input_ok:         if meal_cost <= 0 or meal_cost > 1000000:             print('Sorry, please enter a number more than zero, and less than 1,000,000.')             is_input_ok = False

Done!

Patternism

A new pattern.

Summary

• A while loop can keep asking the user for input until it gets something valid.
• There are at least two kinds of errors people can make: nonnumeric and out-of-range.
• Use a variable as a flag. Set the flag if any of a number of things happens. After, check the flag to see if any of those things happened.

Exercise