2025 Python Files and Exceptions: A Comprehensive Guide

Introduction:

Working with files and handling exceptions is an essential part of programming in Python. Files allow us to store and retrieve data, while exceptions help manage errors and unexpected situations in programs.

Python provides built-in support for handling text files, reading and writing file data, and working with command line arguments for dynamic program execution. Understanding these concepts helps in creating efficient and error-free applications that interact with external data sources.

Working with Files in Python

Python provides built-in functions to open, read, write, and close files efficiently. The open() function is used to open a file, and it requires a filename and mode.

File Opening Modes

Mode	Description
r	Read mode (default). Opens the file for reading.
w	Write mode. Creates a new file or overwrites an existing file.
a	Append mode. Adds content to an existing file without deleting previous data.
x	Exclusive mode. Creates a new file; fails if the file exists.
b	Binary mode. Used for handling binary files like images.
t	Text mode (default). Used for handling text files.

Example: Reading a File

with open("example.txt", "r") as file:
    content = file.read()
    print(content)

This method ensures the file is closed automatically after reading.

Example: Writing to a File

with open("example.txt", "w") as file:
    file.write("Hello, Python!")

This will overwrite the existing content with “Hello, Python!”.

Example: Appending to a File

with open("example.txt", "a") as file:
    file.write("\nAppending new data.")

This adds new content to the file without removing existing data.

Handling Exceptions in Python

Exceptions are errors that occur during program execution. Python provides try-except blocks to handle these errors gracefully.

Basic Exception Handling

try:
    result = 10 / 0  # Division by zero error
except ZeroDivisionError:
    print("Cannot divide by zero!")

This prevents the program from crashing when an error occurs.

Handling Multiple Exceptions

try:
    number = int(input("Enter a number: "))
    result = 10 / number
except ZeroDivisionError:
    print("You cannot divide by zero!")
except ValueError:
    print("Invalid input! Please enter a number.")

This handles both division by zero and invalid input errors.

Using Finally Block

The finally block executes regardless of whether an exception occurs.

try:
    file = open("example.txt", "r")
    content = file.read()
except FileNotFoundError:
    print("File not found!")
finally:
    file.close()

Even if an error occurs, the file will still be closed properly.

Advantages of Using Files and Exceptions

1. Data Storage – Files allow storing data permanently.
2. Automated Processes – Enables reading and writing data automatically.
3. Prevents Crashes – Exception handling ensures smooth program execution.
4. Efficient Debugging – Errors can be handled and logged for debugging.

Disadvantages of Using Files and Exceptions

1. File Corruption Risk – Incorrect handling can corrupt files.
2. Security Risks – Handling sensitive files improperly can cause security issues.
3. Performance Overhead – Exception handling can slow down execution if overused.

Python Command Line Arguments: A Complete Guide

Introduction

Python command line arguments allow users to pass input values to a script while running it from the terminal or command prompt. This makes scripts more dynamic and flexible by enabling them to process different inputs without modifying the code.

Command line arguments are accessed using the sys module, which provides a list called sys.argv containing all arguments passed to the script. Understanding command line arguments helps in automating tasks, handling user input, and building powerful command-line applications.

What Are Command Line Arguments?

Command line arguments are values passed to a Python script at the time of execution. They allow users to customize the script’s behavior without modifying the code. These arguments are stored in the sys.argv list, where:

• sys.argv[0] contains the script name.
• sys.argv[1] and beyond contain additional arguments passed by the user.

Example: Running a Script with Arguments

Let’s say we have a Python script named example.py.

import sys

# Printing command line arguments
print("Script Name:", sys.argv[0])
print("Arguments:", sys.argv[1:])

If we run this script from the terminal like this:

python example.py Hello World 123

The output will be:

Script Name: example.py
Arguments: ['Hello', 'World', '123']

How to Use Command Line Arguments in Python

1. Accessing Arguments Using sys.argv

The sys module provides the argv list, where all arguments are stored.

import sys

if len(sys.argv) > 1:
    print("First argument:", sys.argv[1])
else:
    print("No arguments provided.")

2. Using Multiple Arguments

We can pass multiple arguments and access them by index.

import sys

if len(sys.argv) > 2:
    print("First argument:", sys.argv[1])
    print("Second argument:", sys.argv[2])
else:
    print("Not enough arguments provided.")

3. Converting Arguments to Numbers

Since command line arguments are strings by default, we need to convert them if using numbers.

import sys

if len(sys.argv) > 1:
    num = int(sys.argv[1])  # Convert to integer
    print("Square of the number:", num ** 2)
else:
    print("Please provide a number.")

If we run:

python example.py 5

The output will be:

Square of the number: 25

Advantages of Using Command Line Arguments

• Flexibility: Allows users to change script behavior without modifying the code.
• Automation: Useful for batch processing and automating repetitive tasks.
• Efficiency: Reduces the need for user input during script execution.
• Integration: Can be used with shell scripts, pipelines, and other automation tools.

Disadvantages of Using Command Line Arguments

• Lack of Validation: Users may enter incorrect or missing values.
• Limited User Interface: Not user-friendly for those unfamiliar with command line usage.
• Security Risks: Sensitive data passed as arguments may be visible in command history.

Using argparse for Better Argument Handling

The argparse module provides a more structured way to handle command line arguments.

import argparse

parser = argparse.ArgumentParser(description="Process some numbers.")
parser.add_argument("num1", type=int, help="First number")
parser.add_argument("num2", type=int, help="Second number")

args = parser.parse_args()

print("Sum:", args.num1 + args.num2)

Running this script:

python script.py 5 10

Will output:

Sum: 15

Common Uses of Command Line Arguments in Python

• Automating Tasks: Running scripts with different inputs for automation.
• Data Processing: Handling CSV files, logs, or reports dynamically.
• Testing & Debugging: Running tests with different configurations.
• Building CLI Applications: Creating command-line tools like Git, pip, etc.

2025 Python Files and Exceptions – FAQs

Summary:

Python makes file handling simple with built-in functions for opening, reading, writing, and closing files. It supports working with text files using different file modes like 'r' (read), 'w' (write), and 'a' (append).

Additionally, Python allows handling exceptions using try-except blocks to prevent programs from crashing due to errors like file not found or permission issues. Command line arguments, accessed via the sys module, enable passing data to scripts while executing them, making programs more flexible. Mastering these topics helps developers write reliable and efficient Python applications.

Understanding Python Tuples: Assignment, Return Values, and Comprehension