Raise Exception in File Handling in Python – Complete Guide

Introduction

File handling is an essential part of Python programming. It allows developers to create, read, write, and manage files efficiently. However, while working with files, many errors can occur, such as missing files, permission issues, invalid file formats, or corrupted data.

Python provides a powerful exception-handling mechanism to manage these situations gracefully. In some cases, built-in exceptions may not be enough, and developers may need to manually raise exceptions using the raise keyword. Raising exceptions helps ensure that invalid operations are detected early and handled appropriately.

What is Raise Exception in File Handling?

A raised exception is a custom error generated by the programmer using the raise statement.

When working with files, you may want to:

• Prevent users from opening unsupported file types.
• Check whether a file contains valid data.
• Ensure a file exists before processing.
• Validate file size before reading.
• Stop execution if file content is incorrect.

Instead of allowing the program to continue with invalid data, you can raise an exception to notify users of the problem.

Example:

raise Exception("Invalid file format")

Output:

The program immediately stops and displays the specified error message.

Why Raise Exceptions in File Handling?

Raising exceptions helps:

• Improve program reliability
• Detect file-related problems early
• Prevent data corruption
• Improve debugging
• Enforce business rules

For example, if your application only accepts .txt files, you can raise an exception when another file type is provided.

Syntax

Basic syntax:

raise Exception("Error Message")

Using specific exception types:

raise FileNotFoundError("File does not exist")
raise ValueError("Invalid file content")
raise PermissionError("Access denied")

General syntax:

if condition:
   raise ExceptionType("Message")

Example 1: Raise Exception if File Does Not Exist

import os
filename = "data.txt"
if not os.path.exists(filename):
   raise FileNotFoundError("The file does not exist")
with open(filename, "r") as file:
   print(file.read())

Output:

Explanation:

• The program checks whether the file exists.
• If not, it raises a FileNotFoundError.
• File processing stops immediately.

Example 2: Raise Exception for Empty File

Suppose your application requires the file to contain data.

with open("data.txt", "r") as file:
   content = file.read()
   if content == "":
       raise ValueError("File is empty")
print(content)

Output:

Explanation:

• The file is opened successfully.
• The program checks for empty content.
• If no data exists, a ValueError is raised.

Example 3: Raise Exception for Invalid File Extension

filename = "report.pdf"
if not filename.endswith(".txt"):
   raise ValueError("Only .txt files are allowed")

Output:

Explanation:

The program validates the file extension before processing.

Example 4: Raise Exception for Large Files

import os
filename = "data.txt"
size = os.path.getsize(filename)
if size > 1024 * 1024:
   raise Exception("File size exceeds 1 MB limit")

Explanation:

• 1024 * 1024 equals 1 MB.
• If the file exceeds the size limit, an exception is raised.

Example 5: Using Raise Inside Try-Except

try:
   filename = "report.doc"
   if not filename.endswith(".txt"):
       raise ValueError("Unsupported file type")
except ValueError as e:
   print("Error:", e)

Output:

Explanation:

The exception is raised inside the try block and handled in the except block.

Example 6: Raise Custom Error During File Reading

with open("data.txt", "r") as file:
   content = file.read()
   if "ERROR" in content:
       raise Exception("Invalid data found in file")

Explanation:

The program scans file contents and raises an exception if invalid text is detected.

Example 7: Raising Custom Exceptions

You can create your own exception class.

class InvalidFileError(Exception):
   pass
filename = "image.jpg"
if not filename.endswith(".txt"):
   raise InvalidFileError("Text file required")

Output:

Explanation:

Custom exceptions make error messages more meaningful and easier to debug.

Real-Life Example

Imagine you are building a student management system that imports student records from a text file.

Requirements:

• File must exist.
• File must be a .txt file.
• File must not be empty.
• Every line must contain valid data.

import os
filename = "students.txt"
if not os.path.exists(filename):
   raise FileNotFoundError("Student file not found")
if not filename.endswith(".txt"):
   raise ValueError("Only text files are accepted")
with open(filename, "r") as file:
   data = file.readlines()
if len(data) == 0:
   raise ValueError("Student file is empty")
for line in data:
   if "," not in line:
       raise ValueError("Invalid student record found")
print("File processed successfully")

Why This Example Matters

This approach:

• Prevents incorrect files from being processed.
• Ensures data quality.
• Makes applications more reliable.
• Helps users identify errors quickly.

Such validation is commonly used in:

• Banking systems
• Payroll software
• School management systems
• Inventory management applications
• Data import tools

Common Exceptions Used in File Handling

Common Mistakes

1. Raising Generic Exceptions Everywhere

Incorrect:

raise Exception("Error")

Better:

raise FileNotFoundError("File not found")

Specific exceptions provide clearer information.

2. Forgetting the Error Message

Incorrect:

raise ValueError

Better:

raise ValueError("Invalid file data")

Meaningful messages help debugging.

3. Not Handling Raised Exceptions

Incorrect:

raise ValueError("Invalid file")

Better:

try:
   raise ValueError("Invalid file")
except ValueError as e:
   print(e)

4. Raising an Exception Unnecessarily

Incorrect:

raise Exception("Everything is fine")

Only raise exceptions when actual errors occur.

5. Ignoring File Validation

Incorrect:

with open(filename, "r") as file:
   data = file.read()

Better:

if not filename.endswith(".txt"):
   raise ValueError("Invalid file type")

Always validate input files before processing.

Best Practices

1. Use Specific Exceptions

raise FileNotFoundError("File missing")

2. Provide Clear Messages

raise ValueError("Student ID missing in file")

3. Validate Before Processing

if not os.path.exists(filename):
   raise FileNotFoundError("File not found")

4. Create Custom Exceptions for Large Projects

class InvalidStudentFile(Exception):
   pass

5. Combine Raise with Try-Except

try:
   raise ValueError("Invalid data")
except ValueError as e:
   print(e)

Conclusion

Raising exceptions in file handling is an important technique for building robust Python applications. The raise keyword allows developers to detect invalid files, unsupported formats, missing files, empty content, and other issues before they cause bigger problems.

By using specific exception types, meaningful error messages, and proper validation checks, you can make your file-handling code safer, easier to debug, and more reliable.

Related Python Tutorials