IT 116: Introduction to Scripting

IT 116: Introduction to Scripting
Class 10

Microphone

Homework 5

I have posted homework 5 here.

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

Quiz 3

I have posted the answers to Quiz 3 here.

Questions

Are there any questions before I begin?

Review

Loops

One of the most important features in all of programming is the loop
The textbook calls loops repetition structures
A loop executes a number of statements over and over again
There are two types of loops
- Loops controlled by some condition
- Loops controlled by counting
In conditional loops, the code will keep looping ...
as long as some condition is True
Counted loop keep track of the number of times they run
They stop when they reach a certain value

`while` Loops

A while loop keeps repeating as long as its boolean expression is True

It has the following format

while BOOLEAN_EXPRESSION:
    STATEMENT
    STATEMENT
    ...

We use a while loop whenever we do not know ...
how many times the loop should run
The boolean expression is evaluated before entering the loop
The interpreter will not enter the loop if the boolean expression is False

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
On Unix machines you can stop a infinite loop by hitting Control C
It will abort the program

Data Validation

The output of a program is only as good as its input
There is a saying in data processing
```
Garbage in
Garbage out
```
A lot of data is entered by people ...
and people often make mistakes
Sometimes data must be within a certain range of values
For example rainfall can never be negative
So a program to average rainfall could check for that
You could also set an upper limit, say 50 inches
Because you are unlikely to get that much rain around here
The process of checking input is called data validation

Data Validation Loops

One common use of a while loop is in data validation
Let's say we wanted the user to enter an integer greater than 0

Here is an algorithm we can use to do this

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

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 code to implement the algorithm above

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

Compound Statements

The Python interpreter goes 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 two lines ...

but it could be written on a single line
So far you have only encountered two kinds of simple statements
- Assignment statements
- Function calls
In contrast, all control structures are compound statements
Compound statements contain other statements inside them
They cannot be written on a single line

Attendance

New Material

The `for` Loop in Python

The counted loop in Python is the for loop
But it works differently from the for loop in other computer languages
Let to see how these other for loops work

`for` Loops in Other Languages

Every language that I have ever studied has a for loop
These loops start with the keyword for ...
followed by three statements ...
usually enclosed in parentheses, ( )
These three statements work on a loop variable ...
which controls the loop
The first statement gives the loop variable its starting value
When we give a variable its first value ...
we say we have initialized the variable
The next statement is a boolean expression
The loop code will not run if this expression is not True
The third entry changes the value of the loop variable
This happens after the last statement in the code block has run
The loop variable must change or the loop will go on forever
Here is a Perl script that prints the numbers 1 to 10
```
for ($i = 1; $i <= 10; $i++) {
    print "$i\n";
}
```
In Perl all variable names must begin with a $ ...
statements must end with a ; ...
and code blocks must start with a { and end with a }
In the Perl loop above, the loop variable is $i ...
and it gets the initial value of 1
The boolean expression that follows tells the loop to stop ...
when $i becomes 10
The last statement increases the value of $i by 1
This change happens after the last line in the code block is executed ...
and before the loop variable is tested again

Here is a summary of the three entries

Entry	Purpose	When Run
`$i = 1`	Gives the loop variable its first value	Once, before the code block is run for the first time
`$i <= 10`	Decides whether the code block is run	Before running the statements in the code block
`i++`	Changes the value of the loop variable	After the last statement in the code block, but before running the loop test

`for` Loops

The counted loop in Python is the for loop

The for loop has the following format

for VARIABLE_NAME in LIST_OF_VALUES:
    STATEMENT
    STATEMENT
    ...

This loop is similar in structure to the while loop
It has a header which controls how many times it loops
Followed by an indented code block of statements
These statements are executed each time the loop runs
The for keyword is followed by a variable
Next comes the in keyword followed by a list of values
The first value in the list is assigned to the variable
It keeps that value while passing through the code block
When execution of the code block ends ...
the next value in the list is assigned to the variable ...
which it keeps while executing the statements in the code block
This continues until all values are used ...
at which point the loop ends
Here is a program that uses a for loop ...

to print the value of 2 raised to the powers of 1 to 10

$ cat powers_of_2.py 
# this program uses a for loop to print the powers of 2
# from 1 to 10

for number in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
    value = 2 ** number
    print("2 to the power", number, "is", value)

$ python3 powers_of_2.py 
2 to the power 1 is 2
2 to the power 2 is 4
2 to the power 3 is 8
2 to the power 4 is 16
2 to the power 5 is 32
2 to the power 6 is 64
2 to the power 7 is 128
2 to the power 8 is 256
2 to the power 9 is 512
2 to the power 10 is 1024

The exprssion
```
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
```
is a list
We will cover lists in an upcoming class
You can do everything with a Python for loop ...
that you can do with the for loop in other languages
But the Python for loops makes some things easier
In other languages the value of the loop variable must be an integer
But not in Python

The values of the loop variables can be a float

$ cat return.py 
# prints the return on $1000 for different rates of interest

principle = 1000
for rate in [.01, .02, .03, .04, .05, .06, .07, .08, .09]:
    new_value = principle * (1 + rate)
    print(f"""The return on $1000 at {rate:.0%} is ${new_value:.0f}""")

$ python3 return.py 
The return on $1000 at 1% is $1010
The return on $1000 at 2% is $1020
The return on $1000 at 3% is $1030
The return on $1000 at 4% is $1040
The return on $1000 at 5% is $1050
The return on $1000 at 6% is $1060
The return on $1000 at 7% is $1070
The return on $1000 at 8% is $1080
The return on $1000 at 9% is $1090

They can be strings

$ cat rainbow.py 
# prints the colors of the rainbow

print("The colors of the rainbow are")
for color in ["Red", "Orange", "Yellow", "Green","Blue", "Indigo", "Violet"]:
    print(color)

$ python3 rainbow.py 
The colors of the rainbow are
Red
Orange
Yellow
Green
Blue
Indigo
Violet

The values of the list variable can even be of different types

$ cat types.py 
# prints the type of different values

for value in [1, 1.0, "one", True]:
    print("The data type of", value, "is", type(value))

$ python3 types.py 
The data type of 1 is <class 'int'>
The data type of 1.0 is <class 'float'>
The data type of one is <class 'str'>
The data type of True is <class 'bool'>

The `range` Function

Creating the list of values is not hard if the list is short
But what if we wanted to find the cubes of all the numbers from 1 to 100?
Creating that list would be very tedious
So Python provides the range function to make this easy
The range function creates a special kind of list ...

that consists of a sequence of integers

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

Notice that the sequence of numbers started with 0
And ended with one less than the value of the argument
There is a reason why the range function works this way
But it won't make sense until you have learned about lists

Setting the First and Last Values with `range`

What if we wanted to print the numbers from 1 to 10?
The range function will do that if we give it two arguments instead of one
The first argument is the first value in the list
The second argument is one more than the last number in the list

If I wanted to print the numbers from 1 to 10, I would write

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

If I wanted to print the numbers from 11 to 20, I would write

>>> for number in range(11, 21):
...     print(number)
... 
11
12
13
14
15
16
17
18
19
20

Changing the Increment with `range`

In most languages the last statement in a for loop changes the loop variable ...
after the statements in the code block are run
Usually the loop variable just gets incremented by 1
But you can use any integer value ..
when changing the loop variable
This is true of the range function as well
If you call the range function with one or two arguments
Each value it creates is 1 more than the previous value
You can change this by giving range a third argument
The third argument is called the step value
It tells range how much to add to each value ...
to get the next number in the sequence
This means that I can print the even numbers

By giving 2 as the third argument to range

>>> for number in range(2, 11, 2):
...  print(number)
... 
2
4
6
8
10

To count by three, the third argument should be 3

>>> for number in range(3, 22, 3):
...     print(number)
... 
3
6
9
12
15
18
21

Reversing the `range` Values

In the code above all the numbers created by range were increasing
What if we wanted to go in the other direction?
You can do this if you make the 3rd argument to range negative
The third argument is the size of the step between one number and the next
By default the step value is 1
So to go in the other direction the step must be -1
What arguments should we use if we wanted to print the numbers from 10 to 1?
The first argument is the first number in the list
So the first argument would be 10
But what should the value of the second argument be?
Earlier I said that the value of the second argument ...
should be 1 more than the last value

Let's try 2 as the 2nd argument

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

Whoops
In truth, the value of the second argument is more complicated
The 2nd argument should be what you get if you added the step value ...
to the last number you wanted
We want the last number be 1
The value of the step is -1

So the second argument should be 0

>>> for number in range(10, 0, -1):
...   print(number)
... 
10
9
8
7
6
5
4
3
2
1

Why Does Python Have the `range` function?

Why does Python have the range function?

Here is a Perl script that lists all the even numbers from 2 to 10

$ cat perl_evens.pl
for ($i=2; $i <= 10; $i+=2) {
    print "$i\n";
}

$ perl perl_evens.pl
2
4
6
8
10

To do the same thing in Python you have to use the range function

>>> for number in range(2, 11, 2):
...     print(number)
... 
2
4
6
8
10

The range function in Python provides loop variable values
In Perl this is done by the 3 statements inside the parentheses
This makes Python more complicated than Perl
But Python values simplicity
What's going on?
Python moves creating the loop variable values from the for loop ...
into the range function
This makes the Python for loop more powerful
It can do the same things for loops do in other languages ...
but it will also work with lists ...
and anything that looks like a list

To print the teams in the American League East I would write

$ cat al_east_teams_1.py 
# prints the teams in the American league

print("Here are the teams in the American League East")
for team in ["Boston Red Sox", "Baltimore Orioles", "Toronto Blue Jays", "Tampa Rays", "New York Yankees"]:
    print(team)

$ python3 al_east_teams_1.py 
Here are the teams in the American League East
Boston Red Sox
Baltimore Orioles
Toronto Blue Jays
Tampa Rays
New York Yankees

`for` Loops that Don't Use the Loop Value

If I need a for loop to do something a certain number of times ...
I would use the range function ...
but I wouldn't use the numbers created by range ...
in the code block

For example, to cheer the Red Sox 5 times, I would write

>>> for number in range(5):
...   print("Go Red Sox!")
... 
Go Red Sox!
Go Red Sox!
Go Red Sox!
Go Red Sox!
Go Red Sox!

In this loop I did not use the value of number
I just used range to loop 5 times

Nested Loops

Just as you can have an if statement inside another if statement
You can have a loop inside another loop
When you have one loop inside another it is called a nested loop
You can nest either a for loop or a while loop
But nested for loops are more common
When you nest for loops you must use different names ...
for each loop variable
If you don't you will get very strange results

Here is a nested loop that creates a mutiplication table

$ cat times_table.py
# This script creates a times table using nested for loops

for row in range(1, 11):
    for column in range(1, 11):
        entry  = row * column
        print(entry, end="\t")
    print()

$ python3 times_table.py
1       2       3       4       5       6       7       8       9       10
2       4       6       8       10      12      14      16      18      20
3       6       9       12      15      18      21      24      27      30
4       8       12      16      20      24      28      32      36      40
5       10      15      20      25      30      35      40      45      50
6       12      18      24      30      36      42      48      54      60
7       14      21      28      35      42      49      56      63      70
8       16      24      32      40      48      56      64      72      80
9       18      27      36      45      54      63      72      81      90
10      20      30      40      50      60      70      80      90     100

With each pass through the outer loop row gets a new value
It keeps that value while the inner loop variable column changes from 1 to 10
The print inside the innermost loop may seem odd
I want each value of entry to print on the same line
This means I cannot have the print statement move down to the next line
To do this I supply the extra print argument end ...
and give it the value "\t" ...
which is the escape sequence for the Tab character
This means a Tab will be automatically printed after each argument value ...
instead of a newline
I use Tab instead of Space ...
since I want the individual entries to be aligned with the row above
I discussed this in Class Notes 6 ...
in the section labeled Using print without Going to a New Line
You do not need to know this for the exams

Totaling Numbers with a `for` Loop

for loops are often used to perform calculation with numbers
For example you might read in a list of numbers from a file ...
and compute the total

To do this we could use the following algorithm

set a variable total to 0
for each number in the list:
	add the number to the total

When this loop finishes, the total variable will hold the sum of all numbers
At the moment, you do not know how to read data from a file

So I use a list of integers instead in the following example

$ cat for_total.py 
# totals the numbers in a list

total = 0
for value in [56, 89, 43, 65, 32, 14, 57]:
    total = total + value

print(total)

The line inside the for loop tells Python to
- Get the value of total
- Add the current value of the loop variable value to total
- Set total to this new value

Finding the Average with a `for` Loop

for loops can also be used to find the average using the following formula
```
average = total/number_of_values
```
The algorithm to calculate averages ...
is built on top of the algorithm to calculate the total

Here it it

set a the variable total to 0
set the variable count to 0
for each number in the list:
	add 1 to the count
	add the number to the total
average = total/count

Here is an example

$ cat for_average_1.py 
# averages the numbers in a list

total = 0
count = 0
for value in [56, 89, 43, 65, 32, 14, 57]:
    count = count + 1
    total = total + value
average = total/count

print(average)

$ python3 for_average_1.py 
50.857142857142854

Of course it would be much better if we rounded the average
Say to 2 decimal places
We can do this using the Python round function
If we call round with one argument
It rounds that number to an integer
```
>>> round(56235.47553653)
56235
```
If we call round with a 2nd argument, an integer ...
it will round to the numer of decimal places given by this argument
```
>>> round(56235.47553653, 2)
56235.48
```

Here is a new version of the code above rounding to 2 decimal places

$ cat for_average_2.py 
# averages the numbers in a list

total = 0
count = 0
for value in [56, 89, 43, 65, 32, 14, 57]:
    count = count + 1
    total = total + value
average = round(total/count, 2)

print(average)

$ python3 for_average_2.py 
50.86

Only Two Loops in Python

Python only has two loop constructs
- while loops
- for loops
Other languages have more
But there is nothing these other loops can do ...
that can't be done with a for or while loop
So these other loops are not really needed
They are redundant
Python tries to be a simple as it can
So it does not have redundant features

Studying

Read the Material Before Class