Lab 9: Dictionaries, Object-Oriented Programming, and Generating Graphs

Goals

After the lab, you should be proficient at

using dictionaries to solve problems
creating and testing your own classes from a specification
developing a larger program using a class to solve a problem
using a common third-party library to generate graphs

Objective: Review

Review the slides for today's lab.

Objective: Set Up

Run runHelpClient &
Copy /csdept/courses/cs111/handouts/lab9 and all of its contents (which means what command-line option should you use?) into your cs111 directory.
Copy test.py from lab8 into your lab9 directory.

Objective: Programming in Python

Your programs will be graded on correctness, style, efficiency, and how well you tested them. Make sure you adhere to the good development and testing practices we discussed in class. Your code should be readable and your output should be useful and well-formatted.

(10) Using a dictionary object, create a program that maps a letter to an example word that starts with that letter. You must have at least three entries in your dictionary. Then, print out the dictionary so that it looks similar to a children's book, and the keys are printed in alphabetical order. Example output looks like:
```
f is for fiddle
g is for goose
z is for zoo
```
(35) The most common last names for people in the United States are Smith, Johnson, and Williams. (Source: US Census) The most common first names for females are Mary, Patricia, and Linda and for males are James, John, and Robert. (Source: Social Security Agency)
In this program, you are going to determine the most common names for W & L students.

Your program will read in a text file of names (one name per line), count how many times each name occurs in the text file, and print out the names (in alphabetical order) and the number of times each name occurs. (Note that this problem is slightly simpler than what we did in class because we know that the only thing on a line in the file is the name.)

There are five data files in the data directory for you to process. File test.txt is provided as an easier first file to test. The remaining four files represent W&L undergraduate's last names, first names, female first names, and male first names.

Execute your code on one file. (Start with test.txt. Later, lastnames.txt file will be the easiest "real file" to check that your work is correct because the file is in alphabetical order.)
You can add the following code to your code to enable some "spot checks" for correctness. Note: the code may need to be modified slightly, depending on how you named variables.
```
      while True:
          name = input("What name do you want to check? ")
          if name in nameToCount:
              print(name, "occurs", nameToCount[name], "times.")
          else:
              print(name, "was not in the data.")
    
```
Hit Control-C to exit the while loop.

Next, to make later development a little simpler, refactor your code so that you have a function that takes the name of the file (a string) as a parameter. The function should process the file and return the generated dictionary. The main function should then display the (alphabetized) contents of the returned dictionary.

Finally, modify your main to call the function four times, once for each of the data files.

Don't save the output from this program--it's too much to print! Just look at the output yourself and verify that it makes sense.

While this is useful output, we can't easily determine the name that occurs most frequently, and we can't see trends in names' frequencies. Which leads us to...
(20) The reason we can't get the output we want from the previous program is because we can't tie the name and the number of occurrences together. We want to sort by number of occurrences, but, given the number of occurrences, we can't look up the name that has that number of occurrences. When we want to package and encapsulate data together, that calls for a new data type.

(We will tie this class into the last program in problem 4. For now, just focus on implementing this class.)

To address this issue, we will use the FrequencyInfo class. The file freq.py was provided for you when you copied the lab9 directory at the beginning of lab. The following specifies the class's attributes and methods.
Data:
- a string that represents the "thing" being counted (let's call that the key)
- a count that represents the number of times that the key occurred
Functionality:
- constructor - doesn't return anything. Takes as parameters a key and a count, and initializes the object's data.
  What is the method name associated with the constructor?
- string representation - returns a string that has the format: key count
  What is the method name associated with this method?
- getKey() - returns the FrequencyInfo's key
- getCount() - returns the FrequencyInfo's count
- updateCount() - increments the FrequencyInfo's count by 1
Testing the Class

Let's start by making sure that you understand how to use the class. Follow the examples in the main function in the Card class within the main function:
1. Create a few FrequencyInfo objects.
2. Print those objects.
Complete Implementing the Class
1. Complete the implementations of getKey() and getCount()
2. Test that those methods work.
3. Test that the updateCount() works. (How will you be able to verify that updateCount() works?)
For your output file, show that your tests work.
(25) Putting it all together.
This exercise illustrates how you can use Python to generate graphs. You will use your FrequencyInfo class to print out the name frequency results that can be used by another Python program to generate graphs.

Copy the second program for this problem. There are two alternatives for leveraging FrequencyInfos to solve the problem:
- (More object-oriented practice) Modify the program so that the dictionary maps the key (the name) to the value (the FrequencyInfo). When the program sees a name again, update the FrequencyInfo's count.
  Then, get the values from the dictionary, which you should make into a list of FrequencyInfos.
  OR
- Go through the dictionary, creating FrequencyInfos from the mappings, and adding them to a list.
After you have a list of FrequencyInfos:
1. Sort the list by the FrequencyInfo's count, following the example in the slides. In this case, the term "key" is overloaded. We were using "key" to refer to the "thing" we were counting. In sort "key" refers to the metric we're using to sort the objects.
2. Reverse the list so that the objects are in the order of greatest to least
3. Write the list to a file, one at a time, in the following format:
```
<name> <count>
```
  For example, an output file for male first names could look like
```
James 12
John 9
Robert 7
...
```
  The data above is not the correct values for the W&L data.
4. Save your output files for each input file in the data directory. You should name the summary files appropriately, such as female_fnames_freq.dat. (You can name the files either in your program or using Linux commands.) With proper use of functions and some string manipulation, you should be able to easily modify the program to process all four input files in one execution of the program.

Objective: Generating Graphs (5)

Now, we're going to use a Python program to create bar graphs of the data you generated from your programs using matplotlib, which is useful for generating lots of different kinds of graphs.

Run generateFreqGraphs.py or modify graphing_example.py to generate the graphs for each of your data files.

Show the top 5 results for each file type. In the case of a tie, show all the tied results.

Save the graphs in your data or public_html directory so that the images do not affect your printing later.

Example generated graph: Graph of the most frequently occurring last names at Washington
and Lee

Objective: Creating a New Web Page (5)

This part will be done individually. Do the pair turnin and then make sure both partners have all the code/files.

Go into your public_html directory.
Copy your lab2.html or index.html file to a file called lab9.html (in the public_html directory).
Review the copy command if necessary.
Copy the graphs you created in the last part into your public_html directory if they are not already there.
Modify the Lab 9 web page (using jedit) to have an appropriate, title, heading, and information.
Modify your Lab 9 web page to display the graphs you created. To change the size of the images you can use the width= attribute to make the graphs be a certain width in pixels, e.g., width=400
Add text describing each graph separately. What met your expectations? What surprised you?
Note: Do not display the "old" images from the original index.html or lab2.html pages. Your page should only contain content about this week's lab.
Modify your index.html page to link to your Lab 9 web page.

Finishing up: What to turn in for this lab

When you, as a pair, are ready to submit OR if you are at the end of the lab period, run pairturnin.sh labx partnerusername
where labx is the name of the lab you are submitting and partnerusername is your partner's username on the lab machines (the person whose account you are not using to write the code). For more information about the command, see the wiki.
If you want to copy your pairs' work into your cs111 directory--either just to have it or to work on your code on your own--use the script startup.sh. Run this command from the account that you want For example, run startup.sh labx partnerusername
where labx is the name of the lab you're working on and partnerusername is your partner's username on the lab machines.
For more info, see the wiki.
If you complete the lab on your own after the lab period, submit your lab into your turnin directory.
Remove any .pyc files and any graph files (*.png) files from the directory; otherwise, you'll get an error when creating the output file.

Perform the following steps from your cs111 directory.

Note that each command below links to a page with more information about using the command.

Create the printable lab assignment, using the createPrintableLab command:
createPrintableLab <labdirname>
View your file using the evince command.
Print the file using the lpr command.
Log out of your machine when you are done.

Labs are due at the beginning of Friday's class. You should hand in the printed copy at the beginning of class, and the electronic version should be in the turnin directory before class on Friday.

Ask well before the deadline if you need help turning in your assignment!

Grading (90 pts)

Python programs: 90 pts; see above for breakdown
Graphs: 5 pts
Web pages: 5 pts (both your index.html page and the lab9.html page)

CSCI111: Fundamentals of Programming I