Create a Contacts List Using PyQt, SQLite, and Python

This tutorial will teach you how to create a contact book application using Python, PyQt, and SQLite. This project will be an effective way to learn different coding skills, as it requires you to apply various techniques and encourages you to research topics during the development process.

By the end of this project, you will have a working contact book application that can store and manage your contact information. You can search for, view, add, modify, and remove contacts. This tutorial will guide you through the application process and give you a better understanding of how to create a GUI using Python and PyQt, connect to an SQLite database, and manage data using the Model-View architecture. The source code for the application and each tutorial step are available by following the link provided.

Project Overview

To build a contact book application, you must organize your code into modules and packages to give your project a clear and coherent structure. In this tutorial, you will use the following directory and file structure:

rpcontacts_project/ - The root directory of the project

rpcontacts/ - The package that contains the main code for the application

__init__.py - A blank file that instructs Python to treat this directory as a Python package.
views.py - The module that contains the code for the graphical user interface (GUI)
database.py - The module that contains the code for connecting to the SQLite database
main.py - The module that contains the code for running the application
model.py - The module that contains the code for managing the contact data using the Model-View architecture

requirements.txt - The file that contains the dependencies for the project
README.md - The file that contains the documentation for the project
rpcontacts.py - The file that runs the application

Step-by-step instructions will be provided for using each of these files.

Step 1: Using PyQt, create the Contact Book's Skeleton App

In this initial stage, you'll design a simple yet useful PyQt GUI application that will serve as the framework for the contact book. The bare minimum project structure, which consists of the project's core package and a script to launch the program, will also be created by you.

The Contact Book Project's Organization

Create a new directory called rpcontacts project/ to begin coding the application.

The project's root directory will be this. Now under rpcontacts project/, create a new subfolder called rpcontacts/. This subfolder will house the program's main package. Open your code editor or integrated development environment in the root directory.

Python requires a __init .py module to initialize the package to convert a directory into a package. Create this file in the rpcontacts/ directory, and then add the following code to it:

# -*- coding: utf-8 -*-

"""This module provides the rpcontacts package."""

__version__ = "0.1.0"

This file informs Python that the rpcontacts package exists. The code in the file is run when you import the package or one of its modules.

The package may be initialized without writing code in a __init .py file. It is sufficient to use an empty __init .py file. To keep the version number of your program in this instance, you establish a module-level constant named

Creating the Main Window for the Application

The primary pane for your contact book should now be created. To do that, add a module with the name views.py to your rpcontacts package.

Then update the module with the below code and save it:

# -*- coding: utf-8 -*-

"""This module provides views to manage the contacts table."""

from PyQt5.QtWidgets import (
    QHBoxLayout,
    QMainWindow,
    QWidget,
)

class Window(QMainWindow):
    """Main Window."""
    def __init__(self, parent=None):
        """Initializer."""
        super().__init__(parent)
        self.setWindowTitle("RP Contacts")
        self.resize(550, 250)
        self.centralWidget = QWidget()
        self.setCentralWidget(self.centralWidget)
        self.layout = QHBoxLayout()
        self.centralWidget.setLayout(self.layout)

You need to import the necessary classes first from PyQt5.QtWidgets.Next, you make a Window. The code for creating the application's main Window is provided by this class, which descended from QMainWindow.The Window is resized to 550 by 250 pixels, the Window's title is changed to "RP Contacts," and the center widget is defined and configured using QWidget. Then a horizontal box layout is used to define the layout for the central widget.

Running the Application and Coding

The primary Window for the contact book is already created. Therefore it's time to build the code for a working PyQt application using QApplication. Create a new module in your rpcontacts package named main.py and add the following code to it to accomplish that:

# -*- coding: utf-8 -*-
# rpcontacts/main.py

"""This module provides RP Contacts application."""

import sys

from PyQt5.QtWidgets import QApplication

from .views import Window

def main():
    """RP Contacts main function."""
    # Create the application
    app = QApplication(sys.argv)
    # Create the main Window
    win = Window()
    win.show()
    # Run the event loop
    sys.exit(app.exec())

When you import sys into this module, you have access to the exit() function, which enables you to gracefully end the program when the user quits the main Window. Next, import QtWidgets, QApplication, and Window from PyQt5, respectively. The last step is defining main() as your application's main function.

You create QApplication and Window inside of main(). After that, you use exec to start the application's main loop or event loop on Windows before calling show().

Create a file called rpcontacts.py in the root directory, rpcontacts project, immediately. The application's entry-point script is provided in this file. Save the file after adding the following code:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# rpcontacts_project/rpcontacts.py

"""This module provides RP Contacts entry point script."""

from rpcontacts.main import main

if __name__ == "__main__":
    main()

Your main.py module's main() is imported in this file. The conventional conditional statement is then put into practice, calling main() if the user runs this module like a Python script. Run the command python rpcontacts.py to start the program in your Python environment.

The following Window will appear on your screen:

Create a Contacts List Using PyQt, SQLite, and Python

Step 2: Using Python, create the Contact Book's GUI

In this step, we need to create Contact Books' GUI, which has Add, Delete, and Clear all buttons

Return to the views.py module and modify the Window code to produce the aforementioned GUI:

# -*- coding: utf-8 -*-

"""This module provides views to manage the contacts table."""

from PyQt5.QtWidgets import (
    QAbstractItemView,
    QHBoxLayout,
    QMainWindow,
    QPushButton,
    QTableView,
    QVBoxLayout,
    QWidget,
)


class Window(QMainWindow):
    """Main Window."""

    def __init__(self, parent=None):
        """Initializer."""
        super().__init__(parent)
        self.setWindowTitle("RP Contacts")
        self.resize(550, 250)
        self.centralWidget = QWidget()
        self.setCentralWidget(self.centralWidget)
        self.layout = QHBoxLayout()
        self.centralWidget.setLayout(self.layout)

        self.setupUI()

    def setupUI(self):
        """Setup the main window's GUI."""
        # Create the table view widget
        self.table = QTableView()
        self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
        self.table.resizeColumnsToContents()
        # Create buttons
        self.addButton = QPushButton("Add...")
        self.deleteButton = QPushButton("Delete")
        self.clearAllButton = QPushButton("Clear All")
        # Lay out the GUI
        layout = QVBoxLayout()
        layout.addWidget(self.addButton)
        layout.addWidget(self.deleteButton)
        layout.addStretch()
        layout.addWidget(self.clearAllButton)
        self.layout.addWidget(self.table)
        self.layout.addLayout(layout)

The first modification to Window in this code is a call to.setupUI() at the conclusion of __init__ ().

When you launch the application, this call creates the GUI for the main Window.

The inside code is shown here.What setupUI() does:

a QTableView instance is created and used to display the contacts list.
Sets QAbstractItemView as the value for the .selectionBehavior property.SelectRows. The data about each contact in the list of contacts is contained in the rows in the table view. This guarantees that the entire row will be selected when a user clicks on any table view cell.
Add the Add, Delete, and Clear All buttons to the GUI. These buttons don't currently do anything.
Establish a consistent layout for all the GUI widgets.

Once you run the code, this screen will appear:

Step 3: Constructing the Database for the Contact Book

In this section, you will create the code to specify how the application connects to the contact database. To finish this step, use PyQt's SQL support to connect the application to the database and use SQLite and your contact information to manage the database.

Initially, go back to main.py in the rpcontacts/ directory and update the code to create the database connection.:

# -*- coding: utf-8 -*-

"""This module provides RP Contacts application."""

import sys

from PyQt5.QtWidgets import QApplication

from .database import createConnection
from .views import Window


def main():
    """RP Contacts main function."""
    # Create the application
    app = QApplication(sys.argv)
    # Connect to the database before creating any window
    if not createConnection("contacts.sqlite"):
        sys.exit(1)
    # Create the main Window if the connection succeeded
    win = Window()
    win.show()
    # Run the event loop
    sys.exit(app.exec_())

An attempt to establish a connection to the database using createConnection can be seen in the main() function's line "from .database import createConnection" (). The call to sys. exit(1) will close the application without creating a graphical element and will indicate an error if the application cannot establish a connection for some reason.

Because the application relies on the database to function properly, you must handle the connection in this manner. Your application won't function if you don't have a working connection.

If a problem arises, you can handle it and close the application thanks to this practice. Additionally, you'll be able to give the user pertinent details about the application's error when connecting to the database.

Using PyQt and SQLite to Connect to the Database

The first step in creating your contact book application is connecting it to the database that goes with it. To accomplish this, you must program the function createConnection(), which opens and creates a connection to the database. The function will return True if the connection is successful. If not, it will detail what went wrong with the connection. Return to the rpcontacts/ directory and add a new database.py module. Then incorporate the following code into that module:

# -*- coding: utf-8 -*-

"""This module provides a database connection."""

from PyQt5.QtWidgets import QMessageBox
from PyQt5.QtSql import QSqlDatabase, QSqlQuery


def _createContactsTable():
    """Create the contacts table in the database."""
    createTableQuery = QSqlQuery()
    return createTableQuery.exec(
        """
        CREATE TABLE IF NOT EXISTS contacts (
            id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE NOT NULL,
            name VARCHAR(40) NOT NULL,
            job VARCHAR(50),
            email VARCHAR(40) NOT NULL
        )
        """
    )


def createConnection(databaseName):
    """Create and open a database connection."""
    connection = QSqlDatabase.addDatabase("QSQLITE")
    connection.setDatabaseName(databaseName)

    if not connection.open():
        QMessageBox.warning(
            None,
            "RP Contact",
            f"Database Error: {connection.lastError().text()}",
        )
        return False

    _createContactsTable()
    return True

Here, it would help if you imported a few PyQt classes first. Next, createConnection is defined (). This function's single argument, DatabaseName, specifies the name or location of the SQLite database file that is stored in your file system.CreateConnection is already coded by you (). Now that the database's contacts tables are ready, the code to create them can be written. You can now write a helper function to create the contacts table once the function for creating and opening the database connection is in place. This table will be used to keep track of your contacts' information.

You create a QSqlQuery instance in the _createContactsTable() function. After that, you call the exec() method of the query object with a string-based SQL CREATE TABLE statement.

Your database's contacts table will contain pertinent data about your contacts.

Adding a call to _createContactsTable() from inside createConnection(), just before the last return statement, completes database.py's coding. This guarantees that the application creates the contacts table before database operations. Once the contacts table has been created, you can test the database and add some sample data for additional testing.

Database Testing for the Contact Book

You've already finished writing the code to manage the database connection for the contact book. You'll run some tests in this section to verify the functionality of both this code and the database. Later in this tutorial, you'll add some test data to the database to conduct additional testing.

Open a terminal or command prompt now, and navigate to rpcontacts project/, the root directory. When there, start an interactive Python session and enter the following code:

from rpcontacts.database import createConnection

# Create a connection
createConnection("contacts.sqlite")


# Confirm that contacts table exists
from PyQt5.QtSql import QSqlDatabase
db = QSqlDatabase.database()
db.tables()
# Prepare a query to insert sample data
from PyQt5.QtSql import QSqlQuery

insertDataQuery = QSqlQuery()
insertDataQuery.prepare(
    """
    INSERT INTO contacts (
        name,
        job,
        email
    )
    VALUES (?, ?, ?)
    """
)
# Sample data
data = [
    ("sai", "Technical Lead", "sai@example.com"),
    ("kiran", "Senior Web Developer", "kiran@example.com"),
    ("nitin", "Project Manager", "nitin@example.com"),
    ("sara", "Data Analyst", "sara@example.com"),
    ("nikil", "Senior Python Developer", "nikil@example.com"),
]

# Insert sample data
for name, job, email in data:
    insertDataQuery.addBindValue(name)
    insertDataQuery.addBindValue(job)
    insertDataQuery.addBindValue(email)
    insertDataQuery.exec()
query = QSqlQuery()
query.exec("SELECT name, job, email FROM contacts")


while query.next():
    print(query.value(0), query.value(1), query.value(2))

This code creates a connection to an SQLite database named "contacts. sqlite" using the "createConnection" function from the "rpcontacts.database" module. It then confirms that the "contacts" table exists in the database by calling the "tables()" method on a QSqlDatabase object.

To insert data into the "contacts" table, it creates a QSqlQuery object and prepares a SQL statement. The statement includes placeholders for the values of the "name," "job," and "email" columns in the table.

The code then defines a list of sample data, where each element is a tuple containing the values for a single row in the "contacts" table. It then iterates over this list, binds the values to the placeholders in the prepared query, and executes the query to insert the data into the table.

Finally, the code creates another QSqlQuery object, executes a SELECT statement to retrieve data from the "contacts" table, and prints the values of the "name," "job," and "email" columns for each row in the table.

Step 4: Viewing and Modifying Current Contacts

In the application's main Window, you can display your contact information using QTableView.

Developing a Model to Manage Contact Data

For interacting with SQL databases, PyQt offers a wide range of classes. You'll use QSqlTableModel for your contact book application, which offers an editable data model for a single database table. Given that your database contains contacts in a single table, it is ideal for the task.

Go back to your code editor and add a new module called model.py to the rpcontacts/ directory. Save the file after adding the following code:

# -*- coding: utf-8 -*-
# rpcontacts/model.py

"""This module provides a model to manage the contacts table."""

from PyQt5.QtCore import Qt
from PyQt5.QtSql import QSqlTableModel

class ContactsModel:
    def __init__(self):
        self.model = self._createModel()

    @staticmethod
    def _createModel():
        """Create and set up the model."""
        tableModel = QSqlTableModel()
        tableModel.setTable("contacts")
        tableModel.setEditStrategy(QSqlTableModel.OnFieldChange)
        tableModel.select()
        headers = ("ID", "Name", "Job", "Email")
        for columnIndex, header in enumerate(headers):
            tableModel.setHeaderData(columnIndex, Qt.Horizontal, header)
        return tableModel

Your data model is now ready for use. You must perform a few necessary imports in this code before creating the ContactsModel. The class initializer specifies a model instance attribute that will house the data model. You add the following static method, which is used to configure the model object.

It would help if you now linked the table view widget to the model to show the users the contact information.

Linking the View and the Model

You must link the table view and the data model to display contact information in the main Window of your contact book. To make this connection, you must call setModel() on the table view object and pass the model as an argument:

# -*- coding: utf-8 -*-
# rpcontacts/views.py

# Snip...
from .model import ContactsModel

class Window(QMainWindow):
    """Main Window."""
    def __init__(self, parent=None):
        # Snip...
        self.contactsModel = ContactsModel()
        self.setupUI()

    def setupUI(self):
        """Setup the main window's GUI."""
        # Create the table view widget
        self.table = QTableView()
        self.table.setModel(self.contactsModel.model)
        self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
        # Snip...

You import ContactsModel from model.py at the beginning of this code. This class provides the model for managing the information in your contact database.

You make an instance of ContactsModel in the Window initializer. Then, to link the model with the table view, you call.setModel() on the table object inside .setupUI(). The Window you saw at the start of step 4 will appear if you launch the application after this update.

You can double-click on the name, job, and email to change the values.

Step 5: Renewing Contacts

You can now use the functionality offered by your contact book application to load, display, and update the data about your contacts. You can edit and update the contact details, but you cannot add or remove contacts from the list.

The Add Contact Dialog's creation

Small windows called dialogues allow you to have conversations with your users. In this section, you'll write the code for the Add Contact dialogue in the contact book so that your users can add new contacts to their existing list.

It would help if you subclassed QDialog to program the Add Contact dialogue. This class offers a template for creating dialogues for your GUI programs.

# -*- coding: utf-8 -*-

"""This module provides views to manage the contacts table."""

from PyQt5.QtCore import Qt
from PyQt5.QtWidgets import (
    QAbstractItemView,
    QDialog,
    QDialogButtonBox,
    QFormLayout,
    QHBoxLayout,
    QLineEdit,
    QMainWindow,
    QMessageBox,
    QPushButton,
    QTableView,
    QVBoxLayout,
    QWidget,
)

from .model import ContactsModel


class Window(QMainWindow):
    """Main Window."""

    def __init__(self, parent=None):
        """Initializer."""
        super().__init__(parent)
        self.setWindowTitle("RP Contacts")
        self.resize(550, 250)
        self.centralWidget = QWidget()
        self.setCentralWidget(self.centralWidget)
        self.layout = QHBoxLayout()
        self.centralWidget.setLayout(self.layout)

        self.contactsModel = ContactsModel()
        self.setupUI()

    def setupUI(self):
        """Setup the main window's GUI."""
        # Create the table view widget
        self.table = QTableView()
        self.table.setModel(self.contactsModel.model)
        self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
        self.table.resizeColumnsToContents()
        # Create buttons
        self.addButton = QPushButton("Add...")
        self.addButton.clicked.connect(self.openAddDialog)
        self.deleteButton = QPushButton("Delete")
        self.clearAllButton = QPushButton("Clear All")
        # Lay out the GUI
        layout = QVBoxLayout()
        layout.addWidget(self.addButton)
        layout.addWidget(self.deleteButton)
        layout.addStretch()
        layout.addWidget(self.clearAllButton)
        self.layout.addWidget(self.table)
        self.layout.addLayout(layout)

    def openAddDialog(self):
        """Open the Add Contact dialog."""
        dialog = AddDialog(self)
        if dialog.exec() == QDialog.Accepted:
            self.contactsModel.addContact(dialog.data)
            self.table.resizeColumnsToContents()


class AddDialog(QDialog):
    """Add Contact dialog."""

    def __init__(self, parent=None):
        """Initializer."""
        super().__init__(parent=parent)
        self.setWindowTitle("Add Contact")
        self.layout = QVBoxLayout()
        self.setLayout(self.layout)
        self.data = None

        self.setupUI()

    def setupUI(self):
        """Setup the Add Contact dialog's GUI."""
        # Create line edits for data fields
        self.nameField = QLineEdit()
        self.nameField.setObjectName("Name")
        self.jobField = QLineEdit()
        self.jobField.setObjectName("Job")
        self.emailField = QLineEdit()
        self.emailField.setObjectName("Email")
        # Lay out the data fields
        layout = QFormLayout()
        layout.addRow("Name:", self.nameField)
        layout.addRow("Job:", self.jobField)
        layout.addRow("Email:", self.emailField)
        self.layout.addLayout(layout)
        # Add standard buttons to the dialog and connect them
        self.buttonsBox = QDialogButtonBox(self)
        self.buttonsBox.setOrientation(Qt.Horizontal)
        self.buttonsBox.setStandardButtons(
            QDialogButtonBox.Ok | QDialogButtonBox.Cancel
        )
        self.buttonsBox.accepted.connect(self.accept)
        self.buttonsBox.rejected.connect(self.reject)
        self.layout.addWidget(self.buttonsBox)

    def accept(self):
        """Accept the data provided through the dialog."""
        self.data = []
        for field in (self.nameField, self.jobField, self.emailField):
            if not field.text():
                QMessageBox.critical(
                    self,
                    "Error!",
                    f"You must provide a contact's {field.objectName()}",
                )
                self.data = None  # Reset .data
                return

            self.data.append(field.text())

        If not self.data:
            return

        super().accept()

This script provides views to manage a contacts table using the PyQt5 library. The main window class, Window, creates a QTableView widget to display the contacts data and includes buttons to add new contacts, delete contacts, and clear the entire table. When the "Add" button is clicked, the AddDialog class creates a dialog window where the user can enter the name, job, and email of a new contact. The ContactsModel uses the new contact to add it to the contacts table. contact() method addition Before the new contact is added, the AddDialog class additionally has validation to ensure the user submits a value for each field. Data Processing in the Model of the Add Dialog you will include a method named ContactsModel in your data model..

Data Processing in the Model for the Add Dialog

To your data model, ContactsModel, you will add a method called. Add contact () in this section. Go to the definition of ContactsModel in model.py in your code editor and add the following code:

# -*- coding: utf-8 -*-
# rpcontacts/model.py

# Snip...
class ContactsModel:
    # Snip...

    def addContact(self, data):
        """Add a contact to the database."""
        rows = self.model.rowCount()
        self.model.insertRows(rows, 1)
        for column, field in enumerate(data):
            self.model.setData(self.model.index(rows, column + 1), field)
        self.model.submitAll()
        self.model.select()

This script is the "model" module of the RP Contacts application, which provides the data model for the contacts table. The ContactsModel class manages the underlying SQLite database of contacts and includes methods for adding, deleting, and retrieving contacts. The addContact method is used to add a new contact to the database, it takes a parameter "data," which is a list containing the name, job, and email of the contact to be added.

The method begins by finding the number of rows in the model, then inserting a new row at that position. For each element in the data list, the method sets the corresponding cell in the new row to the value of that element and then submits the changes to the database. Finally, it updates the model after selecting the data from the database.

Step 6: Eliminating Current Contacts

The final feature of the contact book is to delete the contact in the book.

To delete specific contact in the contact book, we need to change the view and model files:

# -*- coding: utf-8 -*-
# rpcontacts/model.py

# Snip...
class ContactsModel:
    # Snip...

    def deleteContact(self, row):
        """Remove a contact from the database."""
        self.model.removeRow(row)
        self.model.submitAll()
        self.model.select()

Three lines of code make up this method. The selected row is eliminated in the first line. The change is submitted to the database on the second line. The third line then loads the data once more into the model.

Return to the views.py module after that and add the following code to the Delete button in Window:

# -*- coding: utf-8 -*-
# rpcontacts/views.py

# Snip...
class Window(QMainWindow):
    # Snip...

    def setupUI(self):
        """Setup the main window's GUI."""
        # Snip...
        self.deleteButton = QPushButton("Delete")
        self.deleteButton.clicked.connect(self.deleteContact)
        # Snip...

    def deleteContact(self):
        """Delete the selected contact from the database."""
        row = self.table.currentIndex().row()
        if row < 0:
            return

        messageBox = QMessageBox.warning(
            self,
            "Warning!",
            "Do you want to remove the selected contact?",
            QMessageBox. OK | QMessageBox.Cancel,
        )

        if messageBox == QMessageBox.Ok:
            self.contactsModel.deleteContact(row)

This script is the "views" module of the RP Contacts application, which provides the user interface for the contacts table. The Window class is a subclass of QMainWindow and is responsible for creating and managing the application's main Window.

In the setupUI method, a button named "Delete" is created, and the deleteContact method is connected to the button's clicked signal.

The deleteContact method is responsible for deleting a contact from the database. When this function is called, the index of the currently selected row in the table view is initially determined. If no row is selected, the method exits. It then displays a warning message box asking the user to confirm the deletion of the contact, and if the user confirms, the method calls the deleteContact method of the ContactsModel class and passes it the index of the selected row, which corresponds to the contact to be deleted from the database.

Database clearing

In this session, we will add functionality to the clear-all button

To make this, we need to make changes to the files:

# -*- coding: utf-8 -*-
# rpcontacts/model.py

# Snip...
class ContactsModel:
    # Snip...

    def deleteContact(self, row):
        """Remove a contact from the database."""
        self.model.removeRow(row)
        self.model.submitAll()
        self.model.select()

Three lines of code make up this method. The first line eliminates the chosen row.

The change is submitted to the database on the second line. The third line then loads the data once more into the model. Return to the views.py module after that and add the following code to the Delete button in Window:

# -*- coding: utf-8 -*-
# rpcontacts/views.py

# Snip...
class Window(QMainWindow):
    # Snip...

    def setupUI(self):
        """Setup the main window's GUI."""
        # Snip...
        self.clearAllButton = QPushButton("Clear All")
        self.clearAllButton.clicked.connect(self.clearContacts)
        # Snip...

    def clearContacts(self):
        """Remove all contacts from the database."""
        messageBox = QMessageBox.warning(
            self,
            "Warning!",
            "Do you want to remove all your contacts?",
            QMessageBox. OK | QMessageBox.Cancel,
        )

        if messageBox == QMessageBox.OK:
            self.contactsModel.clearContacts()

The method will prompt the user if they want to clear all the contacts. If they click yes, then all the contacts will be erased.

All done! Your contact book application is finished with this final line of code. Your users can display, add, update, and remove contacts from the database using the features provided by the application.

Next TopicShould We Update the Latest Version of Python Bugfix

← prev next →