{"id":3060,"date":"2021-11-27T05:15:10","date_gmt":"2021-11-27T05:15:10","guid":{"rendered":"https:\/\/www.pythontutorial.net\/?page_id=3060"},"modified":"2025-03-28T03:41:19","modified_gmt":"2025-03-28T03:41:19","slug":"python-exception-handling","status":"publish","type":"page","link":"https:\/\/www.pythontutorial.net\/python-oop\/python-exception-handling\/","title":{"rendered":"Python Exception Handling"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you learn how to handle exceptions in Python in the right way by using the try<\/code> statement.<\/p>\n\n\n\n

Introduction to the exception handling in Python #<\/a><\/h2>\n\n\n\n

To handle exceptions, you use the try<\/code> statement. The try<\/code> statement has the following clauses:<\/p>\n\n\n

try<\/span>:\n    # code that you want to protect from exceptions<\/span>\nexcept<\/span> <ExceptionType> as<\/span> ex:\n    # code that handle the exception<\/span>\nfinally<\/span>:\n    # code that always execute whether the exception occurred or not<\/span>\nelse<\/span>:\n    # code that excutes if try execute normally (an except clause must be present)<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Let’s examine the try<\/code> statement in greater detail.<\/p>\n\n\n\n
try #<\/a><\/h3>\n\n\n\n
In the try<\/code> clause, you place the code that protects from one or more potential exceptions. It’s a good practice to keep the code as short as possible. Often, you’ll have a single statement in the try<\/code> clause.<\/p>\n\n\n\n
The try<\/code> clause appears exactly one time in the try<\/code> statement.<\/p>\n\n\n\n
except #<\/a><\/h3>\n\n\n\n
In the except<\/code> clause, you place the code that handles a specific exception type. A try<\/code> statement can have zero or more except<\/code> clauses. Typically, each except<\/code> clause handles different exception types in specific ways. <\/p>\n\n\n\n
In an except<\/code> clause, the as ex<\/code> is optional. And the <ExceptionType><\/code> is also optional. However, if you omit the <ExceptionType> as ex<\/code>, you’ll have a bare exception handler.<\/p>\n\n\n\n
When specifying exception types in the except<\/code> clauses, you place the most specific to least specific exceptions from top to bottom.<\/p>\n\n\n\n
If you have the same logic that handles different exception types, you can group them in a single except<\/code> clause. For example:<\/p>\n\n\n
try<\/span>:\n...\nexcept<\/span> <ExceptionType1> as<\/span> ex:\n    log(ex)\nexcept<\/span> <ExceptionType2> as<\/span> ex:\n    log(ex)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Become<\/p>\n\n\n
try<\/span>:\n...\nexcept<\/span> (<ExceptionType1>, <ExceptionType2>) as<\/span> ex:\n    log(ex)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
It’s important to note that the except<\/code> order matters because Python will run the first except<\/code> clause whose exception type matches the occurred exception.<\/p>\n\n\n\n
finally #<\/a><\/h3>\n\n\n\n
The finally<\/code> clause may appear zero or 1 time in a try<\/code> statement. The finally<\/code> clause always executes whether an exception occurred or not.<\/p>\n\n\n\n
else #<\/a><\/h3>\n\n\n\n
The else<\/code> clause also appears zero or 1 time. And the else<\/code> clause is only valid if the try statement has at least one except<\/code> clause.<\/p>\n\n\n\n
Typically, you place the code that executes if the try<\/code> clause terminates normally.<\/p>\n\n\n\n
Python exception handling example #<\/a><\/h2>\n\n\n\n
The following defines a function that returns the result of a number by another:<\/p>\n\n\n
def<\/span> divide<\/span>(a, b)<\/span>:<\/span>\n    return<\/span> a \/ b<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
If you pass 0 to the second argument, you’ll get a ZeroDivisionError<\/code> exception:<\/p>\n\n\n
divide(10<\/span>, 0<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Error:<\/p>\n\n\n
ZeroDivisionError: division by zero<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
To fix it, you can handle the ZeroDivisionError<\/code> exception in the divide()<\/code> function as follows:<\/p>\n\n\n
def<\/span> divide<\/span>(a, b)<\/span>:<\/span>\n    try<\/span>:\n        return<\/span> a \/ b\n    except<\/span> ZeroDivisionError as<\/span> ex:\n        return<\/span> None<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example, the divide()<\/code> function returns None<\/code> if the ZeroDivisionError<\/code> occurs:<\/p>\n\n\n
def<\/span> divide<\/span>(a, b)<\/span>:<\/span>\n    try<\/span>:\n        return<\/span> a \/ b\n    except<\/span> ZeroDivisionError as<\/span> ex:\n        return<\/span> None<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
When using the divide()<\/code> function, you need to check if the result is None<\/code>:<\/p>\n\n\n
result = divide(10<\/span>, 0<\/span>)\n\nif<\/span> result is<\/span> not<\/span> None<\/span>:\n    print('result:'<\/span>, result)\nelse<\/span>:\n    print('Invalid inputs'<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
But returning None<\/code> may not be the best because others may accidentally evaluate the result in the if<\/code> statement like this:<\/p>\n\n\n
result = divide(10<\/span>, 0<\/span>)\n\nif<\/span> result:\n    print('result:'<\/span>, result)\nelse<\/span>:\n    print('Invalid inputs'<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
In this case, it works. However, it won’t work if the first argument is zero. For example:<\/p>\n\n\n
result = divide(0<\/span>, 10<\/span>)\n\nif<\/span> result:\n    print('result:'<\/span>, result)\nelse<\/span>:\n    print('Invalid inputs'<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
A better approach is to raise an exception to the caller if the ZeroDivisionError<\/code> exception occurred. For example:<\/p>\n\n\n
def<\/span> divide<\/span>(a, b)<\/span>:<\/span>\n    try<\/span>:\n        return<\/span> a \/ b\n    except<\/span> ZeroDivisionError as<\/span> ex:\n        raise<\/span> ValueError('The second argument (b) must not be zero'<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example, the divide()<\/code> function will raise an error if b<\/code> is zero. To use the divide()<\/code> function, you need to catch the ValueError<\/code> exception:<\/p>\n\n\n
def<\/span> divide<\/span>(a, b)<\/span>:<\/span>\n    try<\/span>:\n        return<\/span> a \/ b\n    except<\/span> ZeroDivisionError as<\/span> ex:\n        raise<\/span> ValueError('The second argument (b) must not be zero'<\/span>)\n\n\ntry<\/span>:\n    result = divide(10<\/span>, 0<\/span>)\nexcept<\/span> ValueError as<\/span> e:\n    print(e)\nelse<\/span>:\n    print('result:'<\/span>, result)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
The second argument (b) must not<\/span> be zero<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
It’s a good practice to raise an exception instead of returning None<\/code> in special cases.<\/p>\n\n\n\n
Except order example #<\/a><\/h2>\n\n\n\n
When you catch an exception in the except clause, you need to place the exceptions from most specific to the least specific in terms of exception hierarchy.<\/p>\n\n\n\n
The following shows three exception classes: Exception<\/code>, LookupError<\/code>, and IndexError<\/code>:<\/p>\n\n\n\n
\"\"<\/figure><\/div>\n\n\n\n
If you catch the exception, you need to place them in the following order: IndexError, LookupErorr, and Exception.<\/p>\n\n\n\n
For example, the following defines a list of three strings and attempts to access the 4th element:<\/p>\n\n\n
colors = ['red'<\/span>, 'green'<\/span>, 'blue'<\/span>]\ntry<\/span>:\n    print(colors[3<\/span>])\nexcept<\/span> IndexError as<\/span> e:\n    print(type(e), 'Index error'<\/span>)\nexcept<\/span> LookupError as<\/span> e:\n    print(type(e), 'Lookup error'<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
It issues the following error:<\/p>\n\n\n
<class<\/span> 'IndexError<\/span>'> Index<\/span> error<\/span><\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
The colors[3]<\/code> access causes an IndexError<\/code> exception. However, if you swap the except<\/code> clauses and catch the LookupError<\/code> first and the IndexError<\/code> second like this:<\/p>\n\n\n
colors = ['red'<\/span>, 'green'<\/span>, 'blue'<\/span>]\ntry<\/span>:\n    print(colors[3<\/span>])\nexcept<\/span> LookupError as<\/span> e:\n    print(type(e), 'Lookup error'<\/span>)\nexcept<\/span> IndexError as<\/span> e:\n    print(type(e), 'Index error'<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
<class<\/span> 'IndexError<\/span>'> Lookup<\/span> error<\/span><\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
The exception is still IndexError<\/code> but the following message is misleading. <\/p>\n\n\n\n
Bare exception handlers #<\/a><\/h2>\n\n\n\n
When you want to catch any exception, you can use the bare exception handlers. A bare exception handler does not specify an exception type:<\/p>\n\n\n
try<\/span>:\n    ...\nexcept<\/span>:\n    ...<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
It’s equivalent to the following:<\/p>\n\n\n
try<\/span>:\n    ...\nexcept<\/span> BaseException:\n\n    ...<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
A bare exception handler will catch any exceptions including the SystemExit and KeyboardInterupt exceptions. <\/p>\n\n\n\n
A bare exception will make it harder to interrupt a program with Control-C and disguise other programs.<\/p>\n\n\n\n
If you want to catch all exceptions that signal program errors, you can use except Exception instead:<\/p>\n\n\n
try<\/span>:\n    ...\nexcept<\/span> Exception:\n    ...<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
In practice, you should avoid using bare exception handlers. If you don’t know exceptions to catch, just let the exception occurs and then modify the code to handle these exceptions.<\/p>\n\n\n\n
To get exception information from a bare exception handler, you use the exc_info()<\/code> function from the sys<\/code> module.<\/p>\n\n\n\n
The sys.exc_info()<\/code> function returns a tuple that consists of three values:<\/p>\n\n\n\n