Exception Handlings

An exception is an event, which occurs during the execution of a program

that disrupts the normal flow of the program's instructions. In general,
when a Python script encounters a situation that it cannot cope with, it
raises an exception
List of Standard Exceptions −

Sr.No Exception Name & Description

.

1 Exception
Base class for all exceptions

2 StopIteration
Raised when the next() method of an iterator does not point to any
object.

3 SystemExit
Raised by the sys.exit() function.

4 StandardError
Base class for all built-in exceptions except StopIteration and
SystemExit.

5 ArithmeticError
Base class for all errors that occur for numeric calculation.

6 OverflowError
Raised when a calculation exceeds maximum limit for a numeric
type.

7 FloatingPointError
Raised when a floating point calculation fails.
8 ZeroDivisionError
Raised when division or modulo by zero takes place for all numeric
types.

9 AssertionError
Raised in case of failure of the Assert statement.

10 AttributeError
Raised in case of failure of attribute reference or assignment.

11 EOFError
Raised when there is no input from either the raw_input() or input()
function and the end of file is reached.

12 ImportError
Raised when an import statement fails.

13 KeyboardInterrupt
Raised when the user interrupts program execution, usually by
pressing Ctrl+c.

14 LookupError
Base class for all lookup errors.

15 IndexError
Raised when an index is not found in a sequence.

16 KeyError
Raised when the specified key is not found in the dictionary.

17 NameError
 Raised when an identifier is not found in the local or global
namespace.

18 UnboundLocalError
Raised when trying to access a local variable in a function or
method but no value has been assigned to it.

19 EnvironmentError
Base class for all exceptions that occur outside the Python
environment.

20 IOError
Raised when an input/ output operation fails, such as the print
statement or the open() function when trying to open a file that does
not exist.

21 IOError
Raised for operating system-related errors.

22 SyntaxError
Raised when there is an error in Python syntax.

23 IndentationError
Raised when indentation is not specified properly.

24 SystemError
Raised when the interpreter finds an internal problem, but when this
error is encountered the Python interpreter does not exit.

25 SystemExit
Raised when Python interpreter is quit by using the sys.exit()
function. If not handled in the code, causes the interpreter to exit.
 26 TypeError
Raised when an operation or function is attempted that is invalid for
the specified data type.

27 ValueError
Raised when the built-in function for a data type has the valid type of
arguments, but the arguments have invalid values specified.

28 RuntimeError
Raised when a generated error does not fall into any category.

29 NotImplementedError
Raised when an abstract method that needs to be implemented in
an inherited class is not actually implemented.

Try and Except Statement

If you have some suspicious code that may raise an exception, then that
suspicious code should be placed in a try: block.

Try and except statements are used to catch and handle exceptions
in Python. Statements that can raise exceptions are kept inside the
try clause and the statements that handle the exception are written
inside except clause.
There can be one or more except blocks.Multiple Except blocks with
different exception names can be chained together.
Else
You can use the else keyword to define a block of code to be
executed if no errors were raised:
 Example
In this example, the try block does not generate any error:

try:
print("Hello")
except:
print("Something went wrong")
else:
print("Nothing went wrong")

Output:
Hello
Nothing went wrong
The try-finally Clause
You can use a finally: block along with a try: block. The finally
block is a place to put any code that must execute, whether the try-
block raised an exception or not. The syntax of the try-finally
statement is this –
try:
You do your operations here;
......................
Due to any exception, this may be skipped.
finally:
This would always be executed.
......................

The statement written in finally clause will always be executed by

the interpreter ,whether the try statement raises an exception or
not.
Syntax:
try:
# Some Code....

except:
# optional block
# Handling of exception (if required)

else:
# execute if no exception

finally:
# Some code .....(always executed)
Examples:
Program to check for ZeroDivisionError Exception.
Raise Statement
To throw (or raise) an exception, use the raise keyword.

You can define what kind of error to raise, and the text to print
to the user.
Class Myexception(Exception):

Pass

c=5

If c>10:

Raise Myexception(“Something went wrong”)

Example:

class Invaliddata(Exception):

pass

marks=int(input(“Enter Marks for students”))

try:

if marks <0 or marks>100:

raise Invaliddata

except Invaliddata:

print(“Marks should be in between 0 and 100”)