Built-in Exceptions | Python Exceptions (With Examples)

PYTHON BUILT-IN EXCEPTION:

An exception is an event that occurs during the execution of a program that disrupts the normal flow of instructions. It typically happens due to errors in the code or unexpected conditions that arise while the program is running. Exceptions provide a way to handle these situations gracefully, preventing the program from crashing and allowing for controlled error handling.

Python Exceptions

 PYTHON EXCEPTION LIST:

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 the 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 the 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 the 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 a valid kind of argument, but the ideas 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.

 

PYTHON EXCEPTION:

In Python, an exception is an event that occurs during the execution of a program, which disrupts the normal flow of the program's instructions. Anomalies are typically caused by errors in the code or unexpected conditions. Python provides a robust mechanism for handling exceptions to prevent programs from crashing and to allow for graceful error handling.

EXAMPLE:

                            #RAISE EXCEPTION

                           def divide(a, b):

                                 if b == 0:

                                      raise ZeroDivisionError("Cannot divide by zero")

                                      return a / b

                             #HANDLE EXCEPTION

                             try:

                                 result = divide(10, 0)

                             except ZeroDivisionError as e:

                                   print("An error occurred:", e)

EXCEPTION HANDLING:

Exception handling in Python involves using the 'try' and 'except' blocks to gracefully handle errors and prevent program crashes. 

SYNTAX:

                         try:

                              # Code that might raise an exception

                         except ExceptionType:

                              # Code to handle the exception

EXAMPLE:

                             def divide(a, b):

                                  try:

                                        result = a / b

                               except ZeroDivisionError:

                                      print("Error: Division by zero")

                                else:

                                         print("Result:", result)

                                divide(10, 2)  # Result: 5.0

                                divide(10, 0)  # Error: Division by zero

FINALLY  KEYWORD  EXCEPTION:

Certainly! The finally block in exception handling is used to define code that will be executed regardless of whether an exception occurred or not. It's commonly used for cleanup operations that should be performed irrespective of the outcome of the try and except blocks.

EXAMPLE:

                           def divide(a, b):

                                 try:

                                     result = a / b

                           except ZeroDivisionError:

                                    print("Error: Division by zero")

                            finally:

                                     print("Division operation completed")

                            divide(10, 2)  # Output: Result: 5.0 \n Division operation completed

                            divide(10, 0)  # Output: Error: Division by zero \n Division operation      completed

USER-DEFINED EXCEPTION:

User-defined exceptions in Python allow you to create your own custom exception classes to handle specific error scenarios in your code. This can improve the clarity and robustness of your error handling by providing more context and information about the exceptions that occur.

EXAMPLE:

                            #DEFINING A USER-DEFINED EXCEPTION

                            class CustomError(Exception):

                                 def __init__(self, message, error_code):

                                        self.message = message

                                        self.error_code = error_code

                                        super().__init__(self.message)

                           #RAISING USER-DEFINED EXCEPTION

                           def calculate_discount(price, discount):

                              if discount < 0 or discount > 100:

                                     raise CustomError("Invalid discount value", 101)

                                     discounted_price = price - (price * discount / 100)

                            return discounted_price

                           #HANDLE USER-DEFINED EXCEPTION

                           try:

                                 final_price = calculate_discount(100, 150)

                           except CustomError as ce:

                                 print("Error:", ce.message)

                                 print("Error Code:", ce.error_code)