Python for Entrepreneurs Transcripts
Chapter: Appendix: Python language concepts
Lecture: Concept: Error handling

Login or purchase this course to watch this video and the rest of the course contents.
0:01 The primary way error handling is done in Python is exceptions.
0:04 Exceptions interrupt the regular flow, execution of your methods and your code,
0:08 and unwind and stop executing a code until they find what's called an except clause,
0:13 that is the explicit error handling that you've written,
0:16 or if they never find one, your application just crashes.
0:20 That's not amazing, so let's talk about error handling.
0:22 Here we have three methods on the screen, method one, two and three,
0:25 and maybe there are potentially error-prone, something can go wrong,
0:29 maybe work with the file system, a web service, a database,
0:31 things that are not always well known or can't rely on them always working.
0:36 It could even just be that someone's input incorrect data
0:39 and there is going to be a problem there as well.
0:41 So if we want to make sure that when we run these bits of code,
0:43 we can catch and handle those errors,
0:45 we have to put this into what's called a "try...except" block.
0:48 So we put a "try:", we indent the code, so it is part of the try block,
0:52 then we add the error handling the except block and it could just be except:
0:56 an empty catch-all, which is not really recommended.
1:00 In this case, we are going to catch a particular type of exception,
1:04 one of the most based types that we'll catch many of the errors
1:07 that we might not expect, so we'll just say "Exception as x".
1:10 We say as x then we can get a hold of the actual object that is the exception
1:14 and ask it what went wrong. So, look at the error message,
1:17 if this is a custom database error, maybe it has the record id that caused the problem,
1:22 or something like that, who knows.
1:24 It depends on the type of exception that you get.
1:26 So here is a general one, but we're only handling errors in a general way,
1:30 we can't handle say database exceptions differently than web service exceptions,
1:36 so we can have multiple except blocks with multiple exception types,
1:40 and Python will find the most specific one,
1:43 so if we want to make sure that we can catch when we have a connection error,
1:46 trying to talk to a web service or something on the network, and it won't connect,
1:51 we might want to handle that differently than say the users typed in something incorrect.
1:56 So we would add another except clause with the more specific type.
2:00 The order of these except blocks is really important, the way it works,
2:03 is Python will try to run the code, if an exception comes up, it will just go through
2:07 and ask does this exception object derived from the first thing it finds,
2:11 and the next, and the next, and if the first one answers yes to,
2:14 it will just stop and that's the error handling at run.
2:17 So if we switch these, almost everything including connection error derives from exception,
2:22 so it would run the code, throw the exception and ask,
2:26 hey, does this exception derive from exception,
2:29 yes, boom handle the general error and it will never make it to the connection error
2:33 so it has to go from most specific error handling to least
2:36 or most general error handling.