Working with files is a fundamental skill in programming. Whether you’re developing a simple script or a complex application, handling files allows your programs to read data from and write data to the file system. Python provides a robust set of tools for file manipulation, making it an essential language for tasks involving file I/O (Input/Output).

In this tutorial, we’ll explore:

• Understanding File Operations
• Opening Files with open()
• Reading Files
• Writing to Files
• Appending to Files
• Working with Binary Files
• File Positioning with seek() and tell()
• Exception Handling in File Operations
• Best Practices for File Handling

Let’s dive in!

---

Understanding File Operations

Files are used to store data permanently on a storage device. Common operations include:

• Reading: Retrieving data from a file.
• Writing: Adding new data to a file.
• Appending: Adding data to the end of an existing file without overwriting it.

In Python, these operations are performed using built-in functions and methods, primarily the open() function and file object methods.

---

Opening Files with open()

The open() function is used to open a file and returns a file object, which provides methods and attributes to interact with the file’s contents.

Syntax:

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

• file: The path to the file (relative or absolute).
• mode: Specifies the mode in which the file is opened.

File Modes:

Mode	Description
'r'	Open for reading (default).
'w'	Open for writing, truncating the file first.
'a'	Open for writing, appending to the end if the file exists.
'b'	Binary mode.
't'	Text mode (default).
'+'	Open a disk file for updating (reading and writing).

Combining Modes:

• Read in binary mode: 'rb'
• Write in binary mode: 'wb'
• Append in binary mode: 'ab'

Example:

file = open('example.txt', 'r')  # Open for reading in text mode

Note: Always ensure files are properly closed after operations to free up system resources. We’ll discuss this in the context of the with statement.

---

Reading Files

Reading files allows you to access the data stored within them.

Reading the Entire File

Using read() Method:

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

• file.read(size=-1): Reads up to size bytes. If size is omitted or negative, reads until EOF.

Explanation:

• with open(...) as file: Opens the file and ensures it is properly closed after the block.
• file.read(): Reads the entire file content.

Reading Line by Line

Using a For Loop:

with open('example.txt', 'r') as file:
    for line in file:
        print(line.strip())

• for line in file: Iterates over each line in the file.

Using readline() Method:

with open('example.txt', 'r') as file:
    line = file.readline()
    while line:
        print(line.strip())
        line = file.readline()

• file.readline(): Reads one line at a time.

Reading into a List

Using readlines() Method:

with open('example.txt', 'r') as file:
    lines = file.readlines()
    print(lines)

• file.readlines(): Reads all lines and returns a list.

Caution: Using read() or readlines() can consume a lot of memory if the file is large. For large files, it’s better to read line by line.

Reading Large Files in Chunks

with open('large_file.txt', 'r') as file:
    chunk_size = 1024  # Read 1024 bytes at a time
    while True:
        chunk = file.read(chunk_size)
        if not chunk:
            break
        print(chunk)

---

Writing to Files

Writing allows you to create new files or overwrite existing ones.

Writing Text to a File

Using write() Method:

with open('output.txt', 'w') as file:
    file.write('Hello, World!\n')
    file.write('This is a new line.\n')

• 'w' Mode: Opens the file for writing. If the file exists, it truncates (overwrites) the file.

Writing Multiple Lines

Using writelines() Method:

lines = ['First line\n', 'Second line\n', 'Third line\n']

with open('output.txt', 'w') as file:
    file.writelines(lines)

• Note: writelines() does not add newline characters automatically.

---

Appending to Files

Appending adds data to the end of an existing file without overwriting it.

Using 'a' Mode

with open('output.txt', 'a') as file:
    file.write('Appending a new line.\n')

• 'a' Mode: Opens the file for appending.

---

Working with Binary Files

Binary files are files that contain data in a format that is not human-readable (e.g., images, PDFs).

Reading Binary Files

with open('image.jpg', 'rb') as file:
    data = file.read()
    print(data)

• 'rb' Mode: Read binary mode.

Writing Binary Files

with open('copy_image.jpg', 'wb') as file:
    file.write(data)

• 'wb' Mode: Write binary mode.

Copying a Binary File

with open('source_image.jpg', 'rb') as src_file:
    with open('destination_image.jpg', 'wb') as dest_file:
        for chunk in iter(lambda: src_file.read(4096), b''):
            dest_file.write(chunk)

Explanation:

• Reads the source file in chunks of 4096 bytes and writes them to the destination file.

---

File Positioning with seek() and tell()

The file object maintains a file pointer representing the current position in the file.

Using seek()

file.seek(offset, whence)

• offset: Number of bytes to move.
• whence: Reference point (0=start, 1=current, 2=end).

Using tell()

position = file.tell()
print(f"Current position: {position}")

• Returns the current position of the file pointer.

Example:

with open('example.txt', 'r') as file:
    file.seek(10)          # Move to byte 10 from the start
    data = file.read(5)    # Read next 5 bytes
    print(data)

---

Exception Handling in File Operations

Handling exceptions ensures your program doesn’t crash unexpectedly.

Common Exceptions:

• FileNotFoundError: File does not exist.
• PermissionError: Insufficient permissions.
• IOError: General I/O errors.

Using try...except Blocks

try:
    with open('non_existent_file.txt', 'r') as file:
        content = file.read()
except FileNotFoundError:
    print("The file was not found.")
except PermissionError:
    print("You do not have permission to read this file.")
except Exception as e:
    print(f"An error occurred: {e}")

Explanation:

• try Block: Contains code that may raise an exception.
• except Blocks: Handle specific exceptions.

---

Best Practices for File Handling

1. Use the with Statement:

• Automatically handles closing files.
• Cleaner and more readable code.

   with open('file.txt', 'r') as file:
       # Work with the file

2. Avoid Hardcoding File Paths:

• Use variables or configuration files.
• For cross-platform compatibility, use os.path functions.

   import os

   file_path = os.path.join('folder', 'file.txt')

3. Handle Exceptions Properly:

• Anticipate and handle possible errors.
• Provide meaningful error messages.

3. Don’t Read Large Files into Memory:

• Read files in chunks or line by line.
• Prevents memory exhaustion.

3. Use Binary Mode for Non-Text Files:

• Ensure correct reading/writing of binary files.

3. Ensure Data Integrity:

• When writing files, consider using temporary files and renaming them after successful writes.

3. Use Encoding Parameter When Necessary:

• For text files with specific encodings (e.g., UTF-8).

   with open('file.txt', 'r', encoding='utf-8') as file:
       # Read the file

8. Be Cautious with 'w' Mode:

• Overwrites existing files without warning.
• Check if the file exists before writing if data loss is a concern.

---

Practical Examples

Example 1: Reading a CSV File

with open('data.csv', 'r') as file:
    for line in file:
        columns = line.strip().split(',')
        print(columns)

Example 2: Writing a List to a File

data = ['Line 1', 'Line 2', 'Line 3']

with open('output.txt', 'w') as file:
    for item in data:
        file.write(f"{item}\n")

Example 3: Counting Lines, Words, and Characters in a File

def count_file(filename):
    lines = words = chars = 0
    with open(filename, 'r') as file:
        for line in file:
            lines += 1
            words += len(line.split())
            chars += len(line)
    return lines, words, chars

file_stats = count_file('example.txt')
print(f"Lines: {file_stats[0]}, Words: {file_stats[1]}, Characters: {file_stats[2]}")

Example 4: Copying Text from One File to Another

with open('source.txt', 'r') as src_file:
    with open('destination.txt', 'w') as dest_file:
        for line in src_file:
            dest_file.write(line)

---

Conclusion

You’ve now learned the essentials of file handling in Python, including how to:

• Open files using different modes.
• Read from and write to files.
• Append data to existing files.
• Work with both text and binary files.
• Navigate within files using seek() and tell().
• Handle exceptions to make your programs more robust.

Next Steps:

• Practice: Try reading and writing different types of files.
• Explore: Look into modules like csv, json, and pickle for handling specific file formats.
• Advanced Topics: Learn about file serialization and working with file metadata.

---

Happy coding!

Join the Newsletter

Subscribe to get our latest content by email.

Subscribe

We won't send you spam. Unsubscribe at any time.

Built with Kit