IT 212 -- Oct 5, 2020

Review Exercises

What is the output?

a = ['club', 'diamond', 'heart', 'spade']
print(a[0][3], a[0][1], a[0][2], a[2][1], \
    sep='', end=' ')
print(a[1][0], a[3][4], a[1][3], a[1][4], \
    a[1][5], a[3][0], sep='')

Ans: blue demons. The first index is the string in the list. The second index is the letter in that string.

Work in Zoom breakout groups of 3 or 4 to design a BankAccount class. Think of instance variables and methods for a BankAccount class. Come up with about 8 instance variables and 5 instance methods.
Ans: Here are composite lists of BankAccount instance members that the breakout groups obtained:
Instance Variables: acct_number name balance email pin interest acct_type
Instance Methods: deposit withdraw add_interest __init__ __str__

The repr Method

The repr method is similar to the str method for a class.
Both methods return a string representation of the class.
Whereas str typically returns a user friendly string representation, repr is designed to return a technical string representation.
Python is the only commonly used language that has two different methods for converting an object to a string.
Java, JavaScript, and C# use toString; Ruby uses to_s.
Consider this code fragment:
```
s = 'apple'
print(str(s), repr(s))
```
The output is
```
apple 'apple'
```
apple is the user friendly representation; 'apple' is the technical representation.

Now create a Person class and a test module test1.py:

=== Module: person.py ======================
class Person:

    def __init__(self, name, gender, age):
        self.name = name
        self.gender = gender
        self.age = age

=== Module: test1.py =======================
from person import Person
p = Person("Bill", "M", 23)
print(str(p))
print(repr(p))

=== Output: ================================
<person.Person object at 0x032C1118>
<person.Person object at 0x032C1118>

The str and repr methods both return the same default representation of the object:
person is the module, Person is the class, and 0x032C1118 is the hex address of the Person object in computer memory.

Now add an __str__ method for the Person class:

def __str__(self):
    return f"{self.name};{self.gender};{self.age}"
    
# Output:
Alice;F;11
<person.Person object at 0x034B1118>

The default return values for the default str and repr methods are not very useful unless, maybe, you are a systems programmer.
For our Person class, str does not return the default output, but rather uses the __str__ method in the Person class to determine the output; no repr method is supplied so the default representation of the Person object is returned.

Now add this __repr__ method to the Person class and run the test1.py module again:

 def __repr__(self):
    return f"<{self.name};{self.gender};{self.age}>"

# Output:
Alice;F;11
<Alice;F;11>

The str method uses the __str__ method of the Person class to determine what to output; the repr method uses the __repr__ method of the Person class to determine what to output.
We can shorten the code for the __repr__ method by having it invoke the str method:
```
def __repr__(self):
    return f"<{str(self)}>"
```
Sometimes we want the str and the repr output to be the same. In this case, define __repr__ like this:
```
def __repr__(self):
    return str(self)
```

A List of Card Objects

Create a list of five Card objects called poker_hand: [QH, AS, JC, JH, JS].
Ans: Use the Card class from the Card Example defined in card.py. This is our first try:
```
from card import Card
c1 = Card(12, 'H')  # Rank of Queen is 12
c2 = Card(14, 'H')  # Rank of Ace is 14
c3 = Card(11, 'C')  # Rank of Jack is 11
c4 = Card(11, 'H')
c5 = Card(11, 'S')
poker_hand = [c1, c2, c3, c4, c5]
print(poker_hand)
```
This is the output:
```
[<card.Card object at 0x038440B0>, 
 <card.Card object at 0x03AA6950>, 
 <card.Card object at 0x03AA6970>, 
 <card.Card object at 0x03AA6910>, 
 <card.Card object at 0x03CCBF30>]
```
It turns out that when a list objects is printed like this: print(poker_hand), the __repr__ method is used by Python to display the individual objects in the list. Recall that, if we use the default repr method to print c2, which is the ace of hearts, we get
```
print(repr(c2))
# Output:
<card.Card object at 0x03AA6950>
```
This is the object from the Card class in the card module that is stored at the computer memory location 03AA6950 hex, which is not very useful for us. To get a more useful representation of the cards in the list, we need to define our own custom __repr__ method, which will be called in the print statement
```
print(repr(c2))
```

Add this method to our Card class:

def __repr__(self):
    return '<' + str(self) + '>'

and run the print statement again:

print(repr(c2))
# Output:
<AH>

Now print the list again:

from card import Card
c1 = Card(12, 'H') # Rank of Queen is 12
c2 = Card(14, 'H') # Rank of Ace is 14
c3 = Card(11, 'C') # Rank of Jack is 11
c4 = Card(11, 'H')
c5 = Card(11, 'S')
poker_hand = [c1, c2, c3, c4, c5]
print(poker_hand)
# Output:
[<QH>, <AH>, <JC>, <JH>, <JS>]

Now we get more useful output when printing the list because our custom __repr__ method is used when printing the list.

Practice Problem

Create a list of Card objects that contains the cards from a standard deck of playing cards (52 cards):

2C 3C 4C 5C 6C 7C 8C 9C 10C JC QC KC AC
2D 3C 4D 5C 6D 7C 8D 9C 10D JC QD KC AD
2H 3C 4H 5C 6H 7C 8H 9C 10H JC QH KC AH
2S 3C 4S 5C 6S 7C 8S 9C 10S JC QS KC AS

Ans:
# Add this __repr__ method to the
# Card class:
def __repr__(self):
    return '<' + str(self) + '>'

# Script to create list of cards that
# represents a standard 52 card poker deck.
from card import Card
cards = [ ]
for suit in ['C', 'D', 'H', 'S']:
    for rank in range(2, 15):
        card = Card(rank, suit)
        cards.append(card)
print(cards)

Sorting

To sort a list of items, use the sort instance method.

Sort these lists:

a = ['dog', 'gerbil', 'cat', 'rabbit', 'mouse']
b = [28, 15, 93, 31, 11, 10]
Ans:
a.sort( )
print(a)
b.sort( )
print(b)

What happens when you try to sort an array of Person objects?
We will answer this question next time.
To sort an array of user defined objects, define the dunder method __lt__ that defines a less than ( < ) operator for the class.
For example, to sort Person objects by age, use this __lt__ method:
```
def __lt__(self, other):
    return self.age < other.age
```

Here are traditional and unit tests for the Person < operator:

# Source code file: test1.py
from person import Person
p1 = Person("Alice", "F", 11)
p2 = Person("Bob", "M", 13)
print(p1 < p2, p2 < p1)

# Source code file: test2.py
from person import Person
import unittest

class MyUnitTestClass(unittest.TestCase):
    def test_1(self):
        self.assertEqual(p1 < p2, True)
        self.assertEqual(p2 < p1, True)
        
if __name__ == '__main__':
    unittest.main( )

What are name and main?

This section is optional. It explains the meaning of this if statement
```
if __name__ == '__main__':
    unittest.main( )
```
that is found at the end of the unit test scripts that we use in IT 212.
If a module is run using IDLE, its name is '__main__', stored in the __name__ variable, regardless of the actual module name.
To access the name of a module, use the value of the __name__ variable.
Example: run the module module1.py. The output is
```
Name of module: __main__
```
If a method in the module module2.py is not run directly, but instead invoked by module3.py, the name of the module contained in the __name__ variable for module2.py is module2.
Example: run the module module3.py, which invokes module2.py. The output is:
```
Name of module: module2
```
Now we can understand the meaning of this if statement at the end of a unit test script:
```
if __name__ == '__main__':
    unittest.main( )
```
If the unit test script is being run directly by Python so that __name__ == '__main__', execute the script, but don't execute the script if it is being invoked by another module.

Project 3a

Look at the Project 3a Description.