Adventures in Machine Learning

Mastering SQL in Python: A Comprehensive Guide

Introduction to Using SQL in Python

SQL (Structured Query Language) is a language commonly used for databases. It is a powerful language that allows users to manipulate the data stored in a database efficiently.

Python, on the other hand, is a popular programming language that has gained traction over the years because of its simplicity and versatility. When combined, SQL in Python provides a robust tool for handling and manipulating databases.

In this article, we will explore SQL in Python and learn how to use it to manipulate databases effectively. We will start by introducing SQLite, one of the most popular serverless database management systems.

We will then dive into the steps to use SQL in SQLite

SQLite is a lightweight serverless database management system adopted widely by developers due to its zero-configuration and serverless architecture. SQLite operates on the “write-ahead logging” and “serialization” techniques, and all its data is stored in a single file.

SQLite works with Python using the “sqlite3” module. SQLite is a small, fast, reliable, and easy-to-use SQL database engine that is self-contained and requires no configuration.

Its serverless architecture makes it easier to manage, update and secure the database, making it a preferred solution for developers who do not require the resources a full-fledged relational database can provide.

Steps to Use SQL in Python

Now, let’s explore the steps needed to use SQL in Python.


Importing the SQLite Module

The first step in using SQL in Python is to import the “sqlite3” module. The module can be imported using the “import” keyword.


import sqlite3


2. Creating a Database Connection

After importing the “sqlite3” module, we need to establish a connection to the SQLite database.

We create a connection object through the connect method that takes the database name. Suppose the database does not exist.

Still, the connect() method creates a database, while if the database exists, the connect() method establishes the connection.


conn = sqlite3.connect(‘example.db’)


This code creates a new SQLite database “example.db” in the same directory as the Python script or opens an existing “example.”db” database.

A connection object “conn” to interact with the database is established.


Creating Tables and Inserting Data

After establishing a connection to the database, we can create tables and insert data into these tables in the SQLite database using SQL statements.

To create a table, we need to open a cursor object and execute an SQL statement.


c = conn.cursor()

c.execute(”’CREATE TABLE stocks

(date text, trans text, symbol text, qty real, price real)”’)


The above code creates a new table “stocks” with columns date, trans, symbol, qty and price.

After creating the table, we can now insert data into it.


c.execute(“INSERT INTO stocks VALUES (‘2006-01-05′,’BUY’,’RHAT’,100,35.14)”)


The above code inserts new data into the stocks table. The values inside the “INSERT INTO” statement need to match the columns declared when creating the table.

4. Fetching Data

Finally, to fetch data from the database, we can execute an SQL SELECT statement and use the fetchall() method to retrieve the data.


c.execute(“SELECT * FROM stocks”)



The above code retrieves data from the “stocks” table and prints it to the console.


SQL in Python provides a powerful tool for manipulating databases efficiently. We introduced SQLite, a popular serverless database management system that can be used with Python using the “sqlite3” module.

We also went through the steps to use SQL in Python, from establishing a connection to the database, creating tables and inserting data, to fetching data from the database using SQL statements.

By using SQL in Python, developers can easily manage and manipulate databases in a way that can improve their productivity and reduce errors.

As databases become an increasingly integral part of many applications, mastering SQL in Python will prove to be a necessary skill for developers in the future.

Creating and Using a Cursor Object

In the previous section, we walked through the steps to establish a database connection and create tables using SQL commands. Now, we will explore how to create and use a cursor object to execute SQL commands.

A cursor object is used to execute SQL commands in Python and fetch data from the connected database.

Creating the Cursor Object

To create a cursor object, we call the cursor() method on our established database connection object.


conn = sqlite3.connect(‘example.db’)

cursor = conn.cursor()


Now that we have created a cursor object, we can begin executing SQL commands.

Using SQL Commands to Create Tables

We can use SQL commands to create tables in our connected SQLite database. We will use the execute() method on our cursor object to execute SQL statements.


cursor.execute(”’CREATE TABLE students (


name TEXT,

age INT)”’)


The above code creates a new table named “students” with columns for “id”, “name”, and “age.” The “PRIMARY KEY” indicates that the “id” column is the primary key for the table. Once we have executed the SQL command, we need to commit the changes using the commit() method, or else no changes will be made to the database.




This code commits the changes to our database. At this point, the “students” table has been created.

Adding Data to the Database

To add data to our newly created table, we can use the INSERT INTO command. We will use execute() method to insert data.


cursor.execute(“INSERT INTO students(name, age) VALUES (?, ?)”, (“Alice”, 21))


The above code inserts data into the “students” table. The data inserted includes a name and age value of “Alice” and 21, respectively.

We use the “?” placeholder syntax to pass in the values. Again, we need to commit the changes to the database using the commit() method.




Fetching Data from the Database

Once we have added data to our table, we may want to retrieve it. We can use the SELECT statement to do this.

We will use execute() method to fetch our data. “`

cursor.execute(“SELECT * FROM students”)

rows = cursor.fetchall()


The code above fetches all the data in the “students” table and stores it in a variable called “rows.” This data is in the form of tuples, with each tuple representing a row in the table.

Printing Data

To print the data stored in the “rows” variable, we can use a for loop with the print() method. “`

for row in rows:



The above code will print out each row in the “students” table to the console.


In this section, we learned how to create and use a cursor object to execute SQL commands in Python. We explored how to create tables in SQLite using native SQL commands, add data to the database using the INSERT INTO command, and retrieve data from the database using the SELECT statement.

Finally, we learned how to print the data retrieved from the database using a for loop with the print() method. By mastering these techniques, you will be able to more effectively manage databases using Python and SQL commands.

Conclusion and Recap

In this article, we discussed the basics of using SQL in Python. We started by introducing SQLite, a widely used serverless database management system, and how it can be used with Python.

We then walked through the steps to use SQL in Python, highlighting how to establish a database connection, create tables and add data to it, fetch data from the database, and print the retrieved data. By mastering these basics, one can use SQL efficiently to manage databases using Python.

One key takeaway from this discussion is that using SQL in Python is a versatile and straightforward approach to managing databases. Python’s concise and readable syntax makes it easy to understand and use SQL, even for beginners.

With minimal setup, developers can use SQLite to create databases and perform various SQL operations, including creating tables, inserting data, and searching for data. Another takeaway from this article is that SQL in Python is not limited to SQLite.

Python developers can also use other relational database management systems like PostgreSQL and MySQL and apply the same concepts discussed above to work with those databases. PostgreSQL is a powerful and open-source database management system that has grown in popularity in recent years, while MySQL is a reliable database management system that’s been around for some time.

Developers can choose which database management system to use based on their project requirements.

Additional Resources

If you’re interested in learning more about SQL and using it in Python, there are several resources available. Here are a few suggestions:


SQLite Tutorial – This tutorial from provides an in-depth guide to using SQLite with Python. It covers basic SQLite concepts, creating and updating tables, and more.

2. PostgreSQL Tutorial – This online tutorial provides an excellent introduction to using PostgreSQL with Python.

It covers connecting to the database, querying data, and more. 3.

MySQL Tutorial – This online tutorial provides a comprehensive guide to using MySQL with Python. It covers everything from connecting to the database to creating tables and querying data.

4. SQLAlchemy – SQLAlchemy is a Python SQL toolkit and ORM that provides a full suite of well-known enterprise-level persistence patterns.

It allows you to represent tables and relationships as Python classes and provides a simple yet powerful way to access databases from Python. 5.

Pandas – Pandas is a Python library for data manipulation and analysis. It includes a powerful and flexible SQL-like data querying system called “pandasql” that allows you to query and analyze data using SQL syntax.

In conclusion, SQL in Python is a powerful and versatile tool for managing databases effectively. Learning to use SQL in Python enables you to create, manage, and query complex databases with ease.

With the addition of third-party libraries like SQLAlchemy and Pandas, developers have even more options for working with SQL in Python. In summary, SQL in Python provides a powerful and straightforward solution for managing databases effectively.

By establishing a database connection using SQLite, PostgreSQL, or MySQL, developers can create tables, insert data, and fetch data using SQL commands. Using a cursor object and execute() method, developers can execute SQL commands to manipulate databases efficiently.

Additional resources like SQLAlchemy and Pandas provide even more options for working with SQL in Python. With minimal setup, mastering basic SQL operations in Python enables developers to manage and manipulate databases easier.

No matter the database management system used, SQL in Python offers vast possibilities and holds immense importance for handling and manipulating databases.

Popular Posts