In python, every built-in exception must be an instance of a class which inherits from BaseException. But user-defined exception class should inherit from Exception or its subclass. Exception is an subclass of BaseException.
Please note: “When an exception has been assigned using as target, it is cleared at the end of the except clause.”

Here I would like to illustrate several methods for handling exceptions.

raise allows you to force generate your own customized exceptions, which makes you control your code more convenient and effective. Although you still can raise built-in exceptions.

Run the expression on terminal:

raise Exception('spam', 'eggs')
Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
Exception: ('spam', 'eggs')

And you can just use raise like this:

import sys
try:
    f = open('myile.txt')
    s = f.readline()
    i = int(s.strip())
except OSError as err:
    print("OS Error: {0}".format(err))
except ValueError:
    print("Not integer")
except:
    print("Unexpected Error:", sys.exc_info()[0])
    raise   

According to the officail document, “If no expressions are present, raise re-raises the last exception that was active in the current scope. If no exception is active in the current scope, a RuntimeError exception is raised indicating that this is an error.”

Then, you can set your own traceback by using with_traceback() exception method, such as:

raise Exception("something wrong with trace").with_traceback(tracebackobj)

You can also use from clause in raise statement to rasie nested exceptions from the clause expression.Exception chaining can be explicitly suppressed by specifying None in the from clause:

try:
...     print(1 / 0)
... except:
...     raise RuntimeError("Something bad happened") from None
...
Traceback (most recent call last):
  File "<stdin>", line 4, in <module>
RuntimeError: Something bad happened

try statement

except clause

try:
...     raise NameError('Name:', 'Wrong')
... except Exception as inst:
...     print(type(inst))
...     print(inst.args)
...     print(inst)
...     x, y = inst.args
...     print("x=", x)
...     print("y=", y)
...
<class ''>
('Name:', 'Wrong')
('Name:', 'Wrong')
x= Name:
y= Wrong

finally clause

def divide(x, y):
    try:
        result = x / y
    except ZeroDivisionError:
        print("division by zero!")
        return
    else:
        print("result is", result)
        return
    finally:
        print("executing finally clause")

divide(2, 1)
divide(2.0, 0)

User-defined Exceptions