Please see prior weeks' discussion. Please remember that executing (i.e., running) a file is not done using the open command; instead it is done with the python (Windows) or python3 (Mac) command. Note: please don't return to your home directory during the above journey - use '..' when you need to travel to a parent directory.

1. The function takes 3 arguments -- a float, int and int. These are not taken from the user with input() inside the function. (You could use input() outside the function to make the program more reusable, but please don't call input() inside the function.
2. If either of the first two arguments (bill and number in party) is less than or equal to 0, the function uses raise to raise a ValueError exception. Use a compound test (i.e., "if arg1 is less than or equal to 0 or arg2 is less than or equal to 0") and if True, simply call raise as shown in examples this week. Include an error message indicating the problem.
3. The function calculates the tip. All of this is done inside the function.
4. The function returns one float using the return statement. Make sure you are not printing the value inside the function. The program must use the return statement to return the float from the function.
5. When your function is complete, please use the stub program to verify that 100, 4, 20 returns 30 and 150, 3, 15 returns 57.4.
6. Remember that the correct output from the last 2 calls is an exception. This will look like an error to you, but is not an error -- it is the result of your raise statement.

Step 2: add the statement next(fh) to progress past the first line in the file (the headers). This will cause the for loop to start on the 2nd line of the file, after the headers. Step 3: loop through the file, split each line, and compare the id on each line to the student_id variable, above set to 'jk43'. If the line has this id, print the line. This is very similar to what we did in past weeks' assignments. Step 4: continue the above program so that instead of printing the entire line, you print the first and last name together. Then build the first and last name as a single string and print the string. Step 5: once you have tested this code with more than one id and see that it is working properly, place your entire program, including all the code you have written to open and read the file, inside a function, and make changes to make it into a reusable function: remove the student_id = 'jk43' line and the fname = '../student_db_names.txt' lines. Have the function accept two arguments, which will be the student id and the filename. Make sure that the filename and id used by the function HAS BEEN PASSED TO THE FUNCTION -- THE FUNCTION MUST NOT USE ANY 'OUTSIDE' VARIABLES! You also must take care not to open the file outside the function - this would produce an outside variable which you must not refer to inside the function. Step 6: instead of printing the student's full name, use a return statement to return the student's full name from the function. MAKE SURE YOUR FUNCTION DOES NOT PRINT ANYTHING. Step 7: use the stub program provided in the assignment with your completed function and make sure that it works as shown in the example calls -- it must take 2 arguments and return 1 value. MAKE SURE YOU ARE RUNNING THE ENTIRE STUB CODE PROVIDED! Special note on None appearing for the 2nd id: you may find that when you run the sample program that the first id (ap172)returns a name, but the second (valid) id (jab44) returns None. Experimenting, you may try different ids and get differing results. For example, if you reverse the ids in the test, and look for jab44 first followed by ap172, you'll find that both names are returned correctly. This last experimental result should indicate that something more is at play besides faulty logic - in fact it does appear that the logic works - but why for an id based on the order in which we request them? The operative knowledge needed to understand the root of this problem is the nature of a "file" object. Note the result below:

Note above that when we start looping through a file, we get the . But if we break out of that loop after only having read one line of the file, There is an internal file pointer that keeps track of its place in the file (at the start of the 2nd line). So that when we loop through the file again, we get not the first line, but the 2nd line -- because that is where reading left off. Note too that after doing this twice and having read two lines of the file, a call to next(fh) (which is a function that requests the next item in the object) delivers the 3rd line of the file. Try your own experiment to see that this is true! So what does this mean for our program? If you ask the function to read from the same opened file handle for each of its calls, you'll see this behavior - the file object remembers where it left off. If you consider the order that the ids can be found in the file, and the order of ids requested in the example, you'll perhaps see why you initially got None for the 2nd id and that this problem is resolved if you call the ids in the right order. Of course we don't want to be satisfied with just calling the ids in the right order -- the function should be able to work with any id. So what's the solution? Make sure you're opening the file a fresh every time an id is requested. And if you consider that one restriction of this solution is that it not refer to variables that were defined outside, you'll realize why we need this restriction - otherwise we create a needless complication by using an outside variable.

Note: please do not use a function for this solution. The basic form of a list comprehension is this:

endlist = [ transformed item for item in iterable if test ]

File object iterator. Recall that a list comprehension reads from an iterable -- that is, an object you can loop over with for (file object is an iterable). The list comprehension iterates over the iterable object and returns a list of values (modified and/or selected) from the iterable. The object types we've been able to iterate over are file (literally called a "TextIOWrapper"), a list, a dict, a set, and a tuple. So your file object is the iterable, and one item from the iterable is a file line.

Test this step by printing endlist -- you should see all the lines in FF_tiny.txt from start to end, each in a list. Filtering test: does the line start with 4-digit year? Add an 'if' test after the iterator (see examples, and look at the form at the top of this discussion for proper placement) to filter the list. The test asks whether the year in the line is the same as the user's year. You may be able to replicate the "year test" you used in some of the prior Fama-French solutions (i.e., if this is the user's year...). Keep in mind you can slice the line (a string); you don't need to split off the date in order to slice it. Test this step by again printing endlist -- you should see all the lines in FF_tiny.txt that start with your year (in the above example, 1928). Modify the line to strip the line. Remember that the first part of the list comprehension (the "transform") determines what will go into the result list. You simply need to replace the first line with the call that strips the line of its newline.

The basic form of a list comprehension is this:

endlist = [ transformed item for item in iterable if test ]

This solution can be extended from the for-credit list comprehension. To derive just the float value from the line, you'll add this step: Modify the stripped line to return just the Mkt-RF value (the 2nd value, or leftmost float value) from the line. This is tricky because you must do this work in one statement: split the line and subscript the resulting list in one statement.

The idea in combining these two expressions is that the variable items is not needed if you can subscript the split() directly. You should test your combined expression in the separate code snippet above. Once you can see that it is working, then you can put it into your list comprehension at the transformed item portion of the "basic form" at the top of this discussion. You can find examples of this kind of expression combining in the slides on list comprehensions.