While this data is provided as demographics (i.e. population numbers) and does not provide information on specific individuals, it is actual data collected about the real world relating to income inequality and hunger.

The data we will be wroking with are stored in a file as comma-separated values and is located at: /data/cs21/food_access/food_access.csv

Each line contains 25 fields separated by commas:

After the first 5 lines, the remainder of the file is made up of five parts, each containing four numbers. Each part describes food access based on a particular demographic group: households lacking vehicles, children, low-income individuals, all individuals, and seniors. Within each part, the four numbers refer to different distances (1/2 mile, 1 mile, 10 miles, 20 miles), and are counts of how many individuals in that demographic live further than the specified distance from the nearest supermarket.

A full description of the file format can be found here: Data set description link

Here are the first three lines and the last three lines from the file. Each column is separated by a comma.

Note that the lines are sorted alphabetically by county name (the first column).

In this lab we will focus on searching for records by county name, state, and population. A more interesting real-world application would likely allow the user to cross-reference the data and search for and/or display particular patterns or relationships in the data.

You will implement a program called search-food.py, which will allow the user to search through this dataset and find particular information.

Your program should read in data from a file, storing the information in the file about food access. The data you should read in is in the file: /data/cs21/food_access/food_access.csv. Recall that there is a smaller version of this file that may be useful for testing, called /data/cs21/food_access/food_access_small.csv.

Note: don’t copy this file into your cs21/labs/08 directory, just use /data/cs21/food_access.csv as the file name in your program.

As you read in the data, each line of the file corresponds to one record, which your program should represent using a FoodAccessRecord object, and store it in a list.

Your program should repeatedly present a menu to the user with three options for searching the data — by county, by state, or by population — and an option to quit. For example:

Depending on the user’s selection from the menu, your program should prompt the user for additional information, and do one of:

When searching by county name or by state, your program should compare data in lowercase format (so that user input is case insensitive), but display results with their original case.

County and state searches should also be done by prefix, meaning that as long as the name (either county or state, depending on the search) in the database starts with the string the user entered, it should be considered a match.

Details about how to adapt the search algorithms from class to achieve this are described below, in Adapting the search algorithms.

You should ensure that the user provides valid input at all prompts.

Use formatted printing to show the search results in a nice table format that fits an 80-character wide terminal window. This will require using methods from the FoodAccessRecord object to get information about each record. See the FoodAccessRecord object below for a list of methods you can use.

For population threshold searches, your program should ask the user to enter the minimum population they want to searh for, and your search should find any records where the total population (using the .get_population() method) is greater than the number entered by the user.

See Example 3 for the results of this search.

The version of linear search that we discussed in class stops as soon as it finds the item it is looking for, and returns the index of that item or -1 if not found. For this problem, your linear search will need to accumulate a list of matching results and return that.

In addition, the basic version of linear search assumes that you are searching a flat list. We will be searching a list of objects, so will need to adapt linear search to use method syntax to get at the data within each object.

When searching for state names, a food access record should be considered a match whenever the state name starts with the search string (e.g. using "New" should match both "New York" and "New Mexico"). You’ll want to use the .startswith method (see here) rather than == so it doesn’t miss any partial matches (such as matching "New York" with the search string "New").

To do case-insensitive search, you’ll also want to use the .lower method (see here) to convert both the target and the candidate match to lower case.

Because the data is sorted by county name, we can use binary search to very quickly locate a particular county. However, names can be somewhat long, so we’ll want to be able to search by prefix rather than complete string. Additionally, the data may contain multiple county names with the same name prefix, and our program should find and display all of them.

For example, there are six county names that start with the prefix "Allen":

Some fields in the data set are quite long. We can use slicing to truncate these strings to a fixed maximum length, allowing us to create an easy to read table format. This section of the online textbook explains how to slice a string. For instance, the following example using the REPL shows how to slice out the first 10 characters from a string:

Notice how this nicely works, even if we provide an upper bound that is longer than the string we’re trying to slice (unlike when dealing with lists):

Recall that with the % string formatting, you can specify the width of a field when printing, e.g. print("%10s" % ("hi")) will print "hi" with 8 spaces in front of it, so that it takes up a total of 10 characters in the display.

If it’s helpful, you can also use the - flag to get left-justified printing (the default is right-justified). For example:

Notice that the first format specifier, %-10s, produced "hi" followed by 8 spaces (so it takes up a total of 10 characters), and the second format specifier, %10s, produced "there" with 5 spaces in front of it (so that it also takes up a total of 10 characters).

Specifying the width also works with numbers. When displaying floats, we typically also specify the number of digits that should follow the decimal point. For example:

By combining these ideas, you can make your output look like a nice table where everything is aligned. For instance, to get the header shown in the example output, try:

Notice that several of the column labels shown here are abbreviations so it fits in 80 characters; "Total Pop" is the total population of the county, "LFA Pop" is the low food access population (i.e. the number of people too far from the nearest supermarket, via the .get_lfa_people method). Likewise, "Income", "Senior", and "Vehicle" are the counts for the various different groups that are too far from a market (see here for further details on how to get these numbers and what they represent). As mentioned above, for the statistics that have fields corresponding to multiple distances, you can use a distance of 1 mile (that is, for the getters that take a destance parameter, you can use 1).

Right now, the distance parameter is always set to 1 mile. Add a menu option to let the user set a different distance threshold (in miles) which you will then pass to the getter functions.

Prompt the user for a number of individuals with poor access to food, then use linear search to find all counties where the "distant population" is greater than the number given.

For even more challenge, try searching for counties that pass a specified ratio threshold (i.e. find counties where more than a given percentage of the population has poor access to food).

Note that you can do this for other numeric columns if you want.

Rather than importing the provided lookForwardBackward function, try writing your own. This should work the same way as the provided version: it will look linearly forwards or linearly backwards based on an initial seed index that it takes as a parameter. The function will also need to take the search string as an input parameter (as well as potentially other information depending on your design). This function should return a list of all the partial matches based on that initial seed index.

The program can then add that list together with the entry at the initial seed to compute the total list of partial matches which are then displayed to the user.

Remember to run handin21 to turn in your lab files! You may run handin21 as many times as you want. Each time it will turn in any new work. We recommend running handin21 after you complete each program or after you complete significant work on any one program.

When you’re done working in the lab, you should log out of the computer you’re using.

First quit any applications you are running, including your vscode editor, the browser and the terminal. Then click on the logout icon ( or ) and choose "log out".

If you plan to leave the lab for just a few minutes, you do not need to log out. It is, however, a good idea to lock your machine while you are gone. You can lock your screen by clicking on the lock icon. PLEASE do not leave a session locked for a long period of time. Power may go out, someone might reboot the machine, etc. You don’t want to lose any work!