IT 116: Introduction to Scripting

IT 116: Introduction to Scripting
Class 10

Microphone

Questions

Are there any questions before I begin?

Homework 5

I have posted homework 5 here.

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

Today's Class

General Advice

Read the Material Before Class

Learning is an incremental process
It proceeds in steps
Some things you pick up quickly
Others take more time
But the more you are exposed to course material ...
the more you learn
Reading new material before class is useful
It prepares your mind for what you will learn in class
I will post the Class Notes for each class at Noon the day before class
If you read them before class ...
t will make my lectures more understandable

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

Here is an example

>>> while True:
...     print("Hello there!")
... 
Hello there!
Hello there!
...
Hello there!
^CTraceback (most recent call last):
  File "<stdin>", line 2, in <module>
KeyboardInterrupt
>>>

Because the boolean expression that controls this loop is the boolean literal True ...
this loop will go on forever ...
unless I stop it
On Unix, Macs and Windows machines you can stop a infinite loop ...
by hitting Control C
This 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 calculate 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 it 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's 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 only run if this expression is 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 greater than 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 Code block will not run if condition is false
`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 LOOP_VARIABLE 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 the name of the loop variable
Next comes the in keyword followed by a list of values
The first value in the list is assigned to the loop 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 loop variable
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 variable 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

It can be a string

$ 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 loop 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

In other languages the loop variable in a for loop ...
is always an integer
The for loop in Python is more powerful ...
because the loop variable and be any data type
But sometimes the loop variable needs to be an integer
I could manually create a list of integers like I did above
But what if we wanted to find the cubes of all the numbers from 1 to 100?
This is where the range function is comes in
You call the range function whenever you need a list of integers in a for loop

>>> 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
So a total of 10 integers were created
The same number as the argument given to range
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 other 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 what number is added to the last value in range ...
by using a third argument
This third argument is called the step value
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 integer 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 the job of creating integer loop variable values ...
from the for loop ...
to 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
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
This is a special feature of the print functions ...
that can be useful sometimes

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 total

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

So I'll use a list of integers instead

$ 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 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
```
>>> 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

Using `for` Loop to Create a Table

for loop can be used to create tables
I was interested in astonomy when I was teenager
Distances inside the solar system are measured in Astronomical Units (AU)
An AU is the distance from the sun to the Earth
Here is a table of the distances from the Sun of the 8 planets

Planet Distance from Sun in AU

Mercury 0.39

Venus 0.72

Earth 1

Mars 1.52

Jupiter 5.2

Saturn 9.54

Uranus 19

Neptune 30.o6
Distance to objects outside the solar system are measured in light years
In other words, how far light can travel in a year
There is a another measure of distance that is sometimes used
It is called the parsec ...
and it is used when measuring distances to an object ...
using paralax
A parsec is 3.26 light years ...
or 206,265 AU
Let's use a for loop to construct a conversion table ...
Showing values in parsecs ...
and the equivalent in light years and Astronomical Units

Planet	Distance from Sun in AU
Mercury	0.39
Venus	0.72
Earth	1
Mars	1.52
Jupiter	5.2
Saturn	9.54
Uranus	19
Neptune	30.o6

Here is our first attempt

for parsec in range(1,11):
   ly = 3.26 * parsec
   au = 206265 * parsec
   print(parsec, ly, au)

When we run this we get

1 3.26 206265
2 6.52 412530
3 9.78 618795
4 13.04 825060
5 16.299999999999997 1031325
6 19.56 1237590
7 22.82 1443855
8 26.08 1650120
9 29.339999999999996 1856385
10 32.599999999999994 2062650

Clearly we have to do something about the light year value ...

so let's apply round to the calculation

for parsec in range(1,11):
   ly = round(3.26 * parsec)
   au = 206265 * parsec
   print(parsec, ly, au)

This makes the table look much better

1 3 206265
2 7 412530
3 10 618795
4 13 825060
5 16 1031325
6 20 1237590
7 23 1443855
8 26 1650120
9 29 1856385
10 33 2062650

The output is still not great ...
because the values do not line up vertically
We can fix this by inserting a tab between each value
To do this we need to concatenate each number ...
with the escape sequence for a tab, \t
But you can't concatenate a number with a string ...
so we have to convert each number to a string
To keep things simple, I will create the new variable, line
Each line is a row of the table
It will hold numbers converted to strings ...

concatenated with a tab

for parsec in range(1,11):
   ly = round(3.26 * parsec)
   au = 206265 * parsec
   line = str(parsec) + "\t" + str(ly) + "\t" + str(au)
   print(line)

Which gives much neater output

1	3	206265
2	7	412530
3	10	618795
4	13	825060
5	16	1031325
6	20	1237590
7	23	1443855
8	26	1650120
9	29	1856385
10	33	2062650

But the numbers are meaningless without labels
So lets print these along with a line of dashes ...

before the loop

print("Parsec" + "\t" + "LYear" + "\t" + "AU")
print("----------------------")
for parsec in range(1,11):
   ly = round(3.26 * parsec)
   au = 206265 * parsec
   line = str(parsec) + "\t" + str(ly) + "\t" + str(au)
   print(line)

Which gives us our final result

Parsec	LYear	AU
----------------------
1	3	206265
2	7	412530
3	10	618795
4	13	825060
5	16	1031325
6	20	1237590
7	23	1443855
8	26	1650120
9	29	1856385
10	33	2062650

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