Working with CSV, JSON, and Binary Files in Python

In this blog series, we'll explore how to handle files in Python, starting from the basics and gradually progressing to more advanced techniques.

By the end of this series, you'll have a strong understanding of file operations in Python, enabling you to efficiently manage and manipulate data stored in files.

The series will consist of five posts, each building on the knowledge from the previous one:

• Introduction to File Handling in Python: Reading and Writing Files
• Working with Different File Modes and File Types
• Handling Large Files and File Operations in Python
• Using Context Managers and Exception Handling for Robust File Operations
• (This Post) Advanced File Operations: Working with CSV, JSON, and Binary Files

So far in this series on file handling in Python, we’ve covered the basics of reading and writing files, handling large files, and ensuring robust file operations with context managers and exception handling.

This final post will explore advanced file operations, focusing on common formats like CSV, JSON, and binary files.

These formats are widely used for data exchange and storage, and mastering how to work with them will give you the tools to handle a variety of file types efficiently in Python.

Working with CSV Files

CSV (Comma-Separated Values) files are commonly used to store tabular data such as spreadsheets or databases.

Python makes working with CSV files easy through the built-in csv module, which provides functionality to both read and write CSV files.

Reading CSV Files

To read a CSV file, we use the csv.reader() function, which returns a reader object that can be iterated over to access rows in the file.

Example: Reading a CSV File

import csv

# Open the CSV file for reading
with open('data.csv', 'r') as file:
    reader = csv.reader(file)

    # Iterate through each row in the CSV
    for row in reader:
        print(row)

In this example, we open the CSV file using a context manager and read it row by row using csv.reader().

Each row is returned as a list of values, making it easy to process the data.

Reading CSV Files with Headers

If your CSV file has headers, you can use the csv.DictReader() function to access each row as a dictionary, where the keys are the column headers.

import csv

# Open the CSV file with headers
with open('data_with_headers.csv', 'r') as file:
    reader = csv.DictReader(file)

    # Iterate through each row, accessing values by column name
    for row in reader:
        print(f"Name: {row['Name']}, Age: {row['Age']}")

In this case, the DictReader() function treats the first row of the CSV as headers, allowing you to reference columns by their header names.

Writing to CSV Files

Writing to a CSV file is just as straightforward.

The csv.writer() function creates a writer object that allows you to write rows to a file.

Example: Writing to a CSV File

import csv

# Data to write to CSV
data = [
    ["Name", "Age", "Occupation"],
    ["Alice", 30, "Engineer"],
    ["Bob", 25, "Designer"],
    ["Charlie", 35, "Teacher"]
]

# Open a CSV file for writing
with open('output.csv', 'w', newline='') as file:
    writer = csv.writer(file)

    # Write each row of data
    writer.writerows(data)

In this example, we write multiple rows of data to a CSV file using writer.writerows().

Each sublist in the data list represents a row in the CSV.

Working with JSON Files

JSON (JavaScript Object Notation) is a lightweight data-interchange format that is easy for humans to read and write, and easy for machines to parse and generate.

Python’s json module provides functions to read from and write to JSON files, making it a common format for working with structured data.

Reading JSON Files

Reading a JSON file in Python is as simple as using the json.load() function, which converts the JSON data into Python data structures (e.g., dictionaries or lists).

Example: Reading a JSON File

import json

# Open and read the JSON file
with open('data.json', 'r') as file:
    data = json.load(file)

# Accessing JSON data as a Python dictionary
print(data['name'])
print(data['age'])

In this example, we load the JSON data into a Python dictionary and access individual elements by their keys.

Writing to JSON Files

To write Python data to a JSON file, you can use the json.dump() function.

This function serializes Python objects into a JSON-formatted string and writes it to a file.

Example: Writing to a JSON File

import json

# Data to write to JSON
data = {
    "name": "Alice",
    "age": 30,
    "occupation": "Engineer"
}

# Open a JSON file for writing
with open('output.json', 'w') as file:
    json.dump(data, file, indent=4)

In this example, we write a Python dictionary to a JSON file.

The indent=4 argument ensures that the JSON output is formatted nicely with indentation for better readability.

Working with Binary Files

Binary files store data in binary format, and are used for non-text data such as images, audio, video, and serialized data.

Unlike text files, you need to open binary files in binary mode ('rb', 'wb') to read or write them.

Reading Binary Files

To read a binary file, you can open it in 'rb' mode and read the data as bytes.

Example: Reading a Binary File

# Open the binary file for reading
with open('image.png', 'rb') as file:
    binary_data = file.read()

# Print the first 10 bytes of the file
print(binary_data[:10])

In this example, we open an image file in binary mode and read its contents as bytes.

You can then process the binary data depending on your use case (e.g., image manipulation, audio processing).

Writing to Binary Files

Writing binary data is just as easy.

You need to open the file in 'wb' mode and write the data as bytes.

Example: Writing to a Binary File

# Binary data to write
binary_data = b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR'

# Open the binary file for writing
with open('output_image.png', 'wb') as file:
    file.write(binary_data)

In this example, we write binary data to a file, which could be part of an image, audio, or any other binary format.

Conclusion

In this post, we explored advanced file operations in Python, focusing on working with CSV, JSON, and binary files.

Each format has its own use case, and Python provides simple, built-in tools to help you read from and write to these file types effectively.

• CSV: Ideal for tabular data, and easily handled with the csv module.
• JSON: Perfect for structured data, especially when working with APIs and web data.
• Binary Files: Useful for non-text data like images, audio, and videos, and can be handled using binary mode.

With these techniques, you’re now equipped to handle various file formats in Python, making your programs more versatile and capable of processing a wide range of data.

Thank you for following along in this series on file handling in Python!

Ready to enhance your coding skills? Check out Developer Service Blog Courses for beginner-friendly lessons on core programming concepts.

Start learning today and build your path to becoming a confident developer! 🚀

If you would like this post, learn from it, and would like to support my work, consider leaving a small donation:

If you are not a Premium Django Series Subscriber, sign up below and get a 25% discount on the yearly membership:

Feel free to use the feedback buttons or send in a comment for future content you would love to see or what new things you learned from this post.

Also, share it with a friend who would love to read it.