# File Formats Covered in Python Application Development: A Complete Guide to Python-100-Days

> Learn Python file formats like CSV JSON text Pickle SQL and Jupyter Notebooks for data persistence API communication and database management in Python applications. Master essential file handling skills.

- Repository: [骆昊/Python-100-Days](https://github.com/jackfrued/Python-100-Days)
- Tags: how-to-guide
- Published: 2026-02-24

---

**The Python-100-Days repository demonstrates how to work with CSV, JSON, plain text, Pickle, SQL dumps, and Jupyter Notebooks as the essential file formats for data persistence, API communication, and database management in Python applications.**

The `jackfrued/Python-100-Days` curriculum provides comprehensive coverage of file formats that Python developers encounter in real-world applications. Understanding these formats is crucial for building data pipelines, configuring applications, and managing database migrations. This guide examines the specific file formats covered in Python application development according to the repository's source code and documentation.

## Structured Data Formats: CSV and JSON

The repository emphasizes **CSV** and **JSON** as the primary formats for structured data exchange in Python applications.

### CSV Files for Tabular Data Analysis

**CSV** (Comma-Separated Values) serves as the standard format for tabular data storage and machine learning datasets. The Python-100-Days curriculum demonstrates CSV handling using both the high-performance `pandas.read_csv` function and the standard library `csv` module.

In `Day21-30/23.Python读写CSV文件.md`, the repository explains native CSV parsing, while `Day66-80/76.深入浅出pandas-5.md` focuses on data analysis workflows:

```python
import pandas as pd

# Load a CSV located in the same directory

df = pd.read_csv('data/boston_house_price.csv')
print(df.head())

```

### JSON for API Communication and Configuration

**JSON** (JavaScript Object Notation) functions as the universal format for web API communication and lightweight configuration files. The repository covers JSON serialization using the built-in `json` module in `Day21-30/22.对象的序列化和反序列化.md`.

```python
import json

payload = {'name': 'Alice', 'age': 30, 'hobbies': ['reading', 'hiking']}
json_str = json.dumps(payload, ensure_ascii=False, indent=2)

with open('profile.json', 'w', encoding='utf-8') as f:
    f.write(json_str)

```

## Binary Serialization and Plain Text

Beyond structured data, Python applications require **plain text** handling for logs and **binary serialization** for object persistence.

### Plain Text Files for Logging and Simple Storage

Plain text remains essential for log files, configuration scripts, and simple data storage. The repository demonstrates Python's native file I/O capabilities in [`Day31-35/code/example06.py`](https://github.com/jackfrued/Python-100-Days/blob/main/Day31-35/code/example06.py) using the `open()` function with context managers.

```python

# Write

with open('notes.txt', 'w', encoding='utf-8') as f:
    f.write('Learning Python file I/O is straightforward.\n')

# Read

with open('notes.txt', 'r', encoding='utf-8') as f:
    content = f.read()
print(content)

```

### Pickle for Python Object Persistence

**Pickle** provides binary serialization for complex Python objects that JSON cannot represent, such as custom classes and machine learning models. The repository covers Pickle in `Day21-30/22.对象的序列化和反序列化.md` and references it as a common interview topic in `Day91-100/99.面试中的公共问题.md`.

```python
import pickle

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

alice = Person('Alice', 30)

# Serialize

with open('person.pkl', 'wb') as f:
    pickle.dump(alice, f)

# Deserialize

with open('person.pkl', 'rb') as f:
    loaded = pickle.load(f)
print(loaded.name, loaded.age)

```

## Database and Interactive Development Formats

Production Python applications require **database migration scripts** and **interactive development environments** for data exploration.

### SQL Dump Files for Database Migration

**SQL dump** files facilitate database backup and migration workflows in production environments. The repository demonstrates MySQL database export using `mysqldump` in `Day91-100/98.项目部署上线和性能调优.md`.

```bash
mysqldump -u root -p123456 -A -B > backup_$(date +"%Y%m%d%H%M%S").sql

```

### Jupyter Notebooks for Exploratory Analysis

**Jupyter Notebooks** (`.ipynb`) combine code, visualization, and documentation for interactive data exploration. The repository utilizes notebooks extensively in `Day66-80/code/day05.ipynb` to demonstrate integrated workflows combining CSV, JSON, and Pickle operations within a single reproducible environment.

## Summary

- **CSV** and **JSON** serve as the primary structured data formats for tabular data and API communication, implemented through `pandas` and the standard `json` module.
- **Plain text** files remain essential for logging and simple storage, handled via Python's native `open()` function.
- **Pickle** enables binary serialization of complex Python objects that JSON cannot represent, useful for caching and session storage.
- **SQL dump** files facilitate database backup and migration in production environments.
- **Jupyter Notebooks** provide an interactive format for combining code execution, data visualization, and documentation.

## Frequently Asked Questions

### What is the most common file format for data analysis in Python?

**CSV** is the most common format for data analysis in Python applications. The Python-100-Days repository demonstrates CSV handling through both the `pandas.read_csv` function for high-performance data analysis and the standard library `csv` module for lightweight parsing without external dependencies.

### When should I use Pickle instead of JSON?

Use **Pickle** when you need to serialize complex Python objects that **JSON** cannot represent, such as custom class instances, machine learning models, or nested Python-specific data structures. However, only use Pickle for internal Python-to-Python communication, as JSON remains the standard for cross-language API communication and human-readable configuration files.

### How do I handle large CSV files efficiently?

For large CSV files, use **pandas** with chunking parameters or the standard `csv` module with iterator patterns to process data in batches rather than loading the entire file into memory. The repository's `Day66-80/76.深入浅出pandas-5.md` demonstrates advanced CSV loading techniques for handling substantial datasets within memory constraints.

### Are Jupyter Notebooks suitable for production code?

**Jupyter Notebooks** excel for exploratory data analysis, visualization, and teaching, but they are generally not suitable for production deployment due to version control challenges and execution order complexity. The Python-100-Days repository uses notebooks in `Day66-80/code/day05.ipynb` primarily for interactive learning and prototyping, while recommending standard `.py` files for production application code.