Oct 19, 2020 Notes

IT 212 -- Oct 19, 2020

Review Exercises

Use kid data in the file kids.txt to do the following:

Create a two-dimensional array named kids that starts like this:
```
[['Connie', 'F', 8], ['Jacqueline', 'F', 14], ... ]
```
Sort the list alphabetically by rows:
```
kids.sort( )
```

The rows (lists) of the list of lists is used here like class objects without the instance methods. Ans:

kids_file = open("kids.txt", "r")

# Initialize two-d array (list of lists).
kids = [ ]

# Throw away first line
kids_file.readline( )

for line in kids_file:
    fields = line.strip( ).split(" ")
    row = [fields[0], fields[1], int(fields[2])]
    kids.append(row)

kids.sort( )
print(kids)
for k in kids:
    print(k)

we also looked at the older style with a loop that requires two readline statements, one before the loop starts and one at the the end of the loop:

kids_file = open("kids.txt", "r")

# Initialize two-d array (list of lists).
kids = [ ]

# Throw away first line
kids_file.readline( )

line = kids_file.readline( )
while line != "":

    fields = line.strip( ).split(" ")
    row = [fields[0], fields[1], int(fields[2])]
    kids.append(row)
    line = kids_file.readline( )

kids.sort( )
print(kids)
for k in kids:
    print(k)

More Magic Methods

Here is a website that describes more than 100 Python Magic Methods:
https://rszalski.github.io/magicmethods/
Two magic methods we have not yet discussed are __add__ and __mul__.
The int operators + and * invoke these these methods.

For example:

a = 3
print(a + 5, a.__add__(5))
print(a * 5, a.__mul__(5))
# Output
8 8
15 15

Of course, we do not normally call __add__ and __mul__ like this because they are private.

If we have time today, we will add + and * operators to this Pair class:

class Pair:

    def __init__(self, x, y):
        self.x = x
        self.y = y
        
    def __str__(self):
        return f'({self.x}, {self.y})'

Recall from your high school math classes that

(3, 4) + (5, 6) = (8, 10)
(3, 4) * 2 = (6, 8)

Dictionaries

A dictionary is a data structure similar to a list. Whereas in a list, items are stored and accessed by index, in a dictionary, items are stored and accessed by key.

A Python dictionary object is defined like this:

person = { "name" : "Alice", "gender" : "F", "age" : 11 }

A dictionary contains key-value pairs, for example "name":"Alice"; "name" is the key and "Alice" is the value.
To look up the gender of person, we use the key "gender" like this to look up the value "F":
```
value = person["gender"]
print(value)

# Output:
F
```
1. Extract the age of person using the key "age" and print it. Ans:
```
print(person["age"])
```
2. Add the cell phone number "312/456-7890" to person using the key "cell_number". Print person to verify the update.
Ans:
```
person["cell_number"] = "312/456-7890"
print(person)
```

Practice Problems:

Create a Python dictionary named spanish_number to store these key-value pairs:

Key	Value
"one"	"uno"
"two"	"dos"
"three"	"tres"
"four"	"quatro"
"five"	"cinco"

Ans:

spanish_number = {"one":"uno", "two":"dos",
    "three":"tres", "four":"quatro",
    "five":"cinco"}

english = input("Enter an English number: ")
if english in spanish_number:
    print("Spanish number: ",
        spanish_number[english])
else:
    print("Number not between 1 and 5")

Create a dictionary of Kid objects, where the names are the keys and the Kid objects are the values. Use the data in the kids.txt file. Then use your dictionary to answer this question: given a name input at the keyboard, what are gender and age of that person. Ans:

import kid
kids_file = open("kids.txt", "r")

# Initialize dictionary.
kids_dict = { }

# Throw away first line
kids_file.readline( )

for line in kids_file:
    fields = line.strip( ).split(" ")
    k = kid.Kid(fields[0], fields[1],
        int(fields[2]))
    kids_dict[fields[0]] = k

# print(kids_dict)
name = input("Enter a name: ")
if name in kids_dict:
    k = kids_dict[name]
print("Gender:" , k.gender, "Age:", k.age)
else:
    print("Name not in dictionary.")

Project 3b

Here is an example test3.py script that reads Pet objects from the input file pets.txt:

from pet import Pet

pets = [ ]
fin = open("pets.txt", "r")
# Throw away first line.
fin.readline( )
for line in fin:
    fields = line.split(",")
    p = Pet(fields[0], fields[1], fields[2],
        fields[3], fields[4], fields[5])
    pets.append(p)

pets.sort( )
print(pets)

Project 3c

Look at the Project 3c Description.
Look at the PetsDict Example.
Practice Problem 2: Design, implement, and test these classes (See the PetsDict Example):
```
Animal ← Pet
```
Here is an input file pets.txt with Pet information.
Each of these pets has its own Facebook page, with a list of followers shown in followers.txt.

Here is a script that loads Pet data into a dictionary with name as the key and Pet objects as the values:

from pet import Pet

# Create empty dictionary
pets_dict = { }

# Open input file
fin1 = open("pets.txt", "r")

# Throw away first line
fin1.readline( )

for line in fin1:
    fields = line.split(",")
    p = Pet(fields[0], fields[1], fields[2], \
        fields[3], fields[4], bool(fields[5].strip( )))
    pets_dict[fields[3]] = p

print(pets_dict)

Regular Expressions

A regular expression is used to check whether an input string has a specified form.
Use this table of Regular Expression Tokens to write regular expressions.
Some examples of regular expressions:
1. Five digit zipcode:
```
\A\d{5}\Z
```
2. Five digit zipcode with optional four digits:
```
\A\d{5}(-\d{4})?\Z
```
3. Python int constant:
```
\A-?[1-9]\d*\Z
```
4. Python local variable name using underscore notation:
```
\A[a-z_]([a-z0-9]_)*\Z
```
Use this website to test your regular expressions: Rubular Website.
If an input string contains a substring that matches the form of a regular expression, the regular expression is said to accept the regular expression.
You can also test whether regular expressions match input strings using Python:
```
# Import the Python regular expression module.
import re

reg_exp = << Your regular expression >>
input_str = << Your input string >>
print(re.match(reg_exp, input_str)
```
Output: None if there is no match; a match object representing the first match if there is at least one match.