Exception Handling in Python Explained with Examples

KB Product Documentation Tutorials Tutorial Series Python Python Exception Handling Viewed: 5972
0 0

Exception Handling in Python Explained with Examples

Exception handling in Python is an essential programming technique used to manage runtime errors without crashing a program. When an error occurs during execution, Python raises an exception. Without proper handling, the program stops immediately.

Using Python’s exception handling system, developers can detect errors, display helpful messages, and allow the program to continue running safely.

This guide explains everything you need to know about Python exception handling, including syntax, examples, custom exceptions, and best practices.

What is Exception Handling in Python?

Exception handling in Python is a mechanism used to detect and manage runtime errors using try and except blocks so that the program can continue executing instead of stopping abruptly.

Common scenarios where exceptions occur include:

  • Division by zero
  • Invalid user input
  • Missing files
  • Incorrect data types
  • Index errors in lists

Example of an exception:

result = 10 / 0
Output:
ZeroDivisionError: division by zero

Without exception handling, the program stops immediately.

Python Exception Handling Syntax

Python uses four main blocks to manage exceptions:

Block Purpose
try Contains code that may produce an error
except Handles the exception
else Executes if no exception occurs
finally Executes regardless of errors

Basic Syntax

try:
   # risky code
except ExceptionType:
   # handle exception
else:
   # run if no error occurs
finally:
   # always executes

Python Try Block

The try block contains code that might raise an exception. Python attempts to execute this code normally.

If an error occurs, Python immediately moves execution to the matching except block.

Example:

try:
   number = 10 / 0

Python Except Block

The except block catches and handles exceptions generated in the try block.

Example:

try:
   number = 10 / 0
except ZeroDivisionError:
   print("Division by zero is not allowed.")
Output:
Division by zero is not allowed.

This prevents the program from crashing.

Python Else Block

The else block runs only when no exception occurs in the try block.

Example:

try:
   result = 10 / 2
except ZeroDivisionError:
   print("Error occurred")
else:
   print("Result:", result)
Output:
Result: 5

The else block keeps successful code separate from error handling logic.

Python Finally Block

The finally block always executes, whether an exception occurs or not.

It is commonly used for cleanup operations like closing files or database connections.

Example:

try:
   result = 10 / 0
except ZeroDivisionError:
   print("Error occurred")
finally:
   print("Execution finished")
Output:
Error occurred
Execution finished

Complete Example of Python Exception Handling

try:
   result = 10 / 0
except ZeroDivisionError as e:
   print("Exception caught:", e)
else:
   print("No exception occurred")
finally:
   print("This block always executes")
Output:
Exception caught: division by zero

This block always executes

Handling Multiple Exceptions in Python

Python allows developers to catch different exceptions separately.

Example:

try:
   file_path = "data.txt"
   with open(file_path, "r") as file:
       content = file.read()
   result = 10 / 0
except FileNotFoundError:
   print("File not found")
except ZeroDivisionError:
   print("Cannot divide by zero")
except Exception as e:
   print("Unexpected error:", e)

Benefits of handling specific exceptions:

  • Clear error messages
  • Easier debugging
  • Better user experience

Common Python Exceptions

Here are some commonly encountered Python exceptions:

Exception Description
ZeroDivisionError Division by zero
ValueError Invalid value provided
TypeError Wrong data type used
IndexError Invalid index in a list
FileNotFoundError File does not exist

Understanding these exceptions helps developers create more robust Python programs.

Raising Exceptions in Python

Python allows developers to raise exceptions manually using the raise keyword.

Example:

def check_value(value):
   if value < 0:
       raise ValueError("Value must be non-negative")
   print("Value:", value)
Usage:
try:
   check_value(-5)
except ValueError as e:
   print("Error:", e)
Output:
Error: Value must be non-negative

This technique is useful for validating user input and enforcing program rules.

Custom Exceptions in Python

Python also allows developers to create custom exception classes.

Example:

class CustomError(Exception):
   pass
Usage:
try:
   raise CustomError("Custom error occurred")
except CustomError as e:
   print("Caught error:", e)
Output:
Caught error: Custom error occurred

Custom exceptions are commonly used in large applications and frameworks.

Python Exception Handling Cheat Sheet

Statement Purpose
try Wrap code that may cause errors
except Handle the error
else Runs when no error occurs
finally Always executes
raise Manually trigger an exception

This cheat sheet is helpful when learning Python error handling quickly.

Best Practices for Exception Handling in Python

Catch Specific Exceptions

Avoid using a generic except block.

Bad practice:
except:
   pass
Better approach:
except ValueError:

Keep Try Blocks Small

Smaller try blocks make debugging easier.

Use Meaningful Error Messages

Clear messages improve user experience and debugging.

Use Logging in Production

Use the Python logging module instead of printing errors.

Real World Example of Python Exception Handling

Example: Handling invalid user input.

try:
   number = int(input("Enter a number: "))
   result = 10 / number
   print(result)
except ValueError:
   print("Invalid input. Please enter a number.")
except ZeroDivisionError:
   print("Division by zero is not allowed.")

This prevents the program from crashing due to user mistakes.

Q) What is exception handling in Python?

A) Exception handling in Python is a mechanism used to detect and manage runtime errors using try and except blocks so that the program can continue executing instead of crashing.

Q) What are exceptions in Python?

A) Exceptions are errors that occur during program execution and interrupt the normal flow of the program. Examples include division by zero, invalid input, and file access errors.

Q) What are the main blocks used for exception handling in Python?

A) Python uses four main blocks for exception handling:

  • try
  • except
  • else
  • finally

Each block helps manage errors and control program execution.

Q) What does the try block do in Python?

A) The try block contains code that may produce an exception. If an error occurs inside the try block, Python immediately stops executing it and jumps to the appropriate except block.

Q) What does the except block do in Python?

A) The except block catches and handles exceptions raised in the try block. It allows developers to display error messages or perform recovery actions.

Q) What is the purpose of the else block in Python exception handling?

A) The else block runs only when the try block executes successfully without raising any exceptions.

Q) What does the finally block do in Python?

A) The finally block always executes whether an exception occurs or not. It is commonly used for cleanup operations such as closing files or releasing resources.

Q) Can Python handle multiple exceptions?

A) Yes. Python allows multiple except blocks to handle different types of exceptions separately.

Example:

try:
   # code
except ValueError:
   # handle value error
except TypeError:
   # handle type error

Q) What is the raise keyword in Python?

A) The raise keyword is used to manually trigger an exception in Python. It allows developers to enforce rules or validate input data.

Example:

raise ValueError(“Invalid input”)

Q) What are custom exceptions in Python?

A) Custom exceptions are user-defined exception classes created by inheriting from the built-in Exception class. They help developers create application-specific error types.

Q) What is the difference between error and exception in Python?

A) An error is a general issue that prevents code from running correctly, while an exception is a specific runtime error that Python can detect and handle using exception handling.

Q) Why is exception handling important in Python?

A) Exception handling prevents programs from crashing unexpectedly and helps developers manage errors gracefully, improving application reliability.

Q) Can we use multiple except blocks in Python?

A) Yes. Python allows multiple except blocks to handle different types of exceptions individually.

Q) What happens if an exception is not handled in Python?

A) If an exception is not handled, Python stops program execution and displays an error message along with a traceback.

Q) Can try be used without except in Python?

A) Yes. A try block can be used with finally without an except block when cleanup actions are required regardless of errors.

Example:

try:
   file = open("data.txt")
finally:
   file.close()

Q) What is a common example of exception handling in Python?

A) A common example is handling division by zero errors.

Example:

try:
   result = 10 / 0
except ZeroDivisionError:
   print("Division by zero is not allowed")

Q) What are common exceptions in Python?

A) Some common Python exceptions include:

  • ZeroDivisionError
  • ValueError
  • TypeError
  • IndexError
  • FileNotFoundError

Q) What is the best practice for handling exceptions in Python?

A) Best practices include:

  • Catch specific exceptions instead of generic ones
  • Keep try blocks small
  • Use meaningful error messages
  • Log exceptions for debugging

Conclusion

Exception handling in Python is a powerful feature that allows developers to create stable, reliable, and user-friendly applications. By using try, except, else, and finally blocks, programmers can detect and handle errors without interrupting program execution.

Learning how to handle exceptions, raise custom errors, and apply best practices is essential for writing professional Python code.

Mastering exception handling will help you build robust Python applications that handle unexpected situations gracefully.