IT 212 -- Sep 21, 2020 Notes

IT 212 -- Sep 21, 2020

Review Exercises

Zoom Poll 3 Review Exercises. Correct answers are marked with *:
1. What is the output?
```
print(chr(0b00100011))
```
  *a. # b. $ c. % d. *
2. In this method definition
```
def f(n):
    return n * n
```
  the identifier n is a(n) ________ .
  a. argument b. local variable
  c. instance variable *d. parameter
3. What kind of method is open as invoked in this statement:
```
fin = open("input.txt", "r")
```
  a. instance method *b. standalone method
4. What kind of method is close as invoked in this statement:
```
fin.close( )
```
  *a. instance method b. standalone method
5. What is the Python name for a source code file?
  a. directory b. input file c. manifest *d. module

Rewrite the script from last week to put the definition of get_greeting in one module, and the line that invokes it in a different module:

def get_greeting(the_name):
    return "Hello, " + the_name + ", how are you?"
    
print(get_greeting("Larry"))

This is a traditional test of the get_greeting method.
Ans: here are the greeting and test1 modules:

# ----- Source code file: greeting.py 
def get_greeting(the_name):
    return "Hello, " + the_name + ", how are you?"

# ----- Source code file: test1.py 
from greeting import get_greeting
print(get_greeting('Larry'))

What is the difference between
```
# Method 1
from modulename import methodname
```
and
```
# Method 2
import modulename
```
Ans: with Method 1, the method does not need to be fully qualified. with Method 2, the method must be fully qualified by prefixing it with the module name. With Method 2, the test2.py module looks like this:
```
import greeting
print(greeting.get_greeting('Larry'))
```

Unit Tests

A unit test tests the smallest testable unit of the software to be tested.
A "smallest testable unit" for us is a method, either a standalone method or an object from a class.
One problem with a traditional hardcoded test is that the programmer must check the output of the script for correctness.
A unit test for a method compares the actual return value of a method with its expected return value.
For example, suppose we want to max standalone method. We set up these assertions to test the max method:
```
assertEqual(max(37, 71), 71)
assertEqual(max(11, 15), 15)
```
For each assert statement that is true, the unit test passes; for each assert statement that is false, the unit test fails.
To create a unit test file, start with Unit Test Template link in the navigation bar on the left of the Announcements Page.

Here is a complete unit test file that tests the stand alone method max:

import unittest

class TestStringMethods(unittest.TestCase):
        
    def test_2(self):
        assertEqual(max(37, 71), 71)
        assertEqual(max(11, 15), 15)
        
if __name__ == '__main__':
    unittest.main( )

# Output:
.
-----------------------------------------------------
Ran 1 test in 0.002s

OK

The conclusion is OK, so the test succeeded.

Practice Problems:
1. Rewrite the traditional test of the get_greeting method as a unit test.

Reading from Files

Modify this script so it writes its output to the output file output.txt instead of to the screen:

name = "Larry"
amt = 235.41
print(name + 'owes me $' + amt + ".")

# Ans:
name = "Larry"
amt = 235.41

# Method 2, concatenation.  fout.write only accepts one argument.
fout.write(name + " owes me $" + str(amt) + ".\n")
# Method 3, f-string.
fout.write(f"{name} owes me {amt}.\n")
fout.close( )

Modify the script further so that the name and amount are read from the input file input.txt, where the contents of the input file are

# Ans:
# Input file input.txt contents:
Larry,235.41

# Debugging print statements are
# commented out.
fin = open("input.txt", "r")
# print(type(fin))

line = fin.readline( ).strip( )
# print(line)

fin.close( )

fields = line.split(",")
# print(fields)

name = fields[0]
amt = float(fields[1])
# print(name, amt)
# print(f'{name} owes me ${amt}.')

fout = open("output.txt", "w")
fout.write(f'{name} owes me ${amt}.\n')
fout.close( )

Refactoring

Refactoring means change a source code script to that it is easier to understand or use without changing its functionality.
Here are some common refactoring techniques.
One important refactoring technique is method extraction.

Example: this script inputs a Celsius temperature, converts it to Fahrenheit, and prints the result.

1  input_string = input("Enter a Fahrenheit temperature: ")
2  cel = int(input_string)
3  fahr = 9 * cel // 5 + 32
4  print("Fahrenheit temperature:", fahr)

Extract the method and create a hardcoded test script: convert_cel_to_fahr from lines 2 and 3 of the preceding script. For these examples, a refactored method does not include any input or print statements. Also write a unit test to test the extracted method:

// ---- Module: convert.py
def convert_cel_to_fahr(input_string):
    cel = int(input_string)
    fahr = round(9 * cel / 5 + 32)
    return fahr

// ---- Module: test1.py
print(convert_cel_to_fahr(0))
print(convert_cel_to_fahr(100))
print(convert_cel_to_fahr(20))

// ---- Module: test2.py
import convert
import unittest

class MyUnitTestClass(unittest.TestCase):
        
    def test_1(self):
        self.assertEqual(convert_cel_to_fahr(0), 32)
        self.assertEqual(convert_cel_to_fahr(100), 212)
        self.assertEqual(convert_cel_to_fahr(20), 68)
       
if __name__ == '__main__':
    unittest.main( )

Practice Problems

Extract Methods Practice Problems

Project 2

See the Project 2 Description for the details of bowling rules and scoring.

Here is a ragged array that shows the pins knocked down in a bowling game:

["Frame0", [7, 2], [8, 2], [10], [10], [10], 
[10], [10], [9, 1], [10], [10], [7, 3]]

"Frame0" is prepended to the array as a placeholder for Frame 0, which is not actually a frame in a bowling game. This is so the index of the first frame [7, 2] is 1. What is the score for each frame? Ans:

Frame Number	Frame as Array	Frame Score
1	[7, 2]	9
2	[8, 2]	8 + 2 + 10 = 20
3	[10]	10 + 10 + 10 = 30
4	[10]	10 + 10 + 10 = 30
5	[10]	10 + 10 + 10 = 30
6	[10]	10 + 10 + 9 = 29
7	[10]	10 + 9 + 1 = 20
8	[9, 1]	9 + 1 + 10 = 20
9	[10]	10 + 10 + 7 = 27
10	[10]	10 + 7 + 3 = 20
Bonus	[7, 3]

The score for the entire game is the sum of all the frame scores, which is 235.

Write and test a method named framescore, which computes the score for a frame. Input parameters: frame, next_ball_1, next_ball_2. Remember that the score for a frame containing a strike is 10 plus the next two balls (two bonus balls); the score for a frame containing a spare is 10 plus the next ball (one bonus ball); the score for an open frame is the sum of the two balls in the frame with no bonus balls.