05 Exceptions, Debugging

Question 1

What are some of the reasons to use exceptions in our code?

Answer 1

in care of error…

• they give users clear information on what went wrong
• they can terminate the program properly
• they can fix the error and continue the program

Question 2

What does it mean, when we “raise” an exception?

Answer 2

It means that an exception is created. It carries information on what went wrong.

Question 3

What does it mean to “catch” an exception?

Answer 3

It means that the programer expected an error and if that expected error actually occurs, the programmer has already written some code on how to handle it.

Question 4

What happens if an exception is raised but not caught?

Answer 4

The program execution jumps to the end of the program and stops.

Question 5

How can an exception be caught?

Answer 5

If we except some code to result in an error, this code needs to be put inside a “try”-block, followed by an “except”-block.

If the code inside the “try”-block leads to the specified error, the execution instantly jumps to the “except”-block and continues executing there.

Question 6

In regards to exceptions, what does the keyword ‘finally’ do?

Answer 6

The optional keyword is put at the end of a try-except-structure. In this finally-block we put code that needs to be executed in any case, no matter how the exception is handled in the except-block.

Question 7

What are some of the predefined exception types we’ve learned?

Answer 7

• TypeError (incompatible data type)
• ValueError (correct type but incorrect value)
• IndexError (index out of range)
• KeyError (key not found in dictionary)
• ZeroDivisionError
• FileNotFoundError

Question 8

Assume we have a function func1() that calls func2() and
this function again calls func3().
Some error occurs in func3().
Explain the order in which the handling of the error is looked for.

Answer 8

Reverse order:
Check if the exception is caught in func3(). If not, jump to the code where func3() was called in func2() and check if the exception is caught there.
Continue upwards.
If the exception isn’t caught anywhere, the program ends with an error.

Question 9

What kind of information can we find in an exception output?

Answer 9

• name of exception
• detailed error message
• traceback (where did the exception occur?)

Question 10

What can be done if some code could possibly raise different kinds of error?

Answer 10

Multiple exceptions can be caught by putting more than one except-block after the try-block.

Question 11

True or False: Code can throw multiple exceptions at once, for example a TypeError and ValueError, if both the data type and the value are incorrect.

Answer 11

False. Only one except-block is ever executed. The execution is done from top to bottom, the first matching except-block is executed.

Question 12

What is the difference between the following two exception-structures?

1. try:
   func()
   except ValueError:
   print(“oops”)
   finally:
   print(“damn”)
2. try:
   func()
   except ValueError:
   print(“oops”)
   else:
   print(“damn”)

Answer 12

1. if the function leads to a ValueError, “oops” is printed, then “damn” is printed. If it doesn’t lead to an error, nothing is printed.
2. if the function leads to a ValueError, “oops” is printed. If it doesn’t lead to an error, “damn” is printed.

Question 13

In debugging, what are breakpoints?

Answer 13

When running the code in debug-modus, it will pause the execution at the previously specified points in the code. This allows you to check the current values of variables, slowly step through the following lines of code or dive into functions.

Question 14

In Debugging, what is the call stack?

Answer 14

It’s a panel that shows the sequence of function calls that lead to the current point in your code.

Question 15

What kinds of special breakpoints are there?

Answer 15

• conditional breakpoints: only stops the execution at this line of code if the condition is true.
• logging breakpoints: they write messages to the console