Pandas: How to store a DataFrame in a SQLite table

Updated: February 19, 2024 By: Guest Contributor Post a comment


Pandas and SQLite are powerful tools for data analysis and database management, respectively. In this tutorial, we’ll explore the integration between them by showing how you can efficiently store a Pandas DataFrame in a SQLite table. This technique is incredibly useful for those looking to persist their data manipulation results for later retrieval, analysis, or sharing with others.

Introduction to Pandas and SQLite

Before diving into the specifics, it’s important to understand the basics. Pandas is a Python library providing high-performance, easy-to-use data structures, and data analysis tools. On the other hand, SQLite is a C-language library that implements a small, fast, self-contained, high-reliability, full-featured SQL database engine. SQLite is the most used database engine in the world and is built into all mobile phones and most computers.

Setting Up Your Environment

The first step is to ensure that you have both Pandas and SQLite installed in your Python environment. You can install Pandas and a SQLite3 driver using pip:

pip install pandas sqlalchemy

SQLAlchemy is a Python SQL toolkit that makes it easier to communicate with databases using Python objects; it’s our recommended tool for this operation.

Basic Usage: Storing a DataFrame in SQLite

Let’s start with a basic example where we create a DataFrame and store it into a SQLite database.

import pandas as pd
from sqlalchemy import create_engine

# Create a DataFrame
df = pd.DataFrame({
    'id': [1, 2, 3, 4],
    'name': ['Alice', 'Bob', 'Charlie', 'David'],
    'age': [24, 30, 35, 40]

# Create SQLite engine
db_engine = create_engine('sqlite:///mydatabase.db')

# Store DataFrame in SQLite
df.to_sql('users', con=db_engine, if_exists='replace', index=False)

With the above code, we’ve created a simple DataFrame and stored it into a SQLite table named users. The if_exists='replace' parameter tells the database engine to drop the table if it already exists, and create a new one.

Reading Back Data from SQLite

Storing data is important, but so is retrieving it. Here’s how you can read your data back from SQLite using pandas.

pd.read_sql('select * from users', con=db_engine)

This will retrieve the entire users table and load it back into a new DataFrame. The beauty of using Pandas with SQLite is that you can seamlessly integrate SQL queries into your data analysis process.

Advanced Usage

Now that we’ve covered the basics, let’s dive into some advanced ways to work with your data and SQLite.

Handling Larger Datasets

If you’re working with particularly large datasets that might not fit into memory all at once, you can use the chunksize parameter when calling to_sql. This allows you to write the DataFrame to the database in chunks.

df.to_sql('big_data', con=db_engine, if_exists='replace', index=False, chunksize=1000)

This is especially useful when dealing with large amounts of data or on machines with limited memory.

Using SQL Alchemy for More Complex Operations

While Pandas does a great job at simplifying data manipulation and the to_sql method caters for basic storage needs, sometimes you might require more control over your database interactions. SQLAlchemy, which we installed earlier, allows for more complex operations and gives you the power to execute raw SQL queries, manage database connections, and more.

from sqlalchemy import text

db_engine.execute(text("""INSERT INTO users (id, name, age) VALUES (5, 'Eve', 45)"""))

Here, we manually insert a new record into the users table. This technique is useful for when you need to combine the flexibility of SQL with the power of pandas for advanced data manipulation and analysis.


Through this tutorial, we’ve seen how to store a pandas DataFrame in a SQLite table, retrieve data, handle larger datasets, and perform more complex SQL operations. Mastering these techniques will empower you to manage and analyze your data more effectively, making your workflows much more efficient and versatile.