Jan 28, 2019 Notes

IT 211 -- Jan 28, 2019

Review Exercises

What are the differences among these Python scripts?

# Script a 
x = 1 
y = 2
while x < 30 and y < 30:
    x = 2 * x + 3 * y    
    y = 3 * x + 2 * y
    print(f"{x} {y}") 

# Script b 
x = 1 
y = 2
while x < 30 and y < 30:
    print(f"{x} {y}")
    x = 2 * x + 3 * y    
    y = 3 * x + 2 * y 
    
# Script c
x = 1 
y = 2
while x < 30 and y < 30:
    x = 2 * x + 3 * y
    y = 3 * x + 2 * y 
print(f"{x} {y}")

# Script d
x = 1 
y = 2
print(f"{x} {y}")
while x < 30 and y < 30:
    x = 2 * x + 3 * y
    y = 3 * x + 2 * y

# Ans:  Variable trace:
  x    y
----+-----
  1    2
  8   28
100  356

# The output for Script a is
8 28
100 356 
The print statement is at the end of the loop in Script a.
the values 1 2 are not printed.

# The output for Script a is:
1 2
8 28
Ans: the print statement is at the beginning of the loop.
so the values 1 2 are printed but the final values are not printed.

# The output for Script c is:
100 356
The print statement is after the end of the loop, so
the final values are printed.

# The output of Script d is:
1 2
The print statement is before the beginning of the loop.
Only the initial values of 1 2 are printed. The computations 
in the loop here are wasted because nothing from it is printed.

Comparison and Logical Operators

The Python comparison operators are

<     Less than
>     Greater than
<=    Less than or equal to 
>=    Greater than or equal to
==    Equal to 
!=    Not equal to

A comparison operator returns a bool (True or False) value, depending on if the comparison is true or false.
For example 5 < 9 returns True, but 3 != 3 returns False.

Practice Problems: If a, b, and c are defined as:

w = 5
x = 3
y = 9

what are the values of these expressions?

1. x == x   
   Ans:  
   5 == 5
    True

2. w >= x  
   Ans:
   5 >= 3 
    True

3. y != (w + x)
   Ans:
   9 != (5 + 3)
   9 !=   8
     True

Look at the Trace5 Example . If necessary, use this operator precedence table.
The Python logical operators are
```
and  or  not
```
The truth tables for these logical operators:

and false true

false false false

true false true

or false true

false false true

true true true

not

false true

true false

Practice Problems.

What is the output?

a. True and True or False   
   Ans:
   and has higher precedence than or:
   (True and True) or False
         True or False
             True

b. True or True and False   
   Ans:
   and has higher precedence than or:
   True or (True and False)
       True or True
           True

For questions c and d, define
w = 5
x = 3
y = 9

c. w >= x and x != y
   Ans:
   5 >= 3 and 3 != 9
    True  and True
        True

d. x + 2 > w or w + x < 9 and False
   Ans:
   3 + 2 > 5 or ( 5 + 3 < 9 and False)
      False  or (   True and False)
      False  or    False
          False

e. int(y == x * 3) + int(w == x + 2)
   Ans:
   int(9 == 3 * 3) + int(5 == 3 + 2)
       int(True)  +  int(True)
         1        +     1
                  2

Look at Trace6 Example.

File Input and Output

Problem 1: Write a script that reads a name from the input file name.txt, constructs a greeting based on the name, outputs the greeting to the output file greeting.txt.

Answer to Problem 1, pseudocode:

open input file creating file object fin
read one name from input file
close input file
construct greeting "Hello, <name>, how are you?"
open output file creating file object fout
write greeting to output file
close output fil

Here is what you need to know for translating the pseudocode:
1. Open file for reading:
```
fin = open("name.txt", "r")
```
2. Read name from input file:
```
name = fin.readline( )
```
3. Close the input file:
```
fin.close( )
```
4. Construct greeting:
```
greeting = "Hello, " + name + ", how are you?"
```
5. Open output file:
```
fout = open("greeting.txt", "w")
```
6. Write greeting to output file:
```
fout.write(greeting)
```
7. Close output file:
```
fout.close( )
```

The complete script:

fin = open("name.txt", "r")
name = fin.readline( )
fin.close( )
greeting = "Hello, " + name + ", how are you?"
fout = open("greeting.txt", "w")
fout.write(greeting)
fout.close( )

Problem 2: The file numbers.txt contains a list of floating point numbers, one number per line. Write a script that reads these numbers one at a time, keeping track of the count and the sum of the numbers. When finished reading write the average of the numbers to the output file average.txt.

Answer to Problem 2, the pseudocode for computing average of a list:

initialize sum to 0.0
initialize count to 0
open input file
read next input line from input file
while not at end of list
    convert input line to float value
    update sum
    update count
    read next input line from keyboard
end
if count > 0
    compute average as sum / count
    write average to output file
else
    print to output file "No input values."
end
close input and output files

Here is what you need to know to translate the pseudocode:

Open file for reading:
```
fin = open("numbers.txt", "r")
```
Read line from input file:
```
line = fin.readline( )
```
Add the number in the line to the sum:
```
sum = sum + float(line)
```
Add one to the count:
```
count = count + 1
```
Close the input file:
```
fin.close( )
```
Open the output file:
```
fout = open("average.txt", "w")
```
Write the average to the output file:
```
fout.write("Average: " + str(average))
```
Close the output file:
```
fout.close( )
```

The complete script:

# Initialize summary variables.
count = 0
sum = 0.0

# Open input file.
fin = open("values.txt", "r")

# Input first value
line = fin.readline( )

# Continue to input values until the
# end of file is reached.
while line != "":
    value = float(line)

    # Update summary values
    sum += value
    count += 1

    # Input next value
    line = fin.readline( )

# Close input file
fin.close( )

# Open output file
fout = open("average.txt", "w")

# Compute and output average
ave = sum / count
fout.write(f"Average: {ave}\n")

# Close input file
fout.close( )

Sequential Processing

Sequential processing means to process the input values one at a time in the order of the inputs. The input values are not saved.
In many cases, sequential processing is used to obtain summary values of the dataset, such as a count, sum, product, average, minimum, or maximum.
Before beginning to process the inputs, the summary value must be set to an appropriate initial value. Here are some common initial values for summary values:

Summary Value Initial Value

count 0

sum 0.0

product 1.0

minimum First input value

maximum First input value
A sentinel is a special input value that indicates the end of the inputs. Common sentinel values for numeric inputs are 999, 9999, or -1. When the end of file is reached, and the script tries to read another line, an empty string ("") is automatically returned. This is the most commonly used sentinel for Python scripts.
Note: a Python script computes the sum of input values by keeping track of the partial total. For example, to add the list 2, 4, 7, 5, 3, the script would add like this:
Therefore, the sum is 21.

Summary Value	Initial Value
count	0
sum	0.0
product	1.0
minimum	First input value
maximum	First input value

The general form of a sequential processing loop:

summary_value = initial_value
get input_value
while input_value != SENTINEL
    update summary_value(s) using input_value
    get input_value  
end
output summary_value

Look at these sequential processing examples.
Practice Problems: Write Python scripts that print the requested information about the employees in the employees.txt input file.
1. Who is the oldest employee? What is his or her age?
2. The average salary of the desired city, where the desired city is entered at the keyboard.
3. Challenge Problem: what is the name and age of the second youngest employee?
4. Find the minimum, maximum, and average of the values of the exam_scores array:
```
exam_scores = [98, 79, 101, 83, 96]
```