File Handling - Text Files

1. Introduction to File Handling

A file is a named location on a storage device where data is stored permanently. File handling refers to the process of performing operations on files such as creating, opening, reading, writing, and closing them.

Why file handling?

• Data persists even after the program terminates.
• Large amounts of data can be processed efficiently.
• Data can be shared between different programs.
• Enables data analysis and reporting.

Python provides built-in functions and methods for file handling through the open() function which returns a file object.

2. File Path

A file path specifies the location of a file on the storage device.

In Python, use forward slashes (/) or double backslashes (\\) in paths to avoid escape character issues.

3. Opening a File

The open() function is used to open a file. It returns a file object.

file_object = open(file_name, mode)

Parameters:

• file_name: Name or path of the file to be opened.
• mode: Specifies the purpose of opening (read, write, append, etc.).

f = open("sample.txt", "r")  # Open for reading

4. File Modes

For text files, the default mode is "r". Append "t" to explicitly specify text mode (e.g., "rt").

5. Closing a File

After completing file operations, the file should be closed using the close() method.

f = open("sample.txt", "r")
# Perform file operations
f.close()

Why close a file?

• Frees system resources.
• Ensures data is written completely.
• Prevents accidental modifications.
• Limits file access to other programs.

6. Writing to a Text File

The write() method writes a string to the file. The writelines() method writes a list of strings.

f = open("notes.txt", "w")
f.write("Python is a powerful programming language.\n")
f.write("It is used for web development, data science, and AI.\n")
f.close()

Important: The "w" mode overwrites the entire file. If the file contains existing data, it will be erased.

7. Reading from a Text File

The read() method reads the entire content of the file as a single string.

f = open("notes.txt", "r")
content = f.read()
print(content)
f.close()

You can specify the number of characters to read:

f = open("notes.txt", "r")
first_20 = f.read(20)  # Read first 20 characters
print(first_20)
f.close()

8. The readline() Method

The readline() method reads one line at a time from the file. Each call returns the next line including the newline character.

f = open("notes.txt", "r")
line1 = f.readline()
line2 = f.readline()
print("Line 1:", line1)
print("Line 2:", line2)
f.close()

When the end of file is reached, readline() returns an empty string "".

9. The readlines() Method

The readlines() method reads all lines of the file and returns them as a list of strings.

f = open("notes.txt", "r")
lines = f.readlines()
for line in lines:
    print(line.strip())  # strip() removes newline
f.close()

10. Appending to a File

The "a" (append) mode adds new content to the end of the file without erasing existing data.

f = open("notes.txt", "a")
f.write("This line is appended at the end.\n")
f.close()

If the file does not exist, the "a" mode creates a new file.

11. The with Statement

The with statement ensures that the file is properly closed after operations, even if an exception occurs. This is also called a context manager.

with open("notes.txt", "r") as f:
    content = f.read()
    print(content)
# File is automatically closed here

Advantages of using with:

• Automatic file closing.
• Cleaner and more readable code.
• Safer exception handling.
• No need to explicitly call close().

12. The tell() and seek() Methods

tell() returns the current position of the file pointer (in bytes from the beginning).

seek() moves the file pointer to a specified position.

with open("notes.txt", "r") as f:
    print(f.tell())      # Output: 0 (beginning)
    f.read(10)
    print(f.tell())      # Output: 10
    f.seek(0)             # Move to beginning
    print(f.tell())      # Output: 0

seek(offset, whence) syntax:

• whence = 0: From beginning of file (default).
• whence = 1: From current position.
• whence = 2: From end of file.

13. Iterating Through a File

The file object is an iterator. You can loop through it directly to read line by line efficiently.

with open("notes.txt", "r") as f:
    for line in f:
        print(line.strip())

This approach is memory-efficient for large files because it reads one line at a time instead of loading the entire file.

14. write() vs writelines()

lines = ["Line 1\n", "Line 2\n", "Line 3\n"]
with open("data.txt", "w") as f:
    f.writelines(lines)

Note: writelines() does not add newline characters. You must include them in the strings.

15. Checking if a File Exists

Use the os.path.exists() or pathlib module to check if a file exists before opening it.

import os
if os.path.exists("notes.txt"):
    with open("notes.txt", "r") as f:
        print(f.read())
else:
    print("File does not exist.")

16. Standard Streams

Python provides three standard file objects:

import sys
sys.stdout.write("Hello using stdout\n")

17. Best Practices

• Always use the with statement to handle files.
• Specify the correct file mode to avoid accidental data loss.
• Handle exceptions using try-except blocks for robust code.
• Close files explicitly if not using with.
• Use absolute paths sparingly; prefer relative paths.
• Check if a file exists before reading.
• Use strip() when reading lines to remove unwanted whitespace.
• Be careful with "w" mode as it overwrites existing data.