Python – Built-in Exceptions

Built-in exceptions are pre-defined error classes in Python that handle errors and exceptional conditions in programs. They are derived from the base class “BaseException” and are part of the standard library.

Standard Built-in Exceptions in Python

Here is a list of Standard Exceptions available in Python −

Here are some examples of standard exceptions −

IndexError

It is shown when trying to access item at invalid index.

# Open Compiler
numbers=[10,20,30,40]
for n in range(5):
   print (numbers[n])

ModuleNotFoundError

This is displayed when module could not be found.

import notamodule

KeyError

It occurs as dictionary key is not found.

D1={'1':"aa", '2':"bb", '3':"cc"}
print ( D1['4'])

ImportError

It is shown when specified function is not available for import.

from math import cube

StopIteration

This error appears when next() function is called after iterator stream exhausts.

it=iter([1,2,3])
next(it)
next(it)
next(it)
next(it)

TypeError

This is shown when operator or function is applied to an object of inappropriate type.

print ('2'+2)

ValueError

It is displayed when function’s argument is of inappropriate type.

print (int('xyz'))

NameError

This is encountered when object could not be found.

print (age)

ZeroDivisionError

It is shown when second operator in division is zero.

x=100/0

KeyboardInterrupt

When user hits the interrupt key normally Control-C during execution of program.

name=input('enter your name')
enter your name^c

Hierarchy of Built-in Exceptions

The exceptions in Python are organized in a hierarchical structure, with “BaseException” at the top. Here is a simplified hierarchy −

BaseException
   SystemExit
   KeyboardInterrupt
   Exception
      ArithmeticError
         FloatingPointError
         OverflowError
         ZeroDivisionError
      AttributeError
      EOFError
      ImportError
      LookupError
         IndexError
         KeyError
      MemoryError
      NameError
         UnboundLocalError
      OSError
         FileNotFoundError
      TypeError
      ValueError
      --- (Many others) ---

How to Use Built-in Exceptions

As we already know that built-in exceptions in Python are pre-defined classes that handle specific error conditions. Now, here is a detailed guide on how to use them effectively in your Python programs −

Handling Exceptions with try-except Blocks

The primary way to handle exceptions in Python is using “try-except” blocks. This allows you to catch and respond to exceptions that may occur during the execution of your code.

Example

In the following example, the code that may raise an exception is placed inside the “try” block. The “except” block catches the specified exception “ZeroDivisionError” and handles it

# Open Compiler
try:
   result = 1 / 0
except ZeroDivisionError as e:
   print(f"Caught an exception: {e}")

Handling Multiple Exceptions

You can handle multiple exceptions by specifying them in a tuple within the “except” block as shown in the example below −

# Open Compiler
try:
   result = int('abc')
except (ValueError, TypeError) as e:
   print(f"Caught a ValueError or TypeError: {e}")

Using “else” and “finally” Blocks

The “else” block is executed if the code block in the “try” clause does not raise an exception −

# Open Compiler
try:
   number = int(input("Enter a number: "))
except ValueError as e:
   print(f"Invalid input: {e}")
else:
   print(f"You entered: {number}")

The “finally” block is always executed, regardless of whether an exception occurred or not. It’s typically used for clean-up actions, such as closing files or releasing resources −

try:
   file = open('example.txt', 'r')
   content = file.read()
except FileNotFoundError as e:
   print(f"File not found: {e}")
finally:
   file.close()
   print("File closed.")

Explicitly Raising Built-in Exceptions

In Python, you can raise built-in exceptions to indicate errors or exceptional conditions in your code. This allows you to handle specific error scenarios and provide informative error messages to users or developers debugging your application.

Syntax

Following is the basic syntax for raising built-in exception −

raise ExceptionClassName("Error message")

Example

In this example, the “divide” function attempts to divide two numbers “a” and “b”. If “b” is zero, it raises a “ZeroDivisionError” with a custom message −

# Open Compiler
def divide(a, b):
   if b == 0:
      raise ZeroDivisionError("Cannot divide by zero")
   return a / b

try:
   result = divide(10, 0)
except ZeroDivisionError as e:
   print(f"Error: {e}")

Key Takeaway: Master built-in exceptions in Python—handle errors with pre-defined classes—at Vista Academy!