try and except

What you will be able to do

After this lesson you can

• catch an error with try and except, so that the program goes on,
• write several except parts, and name the error you expect,
• use else and finally, and
• say why a bare except: is dangerous.

Catch it, do not crash

With try and except you say: "Try these lines. If this kind of error happens, do this instead."

Predict first: what will this show? Does the last line run? Then run it.

The conversion int("12a") fails with a ValueError. Python does not stop. It jumps out of the try lines, to the except ValueError: lines, and runs them. When they are done, the program goes on with the first line after the whole block. So the last line runs too.

Notice what did not run: the line print("It worked:", number). The jump happened at the failing line, and the lines after it, inside the try, are skipped.

All the parts

In the output, (the division was tried) appears twice, once for each call. And the order is interesting: the finally message appears before the answer is printed, because the function's finally runs when the function ends, before the caller prints the value that was returned.

Several kinds of error

You can write several except parts, one for each kind. Python takes the first one that matches.

The last loop shows two more tools.

• except (ValueError, TypeError) as error: names two kinds in a tuple. One part handles both.
• as error gives the error itself, a value that you can print or look at. type(error).__name__ is the name of the kind.
• int(None) is a TypeError, and int("abc") is a ValueError. The two parts of the tuple catch them both.

After the except block, the program goes on normally. The error is handled, so nothing stops.

Be specific

Name the error that you expect: except ValueError:. Why? Look at this program.

If the part had said except ValueError:, the typing mistake (a NameError) would not have been caught, and Python would have stopped with a clear message that shows the line.

The rule: catch the errors that you expect, and let the others stop the program. The ones that you do not expect are bugs, and bugs should be loud.

Common mistakes

• A bare except:. It hides bugs.
• Putting too much in the try. Put only the risky line, so that you know which line failed.
• An except part that does nothing (pass). The error vanishes without a trace.
• Catching the wrong kind. except ValueError does not catch a ZeroDivisionError.
• Using the variable of the try in the except when the line failed before the variable was made.

Practice

Start with two quick questions. Each New numbers gives you a fresh one, so you can practise as long as you like.

Then the labs and the problems:

1. Warm-up. Open the problem A safe number and the problem A safe division.
2. Build. Open the lab A safe calculator. The checker gives your function good and bad input.
3. Stretch. Open the problem What runs, and in which order? and write down the order before you run it.

Remember these

• try the risky lines. except a named error. else when fine. finally always.
• Several except parts, or a tuple of kinds, and as error for the error itself.
• Put only the risky line in the try.
• Never use a bare except:.

Check yourself

Try each one on your own first. If you are stuck, open a hint. Then check with Show the answer.

1. When does else run?

2. When does finally run?

3. Why is except: with no name risky?

4. Which error does int("abc") give, and which does int(None) give?