How to Use SQL in Python: A Comprehensive Guide

By Cristian G. Guasch • Updated: 06/28/23 • 19 min read

Learning to use SQL in Python has become an essential skill in today’s data-driven world. With businesses relying heavily on data analysis and decision-making backed by solid information, it’s crucial to have the right tools at hand. This article will shed light on how to seamlessly combine SQL and Python, two powerful tools that can significantly improve workflow and simplify the process of working with data.

To harness the power of SQL in Python, various libraries have been developed to help bridge the gap between the two languages. These libraries, such as psycopg2, SQLite3, and SQLAlchemy, enable developers to write SQL queries and interact with databases directly within their Python code. This integration not only adds versatility to Python but also allows users to take advantage of SQL’s robust features while maintaining the ease of use and readability that Python is known for.

Once equipped with the knowledge of how to use SQL in Python, developers can build data-driven applications, perform complex data analysis, and better meet the demands of their projects. By using these two languages in conjunction, one can unlock a wealth of possibilities and streamline tasks that once seemed daunting. Stay tuned to find out more about using SQL in Python and get ready to supercharge your data manipulation capabilities.

Understanding SQL and Python

SQL and Python have become widely popular tools for managing and analyzing data. When developers want to combine the capabilities of these two powerful tools, they often seek to learn how to use SQL in Python. This section aims to provide a brief introduction to both SQL and Python, and how they can be used together for advanced data manipulation tasks.

Structured Query Language (SQL) has been the go-to language for database management and data manipulation since its inception in the 1970s. This domain-specific language allows users to perform tasks such as inserting, updating, deleting, and querying data stored in relational databases like MySQL, PostgreSQL, and SQLite. In today’s data-driven world, SQL remains a fundamental skill for data analysts, DBAs, and developers.

Python, on the other hand, is a versatile and powerful general-purpose programming language that has gained popularity over the years. Known for its simplicity and readability, Python continues to be a favorite among beginners and experts alike. The language’s extensive library provides numerous packages and modules for various tasks, including data analysis, web development, and machine learning.

To use SQL in Python, programmers commonly adopt the following approaches:

  • Built-in Python Libraries: Python includes native support for SQLite, a lightweight and serverless relational database system. The sqlite3 module enables developers to connect to and interact with SQLite databases directly in Python.
  • Database Management Systems (DBMS) Connectors: Multiple third-party packages allow Python to connect to various relational databases. Examples of these connectors include psycopg2 for PostgreSQL, mysql-connector-python for MySQL, and pyodbc for Microsoft SQL Server.
  • Object Relational Mapping (ORM) Tools: These tools, like SQLAlchemy and Django ORM, provide a SQL database abstraction layer, enabling developers to work with a relational database using Python classes and objects. Using an ORM tool can offer a more Pythonic and efficient way of interacting with databases.

When using SQL in Python, developers can leverage Python libraries and packages to achieve complex data manipulation tasks more efficiently. By combining the power of SQL and Python, data analysts, developers, and DBAs can unlock new possibilities for managing and analyzing data.

Setting Up Your Python Environment

To start using SQL in Python, one must first set up the Python environment. This process involves several essential steps, such as installing the necessary software, configuring your system, and understanding how to use different libraries.

The first step towards utilizing SQL in Python is installing Python itself. While some systems come with Python pre-installed, you might need to download the latest version from the official website ( Once the installation is complete, verify it by typing python --version in your command prompt or terminal.

After installing Python, you’ll need to install a database connector to use SQL databases within your Python scripts. One popular library for this purpose is sqlite3. This library comes pre-built with Python and doesn’t require a separate installation. On the off chance that it’s not available, you can use the following command for installation:

pip install sqlalchemy

For connecting to other databases, such as MySQL or PostgreSQL, additional libraries are available:

  • MySQL: Install the mysql-connector-python library using the command: pip install mysql-connector-python
  • PostgreSQL: Install the psycopg2 library using the command: pip install psycopg2

Throughout this process, it’s wise to use a virtual environment. Doing so isolates your project from the rest of your system, ensuring that your project has its dependencies in one place. To create and use a virtual environment, follow these steps:

  1. Install the virtual environment package: pip install virtualenv
  2. Navigate to your project folder and create a virtual environment with the command: virtualenv venv
  3. Activate the virtual environment:
    • Windows: venv\Scripts\activate
    • macOS/Linux: source venv/bin/activate

Knowing which libraries to use is vital when working with SQL in Python. Here are a few popular libraries that can help you manipulate and query SQL databases:

  • SQLAlchemy: An ORM (Object Relational Mapper) that allows you to map Python objects to database tables, making SQL queries simpler and more Pythonic.
  • Pandas: Though primarily used for data analysis, Pandas can work with SQL databases as well. It can load SQL queries into a DataFrame, allowing you to manipulate and analyze data seamlessly.
  • SQLObject: Another ORM that lets developers work with databases using Python objects and methods, instead of writing raw SQL queries.

With your Python environment properly set up, you’re now ready to dive into using SQL in Python and exploring the numerous tools and libraries available for efficient database management.

Making a Connection with a Database

Integrating SQL in Python can be a powerful combination for managing and analyzing data. To use SQL effectively in Python, one must first establish a connection with a database. There are several libraries available to achieve this, but in this article, we’ll focus on the most popular one: SQLite.

SQLite is an excellent choice for beginners because of its simplicity and ease of use. It’s a serverless, self-contained database engine that does not require a separate server process. It only needs a few lines of code to connect to a database and perform database-related operations. Let’s dive into the process of making a connection with a database using SQLite.

The first step is installing the SQLite module. Python 3 comes with a built-in SQLite module called sqlite3, so there’s no need to install anything further. However, if you are using Python 2, you’ll need to install the pysqlite module. Once the SQLite module is available, you can start establishing a connection:

import sqlite3
conn = sqlite3.connect('example.db')

With this code, a connection to a database called example.db is established. If the file does not exist, SQLite will generate it automatically.

Once a connection is made, the database can be interacted with through the use of cursors. Cursors are necessary to execute SQL commands using Python. Here’s how to create a cursor:

cursor = conn.cursor()

To execute SQL queries using the cursor, the execute() method is employed. For instance, to create a new table named users, the following code can be used:

cursor.execute('''CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, age INTEGER)''')

After executing an SQL command, it’s essential to commit the changes. This action confirms the transaction and guarantees that any changes made persist in the database:


Lastly, it’s crucial to close the connection once all the necessary operations are finished. This ensures proper resource management:


In summary, connecting to a database using SQL in Python is a relatively straightforward process. With just a few lines of code, SQLite allows users to connect to a database and perform SQL operations. As always, it’s vital to properly manage connections, cursors, and transactions, ensuring efficient and seamless data management.

Executing SQL Queries in Python

SQL in Python has become increasingly popular, given Python’s versatility and ease of use. Connecting to databases and executing SQL queries is a critical component of working with data in a Python environment. To accomplish this, various libraries can be utilized. In this section, we’ll explore how to execute SQL queries in Python using two popular libraries, namely sqlite3 and SQLAlchemy.


The sqlite3 library comes bundled with Python and provides an easy way to interact with SQLite databases. Here’s a simple example to get started:

  1. Import the sqlite3 library: import sqlite3
  2. Connect to the database (this will create a new file if it doesn’t exist): connection = sqlite3.connect('example.db')
  3. Create a cursor object to interact with the database: cursor = connection.cursor()
  4. Execute an SQL query: cursor.execute('CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT, age INTEGER)')
  5. Use the cursor object to INSERT data: cursor.execute("INSERT INTO users (name, age) VALUES ('John Doe', 30)")
  6. Commit the changes and close the connection: connection.commit() connection.close()


SQLAlchemy is a powerful and versatile Object Relational Mapper (ORM) library for Python. With SQLAlchemy, developers can interact with databases using Python objects and classes rather than raw SQL queries. Here’s an example using SQLAlchemy:

  1. Install the library using pip: pip install sqlalchemy
  2. Import necessary modules: from sqlalchemy import create_engine, Column, Integer, String from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm import sessionmaker
  3. Define a Python class to represent the database table: Base = declarative_base() class User(Base): __tablename__ = 'users' id = Column(Integer, primary_key=True) name = Column(String) age = Column(Integer)
  4. Connect to the database and initialize the table: engine = create_engine('sqlite:///example.db') Base.metadata.create_all(engine)
  5. Create a session to interact with the database: Session = sessionmaker(bind=engine) session = Session()
  6. Add a new User object to the database: new_user = User(name='Jane Doe', age=28) session.add(new_user)
  7. Commit the changes and close the session: session.commit() session.close()

No matter which library is preferred, executing SQL queries in Python opens up numerous possibilities for data processing and manipulation. Both sqlite3 and SQLAlchemy offer easy-to-use features for working with databases, and their functionality can be further extended with additional libraries and tools.

Using SQLAlchemy for SQL in Python

SQLAlchemy offers a powerful way to use SQL in Python, making it much simpler for developers to build advanced applications. It’s not only an Object Relational Mapper (ORM) framework, but also a versatile SQL toolkit, giving users the ability to communicate effectively with databases.

Integrating SQL with Python becomes a breeze when utilizing SQLAlchemy. Here’s a breakdown of the steps involved:

  1. Installation: First, you’ll need to install the SQLAlchemy package. To do this, use the following command in the terminal or command prompt:
pip install sqlalchemy
  1. Creating a Connection: To establish a connection to the database, you’ll need to create an engine object. The syntax for this process is as follows:
from sqlalchemy import create_engine
# Replace 'dialect+driver://username:password@host:port/database' with your database credentials
engine = create_engine('dialect+driver://username:password@host:port/database')
  1. Executing Queries: Once connected to the database, you can execute SQL queries directly through SQLAlchemy. This feature enables seamless integration of SQL in Python programs. Check out an example of executing a query:
with engine.connect() as connection:
    result = connection.execute("SELECT * FROM table_name")
  1. Working with ORM: Adopting the ORM approach can simplify complex queries and provide a more Pythonic way to interact with databases. To use this feature, follow these steps:
    • Define the model, also known as the schema representing your database table.
    • Map the table to the model by using SQLAlchemy’s declarative base.
    • Create session objects to interact with the database.

Here’s an example of defining a model:

from sqlalchemy import Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

class SampleTable(Base):
    __tablename__ = 'sample_table'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    age = Column(Integer)

If you need to perform complex operations, SQLAlchemy also offers features like joining tables, filtering data, and ordering results. This versatility makes it an excellent choice for integrating SQL in Python applications.

In summary, using SQLAlchemy to incorporate SQL in Python applications provides numerous advantages and simplifies database interactions. The combination of ORM and SQL querying capabilities offers developers the best of both worlds, ensuring that complex tasks become more manageable.

Inserting Data into a Database

Inserting data into a database is a crucial step when working with SQL in Python. This process involves adding new records to existing tables within the database. Before diving into the details, it’s important to understand the basic structure of SQL queries in Python.

There are several Python libraries available for interacting with SQL databases, with SQLite being one of the most popular. This lightweight, serverless database offers an easy-to-use interface for performing various SQL operations within a Python environment. To begin, users will need to import the necessary library:

import sqlite3

With the required library in place, it’s essential to establish a connection to the database. The following code snippet illustrates how to create a new database or connect to an existing one:

connection = sqlite3.connect('example.db')

Once connected, a cursor object is necessary for executing SQL commands:

cursor = connection.cursor()

Now let’s explore how to insert data into a database using SQL in Python. The syntax for inserting data follows the pattern:

INSERT INTO table_name (column1, column2, column3, ...) VALUES (value1, value2, value3, ...);

Here’s an example illustrating how to insert a single record into a hypothetical table called employees:

cursor.execute("INSERT INTO employees (first_name, last_name, age) VALUES ('John', 'Doe', 35)")

When adding multiple records, consider using the executemany method. This technique saves time by executing the command in a single transaction:

employees_data = [
    ('Jane', 'Doe', 28),
    ('Mark', 'Smith', 45),
    ('Sara', 'Johnson', 33)

cursor.executemany("INSERT INTO employees (first_name, last_name, age) VALUES (?, ?, ?)", employees_data)

To commit these changes, the commit method must be called on the connection object:


Lastly, it’s common practice to close the connection to the database after completing all operations:


In summary, inserting data into a database with SQL in Python requires the following steps:

  • Importing the necessary library (e.g., sqlite3)
  • Establishing a connection to the database
  • Creating a cursor for executing SQL commands
  • Formulating the SQL query to insert data
  • Executing the query with the appropriate method (execute or executemany)
  • Committing the transaction
  • Closing the connection to the database

Following this procedure, users can successfully add new records to their SQL databases using Python.

Fetching Data from Your Database

When working with databases while using SQL in Python, one of the most essential steps is fetching data. This section will guide you on how to efficiently obtain the desired information from your database.

Firstly, to connect your Python application with your SQL database, you’ll need an SQL library. The most common choices include:

  • MySQL Connector/Python for MySQL databases
  • psycopg2 for PostgreSQL databases
  • SQLite3 for SQLite databases

After choosing the appropriate SQL library, ensure it’s installed in your Python environment.

Once the connection between the database and the Python application is established, you can start sending queries to fetch data. For the purpose of this tutorial, let’s assume a database named ‘inventory’ contains a ‘products’ table. Your main goal is to retrieve information about products with specific criteria.

Begin by importing the applicable library and establishing a connection with the database:

import connector_library_example as cle

connection = cle.connect(user='username', password='password', host='hostname', database='inventory')

Now that you’ve connected to the database, you can create a cursor. Cursors act like intermediaries between your queries and the fetched data. To create a cursor, you simply need to run:

cursor = connection.cursor()

With the cursor established, you can execute any standard SQL query. For instance, if you want to fetch all products with a price under $50, you can use the following query:

cursor.execute("SELECT * FROM products WHERE price < 50")

Now, to obtain the results, there are several methods available:

  1. fetchone() returns the next row of the result set as a tuple. It’s perfect for situations where you expect only one result. product = cursor.fetchone()
  2. fetchmany(size) retrieves the specified number of rows from the result set. products = cursor.fetchmany(size=5)
  3. fetchall() returns all the remaining rows of the result set as a list of tuples. This method can consume considerable amounts of memory if the result set is large. products = cursor.fetchall()

Lastly, after fetching the data, don’t forget to close both the cursor and the connection:


In summary, fetching data from a database in Python is as simple as connecting to the database, creating a cursor, executing an SQL query, and retrieving the results with the appropriate method. Following these steps can help you gather the information you need from your SQL database efficiently.

Updating Records in the Database

Incorporating SQL in Python allows developers to interact with databases seamlessly, making it easier to perform various operations such as updating records. This section will discuss how to update records in the database using SQL in Python.

When working with SQL in Python, one useful package to consider is SQLite. SQLite provides a lightweight, serverless, and self-contained solution to include an SQL database engine in your Python application. To get started, follow these steps:

  1. Import the sqlite3 module in your Python script.
  2. Connect to the database by invoking the connect() method.
  3. Create a cursor object by calling the cursor() method on the connection object.
  4. Construct an SQL update statement to modify the records in the database.

The basic syntax for the SQL update statement is as follows:

UPDATE table_name SET column1 = value1, column2 = value2, ... WHERE some_condition;

Here’s an example of how to update records in a table using SQLite in Python:

import sqlite3

# Connect to the database
conn = sqlite3.connect('example.db')

# Create a cursor object
c = conn.cursor()

# Update records
c.execute("UPDATE employees SET salary = 70000 WHERE role = 'Engineer'")

# Commit changes

# Close the connection

Remember to use commit() after executing the update statement to save the changes. Otherwise, the updates won’t be persistent.

Some key points to remember:

  • Updating records using SQL in Python is a straightforward process that involves using an SQL update statement and a committed cursor object.
  • The SQLite provides an excellent package for database integration with Python applications.
  • Always use the commit() function after making updates, and close the connection when done.

Experimenting with different conditions and updating multiple columns simultaneously can further enhance database management skills when working with SQL in Python. Combining the power of SQL and Python results in an efficient and effective approach to managing databases with ease.

Deleting Records from a Database

Moving on to the ninth section, we’ll explore how to delete records from a database using SQL in Python. It’s important for developers to understand this process as it empowers them to manage databases effectively and maintain data accuracy.

To delete records, one typically uses the DELETE statement. Combining this with Python’s popular library, sqlite3, makes it much simpler to perform such operations. Recall that to use sqlite3, you’ll first need to import the library and establish a connection to the database.

Let’s start by discussing the steps involved in deleting records from a database with SQL in Python:

  1. Import the sqlite3 library: This can be done using the import sqlite3 command.
  2. Connect to the database: Use the sqlite3.connect() method to establish a connection.
  3. Create a cursor: Cursors enable you to execute SQL commands through Python. Initialize a cursor with the conn.cursor() function, where conn represents the connection.
  4. Create a query: Write a SQL DELETE query to specify which records to remove.
  5. Execute the query: Use the cursor.execute() method to run the query, specifying the records to be deleted.
  6. Commit the changes: After executing the query, it’s critical to commit the changes using conn.commit().
  7. Close the connection: Once the operation is complete, ensure you close the connection using conn.close().

Here’s an example of using these steps to delete records:

import sqlite3

# Connect to the database
conn = sqlite3.connect('example.db')

# Create a cursor
cursor = conn.cursor()

# Create the DELETE query
delete_query = "DELETE FROM employees WHERE id = 1"

# Execute the query

# Commit the changes

# Close the connection

In this example, records from the employees table with an id of 1 are deleted. You can modify the query as needed to delete specific records.

When working with SQL in Python, keep these best practices in mind:

  • Use ? placeholders instead of manually formatting values into the query string to avoid SQL injection attacks.
  • Implement error handling using try, except, and finally blocks to ensure proper clean-up and efficient handling of exceptions.

In summary, deleting records in a database using SQL in Python is a straightforward process by executing the DELETE statement and leveraging the power of the sqlite3 library. By following these steps and best practices, you’ll effectively maintain and manage databases with ease.


Throughout this article, the use of SQL in Python has been thoroughly explored. By now, readers should have a solid understanding of how to effectively integrate SQL into their Python projects. There are multiple advantages to using SQL in Python, which include:

  • Enhanced querying capabilities
  • Streamlined data manipulation
  • Improved data storage and retrieval

Utilizing SQL in Python allows for more complex and powerful applications that can manage, analyze, and store large volumes of data efficiently. The integration also enables developers to leverage Python’s extensive libraries and SQL’s robust querying features. Additionally, it offers the potential for users to see noticeable improvements in their overall workflow and productivity.

Various tools and libraries have been discussed, emphasizing their importance in facilitating the seamless integration process between SQL and Python. The most prominent libraries mentioned were:

  • SQLite3
  • SQLAlchemy
  • MySQL-Connector
  • Psycopg2

By choosing the appropriate tool, developers can quickly integrate SQL in Python without compromising on functionality. It’s important to weigh the pros and cons of each library to determine which one best fits the needs of your specific project.

In summary, SQL in Python integration offers the best of both worlds, giving developers access to powerful querying methods while maintaining the flexibility and versatility of Python. With a greater understanding of how to use SQL in Python, readers are now well-equipped to take on new projects and enhance their current applications through the integration of SQL and Python.

Related articles