Mar 4, 2019 Notes

IT 211 -- Mar 4, 2019

Review Exercises

Explain what this statement means from Project 6:
```
new_photo_name = "{:s}/{:03d}-{:%s}". /
    format(folder_name, counter, original_photo_name)
```
Ans: "{:s}/{:03d}-{:%s}" is a format string and {:s}, {:03d}, {:%s} are format specifiers. Each time that a format specifier occurs in the format string, the corresponsing argument of the format method is entered in the output string. {:s} means that a str object will be included; {:03d} means that a decimal number with field width 3 with leading zeros will be included. The resulting string for the eiffel tower in paris is "paris/001-eiffel-tower.jpg"
Write python statements to do the following:
1. Create an empty dictionary. Ans:
```
d = { }
```
2. Add the new key-value pairs age: 35, id: 1234 Ans:
```
d["age"] = 35
d["id"] = 1234
```
3. Print the number of key-value pairs in the dictionary. Ans:
```
print(len(d))
```
4. Print all the key-value pairs in the dictionary. Ans:
```
for key in d:
    print(key, ":", d[key])
```
Suppose you have three persons, whose information you want to represent:

Variable name name gender age

child_alice "Ally" "F" 11

child_robert "Bob" "M" 9

child_susan "Sue" "F" 10

Represent this information as (a) three lists, (b) three tuples, (c) three dictionaries.
Ans: Here is the solution with the output.

Variable name	name	gender	age
child_alice	"Ally"	"F"	11
child_robert	"Bob"	"M"	9
child_susan	"Sue"	"F"	10

Classes and Objects

Reference: docs.oracle.com/javase/tutorial/java/concepts/object.html

In Exercise 3, we saw three ways to represent composite information about a child. In 2a and 2b, we could access each piece of information by index. In 2c, we could access each piece of information by key ("name", "gender", or "age"). Today we will look at a fourth way to represent this information: using classes and objects. Here is a script that does this for the three children:

# Create a Child class with no extra structure.
# pass means that there is no body for the class.
class Child:
   pass
   
# Create first Child object.
child_alice = Child( )
child_alice.name = "Ally"
child_alice.gender = "F"
child_alice.age = 11

# Create second Child object.
child_robert = Child( )
child_robert.name = "Bob"
child_robert.gender = "M"
child_robert.age = 9

# Create third Child object.
child_susan = Child( )
child_susan.name = "Sue"
child_susan.gender = "F"
child_susan.age = 10

# Print Child information.
print(child_susan.name)
print(child_alice.age)
print(child_robert.gender)

The advantage of classes is that they can not only contain information, but can also have methods.
We know about the builtin class str. It contains information, which is its characters, but also has methods:
```
s = "elephant"
print(s.upper( ))
print(s.count("e"))
print(s.find("ph"))
```
Real world objects share two characteristics: state and behavior. For example, a baby's state can be described by these properties (called instance variables in Python):
```
name   age   is_sleeping (True, False)

was_recently_fed (true, false)  mood ("smiling", "crying")

diaper_state (clean, soiled)
```
A baby's behavior can be described by the things he or she can do (called methods in Python):
```
drink   smile   sleep   move_arms   

kick   cry   wet_diaper
```
Properties should be pieces of data that vary from object to object. For example all live babies have a head, so the instance variable has_head is not very useful. age is a useful instance variable because the age of each baby (in months) is different.
Two other names for an instance variable in addition to property are attribute and field.
A class is the conceptual collection of all objects of a similar type, for example the class of all babies (class name Baby), the class of all basketball players (class name BasketballPlayer).
Class names are written in upper camel notation (Baby, BasketballPlayer, SavingsAccount, Bicycle).
Suggest instance variables and methods for each of these real world classes.
BasketballPlayer Coin

In Python a class can be used to create objects of that class by calling the new method. Here is how to create a new objects from the str, int, and list objects:

# Create three str objects:
s1 = "elephant"
s2 = str(3087)
s3 = str( )

# Create three int objects:
n1 = 3087
n2 = int("873")
n3 = int( )

# Create three list objects:
lst1 = [4, 2, 3, 1]
lst2 = list("dog")
lst3 = list( )

Python distinguishes between standalone methods and instance methods.
A standalone method is not called by an object, for example
```
n = len(s)
```
An instance method is called by an object of a class, for example
```
t = s.upper( )
```
In the Person Example, look at the Python user defined class Person in person.py and the test file in test.py.

Project 7

Look at the Project 7 Description.