Here are our solutions for the day 19 exercises in the 30 Days of Python series. Make sure you try the exercises yourself before checking out the solutions!
1) Create a short program that prompts the user for a list of grades separated by commas. Split the string into individual grades and use a list comprehension to convert each string to an integer. You should use a
try statement to inform the user when the values they entered cannot be converted.
Let's start by writing our
input call to grab the list of grades. We can also use the
split method to split the string we get back from
input all on the same line.
grades = input("Please enter your grades, separated by commas: ").split(",")
Before we move on, let's consider what happens if the user enters something like this in response to our prompt:
76, 93, 84, 81
Here we have spaces after all of the commas, so our resulting
grades list would be:
['76 ', '93 ', '84 ', '81']
This isn't a problem though, because Python is happy to accept the string
'76 ' as a valid argument to
float, and it will strip off the whitespace for us.
It's therefore not necessary to do something like this:
grades = input("Please enter your grades, separated by commas: ").split(",") grades = [grade.strip() for grade in grades]
Now we get to the meat of the exercise. We need to try to convert each string to an integer, and then we need to catch any exceptions that arise from the user providing invalid values.
In the event that the user enters an invalid value, we're going to get a
ValueError, so this is the exception we need to catch with our
grades = input("Please enter your grades, separated by commas: ").split(",") try: pass except ValueError: pass
try clause I'm going to create a list comprehension to convert each string to an integer. I'm then going to assign the result to
grades. If you need a reminder on how list comprehensions work, take another look at day 15.
except clause I'm going to write a message informing the user that their data was in an invalid format.
In a more complete application, the rest of our code working with
grades would likely go in an
else clause, but we don't have to worry about that here.
grades = input("Please enter your grades, separated by commas: ").split(",") try: grades = [int(grade) for grade in grades] except ValueError: print("The grades you entered were in an invalid format.")
2) Investigate what happens when there is a
return statement in both the
try clause and
finally clause of a
In order to complete this exercise, we're going to need to write a function, since we need a function actually return from.
We don't have to get too fancy here. This will do:
def func(): pass
Now let's put our
try statement in the function body. I recommend you use something different for the two return values so that we know where our values come from.
Something like the function below would be appropriate:
def func(): try: return "Returned from the try clause!" finally: return "Returned from the finally clause!"
Now let's call our function and see what happens.
def func(): try: return "Returned from the try clause!" finally: return "Returned from the finally clause!" print(func()) # "Returned from the finally clause!"
Perhaps a little surprisingly, we get the value returned in the
finally clause. This makes some sense though, because the
finally clause always runs, and it will interrupt the
return in the
try clause. It effectively puts that
return on hold while it does its own
The problem is that if we carry out the
return in the finally clause, we end the function execution, so we never come back to do the one in the
try clause. It just gets forgotten about.
3) Imagine you have a file named
data.txt. Open it for reading using Python, but make sure to use a try block to catch an exception that arises if the file doesn't exist. Once you've verified your solution works with an actual file, delete the file and see if your try block is able to handle it.
The content of our
data.txt file is something simple like this:
There is some data here!
It's not terribly important.
We also get told that the exception we need to watch our for is
With that in mind, let's construct our
try: pass except FileNotFoundError: pass
try clause we're going to write the code to access the file. I'm just going to print the file contents to the console. In the
except clause I'm going to write a message to the user indicating that the file could not be found.
In a real application, we might take this opportunity to create the file for the user instead.
try: with open("data.txt", "r") as text_file: print(text_file.read()) except FileNotFoundError: print("Error: Couldn't find data.txt")
With that, we're done!