IT 116: Introduction to Scripting

IT 116: Introduction to Scripting
Class 9

Microphone

Questions

Are there any questions before I begin?

Readings

If you have the textbook you should read Chapter 4, Repetition Structures, from Starting Out with Python.

Solution to Homework 3

I have posted a solution to homework 3 here.

Let's take a look.

Homework 5

I have posted homework 5 here.

It is due this coming Sunday at 11:59 PM.

Graded Quiz Today

After I finish talking I will pass out the papers for today's graded quiz.

Today's Class

Today I will discuss while loops and how they can be used.

General Advice

If You Fall Behind See Me

Most students at UMB have many demands on their time
They work many hours outside of school and take several courses
Under normal circumstances, most students can handle the load
But sometimes life throws you a curve
Things like
- A family emergency
- Health problems
- Issues at work
If this happens contact me as soon as it happens
Often I can help
But you need to do this as soon as you start to fall behind
If you wait until the end of the semester ....
there is much less that I can do to help

Tips and Examples

Comments

All scripts for this course must have a script comment at the top of the script
The comment should describe what the script does
I does not need to be longer than a single sentence
You don't need a comment on every line
That can actually make the script harder to read
Later on in the course you will learn how to write functions
Each function will need its own comment ...
that describes what the script does

Don't Use Whitespace at the Beginning of a Line

There are three characters that change the spacing of text
- Space
- Tab
- Newline
The newline character is what you get when you press Enter on a PC ...
or Return on a Mac
These characters are called whitespace
Most computer languages ignore whitespace
Except when it comes between words
Programmers will sometimes put extra whitespace in their code ...
to make it more readable
For example, putting blank lines between different sections of code
They do this knowing the extra whitespace does not affect how the code runs
But in Python, whitespace has meaning when it comes at the beginning of a line
Indentation is what Python uses to mark a code block
Do not put extra spaces before the start of a statement ...

unless it is part of a code block

>>>  a + 1
  File "<stdin>", line 1
  a + 1
  ^
IndentationError: unexpected indent

If you look carefully, you'll there is an extra space before the prompt above
Removing this space fixes the error
```
>>> a + 1
6
```

Converting Results to Integer

My homework assignments will often ask you to convert something to an integer
There are two situations where you will need to do this
- When using input to ask the user for an integer
- When converting a decimal (float) into an integer
The input function asks the user for a value
It always returns a string
So if you need an integer from the user ...
you must use the int function on the value returned by input
Converting a float to integer should be done by using the round function ...
with only one argument
There are two WRONG ways to make a decinal number an integer
The first to use the integer division operator, //
When using this operator, the decimal part of the result is thrown away
This makes the result less precise
We can see this when doing calculation using / and //
Let's convert Fahrenheit to Celsius using regular division
```
>>> fahrenheit = 41
>>> (fahrenheit - 32) / 1.8
5.0
```

If instead of using / we use // we get

>>> fahrenheit = 41
>>> (fahrenheit - 32) // 1.8
4.0

That value is way off ...
because integer division throws away the decimal part
The second wrong way to convert a float to an integer ...
is to use the int conversion function
This function also throws away the decimal part of a number
If we use int in calculating Celsius conversiton

we can get

>>> fahrenheit = 35
>>> int((fahrenheit - 32) / 1.8)
1

If we use round we get
```
>>>> round((fahrenheit - 32) / 1.8)
2
```
Let's see what we get if we use neither function
```
>>> (fahrenheit - 32) / 1.8
1.6666666666666665
```

Use Spaces before and after =

Spaces can be used to make the code more readable
One way to do this is to put a space ...
before and after every assignment operator
Python won't care if you use spaces ...
but your code will be easier to read
Compare this line
```
name=input("Please enter your name: ")
```

with this

name = input("Please enter your name: ")

Which would you rather read?

Review

Logical Operators

Each data type has its own set of operators
Logical operators work on boolean values and produce a boolean result
The logical operators are
- and
- or
- not
and returns True if both its operands are True
```
>>> 5 > 4 and 4 > 2
True
```
If either of its two operands are False, and returns False
```
>>> 5 > 4 and 4 < 2
False
```
It also returns False if both its operands are False
```
>>> 5 < 4 and 4 < 2
False
```
or returns True if either of its operands are True
```
>>> 5 > 4 or 4 < 2
True
```
It only returns False if both of its operands are False
```
>>> 5 < 4 or 4 < 2
False
```
The not operator takes only one operand
It reverses the value of that operand
So True becomes False
```
>>> not 5 > 4
False
```
And False becomes True
```
>>> not 5 < 4
True
```
To show how the logical operators work we use truth tables

Here is the truth table for and

p	q	p and q
`True`	`True`	`True`
`True`	`False`	`False`
`False`	`True`	`False`
`False`	`False`	`False`

and only returns True if both values are True

The truth table for or

p	q	p or q
`True`	`True`	`True`
`True`	`False`	`True`
`False`	`True`	`True`
`False`	`False`	`False`

or only returns False if both values are Fales
And the truth table for not

p not p

True False

False True

p	`not` p
`True`	`False`
`False`	`True`

Precedence of Logical Operators

Operator precedence determines which operators are evaluated first ...
when more than one operator appears in an expression
The logical operators, and, or and not have the lowest precedence
Their precedence is lower than arithmetic operators ...

and lower than the relational operators

**	Exponentiation
* / // %	Multiplication, division and remainder
+ -	Addition and subtraction
> < >= <= == !=	Relational Operators
not	Logical NOT
and	Logical AND
or	Logical OR

Checking Numeric Ranges with Logical Operators

A program should always check that input values make sense ...
before using them in a calculation
This is called data validation
Say you are writing a program to calculate retirement benefits
You need to ask the user for their age
But the age needs to be in a certain range
Your program should not accept age values of 1 or 200
We might want to make sure that the values were between 16 and 65
When we need to determine whether a value is inside a range ...
we use the and operator
```
age >= 16 and age <= 65:
```
If we wanted to determine whether a value is outside a range ...
we use the or operator
```
age < 16 or age > 65:
```

Boolean Variables

A boolean variable can only be True or False
Boolean variables are often used as flags
They are used to record a certain condition
that will be needed later in the code
Flags can make a program much more readable
A program to compute the price of a ticket might contain the following
```
minor = age < 10
senior = age > 65
```
You would then use these flags later in your program ...
to calculate the price of a ticket

Attendance

New Material

Loops

One of the most important structures in all of programming is the loop
The textbook calls loops repetition structures
A loop repeats a group of statements ...
under certain conditions ...
or a certain number of times
Whenever you need to do something over and over
You should use a loop
There are two types of loops
- Loops controlled by some condition
- Loops controlled by counting
Conditional loops will keep going as long as some condition is met
Counting loops keep track of the number of times the loop is run
They stop when this loop count reaches a certain value

`while` Loops

In Python there is only one conditional loop, the while loop
A while loop keeps repeating as long as a certain condition is True

It has the following format

while BOOLEAN_EXPRESSION:
    STATEMENT
    STATEMENT
    ...

A while loop stops when the boolean expression becomes False

Here is a silly example

$ cat question.py
# keeps asking a question until it gets the right answer

reply = ""
while reply != "yes" :
    reply = input("Are we there yet? ")
print("Yeah!")

$ python3 question.py
Are we there yet? no
Are we there yet? no
Are we there yet? no
Are we there yet? yes
Yeah!

The text marked in blue is entered by the user
We use a while loop whenever we do not know ...
how many times the loop should run
For example lets write a dumb guessing game
The code has a "secret" number which the user has to guess

The game keeps going until the user quesses the secret number

secret_num = 7

guess = 0
tries = 0

while guess != secret_num:
    guess = int(input("Your Guess: "))
    if guess == secret_num:
        print("Yes, the number is", secret_num)
    else:
        print(guess, "is not the number")
        tries  =  tries  + 1
        
print("You guessed correctly after", tries , "tries")

The loop keeps going until the user quesses correctly

When the loop is run, we have no idea how many time the code block will be executed

Your Guess: 4
4 is not the number
Your Guess: 2
2 is not the number
Your Guess: 5
5 is not the number
Your Guess: 7
Yes, the number is 7
You guessed correctly after 3 tries

User Input with `while` Loops

Whenever you do not know how long a loop should run ...
you should use a while loop
This can happen when you are getting input from a user
Let's say you wanted to add a series of numbers entered by the user
You don't know how many numbers the user needs to add ...
so after each number is entered ...
you ask the user if they are done
There are much better ways to do this ...

but this code shows how a while loop works

$ cat total.py
# add a series of numbers entered by the user
# demonstrates the use of a while loop

done  = "no"
total = 0
while done != "yes":
    number = int(input("Please enter a number: "))
    total  = total + number
    done   = input("If you are finished, enter yes: ")
print("Your total is", total)

$ python3 total.py 
Please enter a number: 4
If you are finished, enter yes: 
Please enter a number: 5
If you are finished, enter yes: 
Please enter a number: 6
If you are finished, enter yes: yes
Your total is 15

The text marked in blue is entered by the user
The condition in a while loop is evaluated before entering the loop
This is why we give the variable done a value before entering the loop
The loop would never be run if we set done to "yes"
In other computer languages there are other conditional loops
For example loops that test the condition ...
after the code block has been executed once
But Python only has the while loop ...
because it wants to be as simple as possible ...
and the other conditional loops are not strictly necessary
There is nothing these other loops can do ...
that Python can't do with the while loop

Infinite Loops

Something must happen in the code block of a while loop ...
that will make the boolean expression become False ...
or the loop will go on forever
This is called an infinite loop
Here is very simple while loop that prints the numbers from 1 to 5
```
num = 1

while num <= 5:
    print(num)
    num = num + 1
```
When we run it we get
```
1
2
3
4
5
```
This loop will always run to conclusion ...
because the code block increases numb ...
until it finally reaches 5
Here is another verson of this code ...

where num never changes

num = 1

while num <= 5:
    print(num)

When I run it, it will not stop
```
1
1
1
1
...
```
this loop will go on forever ...
unless I stop it ...
because nothing in the code block changes num
This is called an infinite loop
The only way to stop an infitine loop ...
by hitting Control C on the command line
Control C works Windows, Mac and Unix
But not in IDLE

Data Validation

The output of a program is only as good as its input
If you give a program bad input data ...
the output is worthless
There is a saying in data processing
```
Garbage in
Garbage out
```
This is sometimes abbreviated as "GIGO"
A lot of data is entered by people ...
and people often make mistakes
For example you might enter the value of a check you wrote ...
and leave out the decimal point
So instead of entering
```
$23.94
```
you enter
```
$2394
```
Errors like this are hard for a program to spot
Because you might write a check for $2,394
But it is often the case that valid data falls into a range
Think of a program that calculates average rainfall
You can never have negative inches of rain
You could also set an upper limit, say to 50 inches
You are unlikely to get that much rain ...
at least around here
Checking input to see that it is reasonable is called data validation

Data Validation Loops

while loops are often used to check values entered by the user
Let's say we wanted the user to enter an integer greater than 0
We would first ask the user for input ...
then test whether the value entered is greater than 0
If not, we would print an error message and ask for new input
This is an example of an algorithm
An algorithm is a step-by-step description of how to perform a specific task
A recipe is an example of an algorithm

Here is one way of writing the algorithm above

get number from user and store in a variable
convert this into integer
while value is not greater than 0:
    print error message
    get a new value from the user
    convert inot integer

This is an example of pseudocode
Pseudocode is a description of what the program will do ...
in language that mimics the structure of a computer program

Here is the Python program that implements this algorithm

$ cat validation.py
# this program asks the user to enter an
# integer greater than 0 and keeps asking
# until it gets a proper value
# it is an example of using a while loop
# for data validation

value = int(input("Please enter an integer greater than 0: "))
while value <= 0:
    print(value, "is not greater than 0")
    value = int(input("Please enter an integer greater than 0: "))
print(value, "is greater than 0")

$ python3 validation.py
Please enter an integer greater than 0: -3
-3 is not greater than 0
Please enter an integer greater than 0: 0
0 is not greater than 0
Please enter an integer greater than 0: 5
5 is greater than 0

Here we are assuming that the user has entered a string ...
that can be turned into an integer
In a real data validation situation we would test for this
But that requires features of Python that we have not yet discussed

An Improved Data Validation Loop

There is a problem with the code above
The statement asking the user for input appears twice
This violates the DRY rule
Don't Repeat Yourself
Repeated code makes a program longer
It can also cause problems if you change one repeated statement ...
but forget to change the other
We can get rid of the first input statement ...
if we make sure the code will enter the while loop
We can do this by setting a flag to False ...
and change the loop condition so it runs if the flag is not True
Inside the loop we ask the user for input and test it
We set the flag to True if the input is good

Here is the algorithm

set a flag to False
while the flag is not True
    get input from the user and store in a variable
    convert value to integer
    if the input value is valid
        set the flag to True
    else:
        print an error message

The flag tells the loop when we are done
So a good name for it is done

Here is code to implement the algorithm

done = False
while not done:
    value = int(input("Please enter an integer greater than 0: "))
    if value > 0:
        done = True
    else:
        print(value, "is not greater than 0")
print(value, "is greater than 0")

When we run this we get

$ python3 validation2.py
Please enter an integer greater than 0: -1
-1 is not greater than 0
Please enter an integer greater than 0: 0
0 is not greater than 0
Please enter an integer greater than 0: 5
5 is greater than 0

An Example of Input Validation

Let's say that you were writing a program to compute the body mass index
The body mass index tells you whether your weight is healthy or not
There are two inputs
- Height
- Weight
If the height is measured in inches and the weight in pounds
The formula for calculating BMI is
```
bmi = weight / height ** 2 * 703
```
We know a height cannot be 0
The tallest man in the Guinness Book of Records was Robert Wadlow
He measured 8 feet 11 inches or 107 inches
The heaviest man weighed 975 pounds
We can use these limits in a validation loops
A validation loop must be a while loop ...
because the loop only stops when a correct value is entered

Using these values we can write a BMI calculator that validates its input

$ cat bmi.py
# calculates the Body Mass Index using validation loops

done = False
while not done:
    height = int(input("Please enter your height in inches: "))
    if height <= 0 or height >= 107:
        print("Height must be greater than 0 and less than or equal to 107")
    else:
        done = True

print()

done = False
while not done:
    weight = int(input("Please enter your weight in pounds: "))
    if weight <= 0 or weight >= 975:
        print("Weight must be greater than 9 and less than or equal to 975")
    else:
        done = True

print()

bmi = weight / height ** 2 * 703
print("Your Body Mass Index is", round(bmi))

bmi = weight / height ** 2 * 703
print("Your Body Mass Index is", round(bmi))

$ python3 bmi.py
Please enter your height in inches: 0
Height must be greater than 0 and less than or equal to 107
Please enter your height in inches: 200
Height must be greater than 0 and less than or equal to 107
Please enter your height in inches: 60

Please enter your weight in pounds: 1000
Weight must be greater than 9 and less than or equal to 975
Please enter your weight in pounds: 0
Weight must be greater than 9 and less than or equal to 975
Please enter your weight in pounds: 150

Your Body Mass Index is 29

If the user enters a value that is in the proper range
The code never enters the while loop

Using a `while` Loop to Add Numbers

Consider the problem of adding positive integers
Positive integers are all the integers greater than 0
When adding numbers entered by a user ...
we have to know when to stop
Earlier in this class I did this in a clumsy way
After each number I asked the user it they were done
But there is another approach
We only want to add positive integers
If the user enters 0 or a negative number ...
we can use that as a signal to stop adding ...
and print the results
To prevent having to use two input statements ...
we will set the flag done to False ...
then keep looping until done is no longer False
But here we set done to True if the value entered by the user is 0 or less

Here is the code

# script to add positive integers using a while loop

done  = False
total = 0
while not done:
   num = int(input("Number: "))
   if num > 0:
      total =  total + num
   else:
      done = True
print("Total", total)

When we run the script we get

$ python3 while_add.py 
Number: 45
Number: 84
Number: 92
Number: 5
Number: 0
Total 226

Again, the numbers in blue are entered by the user

Compound Statements

The Python interpreter moves through a script one statement at a time
Many statements consist of a single line
- distance = speed * time
- rate = .05
- print("Hello world!")
A statement that can fit on a single line is called a simple statement
Notice that I said it can fit on a single line

A statement like this

distance = speed_of_vehicle * time_traveled_today \
    + distance_of_starting_point

Is spread out over two lines ...
but it could be written on a single line
At this point you have only see two kinds of simple statements
- Assignment statements
- Function calls
But all control structures have statements inside them
That means they cannot be written on a single line
Such statements are called compound statements