PyQt is a Python library for creating GUI applications using the Qt toolkit. Created by Riverbank Computing, PyQt is free software (GPL licensed) and has been in development since 1999. PyQt5 was released in 2016 and last updated in October 2021.

This complete PyQt5 tutorial takes you from first concepts to building fully-functional GUI applications in Python. It requires some basic Python knowledge, but no previous familiarity with GUI concepts. Everything will be introduced step by by step, using hands-on examples.

PyQt5 is the Qt5-based edition of the Python GUI library PyQt from Riverbank Computing.

There are two major versions currently in use: PyQt5 based on Qt5 and PyQt6 based on Qt6. Both versions are almost completely compatible aside from imports. PyQt6 also makes some changes to how namespaces and flags work, but these are easily manageable.

Looking for something else? I also have a PyQt6 tutorial, PySide2 tutorial and PySide6 tutorial.

This track consists of 36 tutorials. Keep checking back as I'm adding new tutorials regularly — last updated 4 February 2024.

Getting started with PyQt5

Take your first steps building apps with Python & Qt5

Like writing any code, building PyQt5 applications is all about approaching it in the right way. In the first part of the course we cover the fundamentals necessary to get you building Python GUIs as quickly as possible. By the end of the first part you'll have a running QApplication which we can then customize.

1 video 6 tutorials 1:11:19

Creating your first app with PyQt5 video (07:32)
A simple Hello World! application with Python and Qt5

PyQt5 Signals, Slots & Events (13:25)
Triggering actions in response to user behaviors and GUI events

PyQt5 Widgets (12:30)
Using QPushButton, QCheckBox, QComboBox, QLabel and QSlider widgets

PyQt5 Layouts (08:24)
Use layouts to effortlessly position widgets within the window

PyQt5 Toolbars & Menus — QAction (12:00)
Defining toolbars, menus and keyboard shortcuts with QAction

PyQt5 Dialogs and Alerts (08:37)
Notify your users and ask for their input

Creating additional windows (08:51)
Opening new windows for your application

Creating applications with Qt Designer

Using the drag-drop designer to develop your apps

As your applications get larger or interfaces become more complicated, it can get a bit cumbersome to define all elements programmatically. The good news is that Qt comes with a graphical editor Qt Designer (or Qt Creator) which contains a drag-and-drop UI editor — Qt Designer. In this PyQt5 tutorial we'll cover the basics of creating Python GUIs with Qt Designer.

5 tutorials 51:25

First steps with Qt Designer (06:58)
Use Qt Designer's drag and drop interface to design your PyQt5 GUI

Laying Out Your PyQt5 GUIs With Qt Designer (13:04)
Use Qt Designer to effortlessly build your application UI

Creating Dialogs With Qt Designer (17:24)
Using the drag and drop editor to build PyQt5 dialogs

Embedding custom widgets from Qt Designer (05:14)
Learn how to use custom widgets in your PyQt5 applications when designing with Qt Designer

The QResource System (08:45)
Using the QResource system to package additional data with your applications

Mozzarella Ashbadger

Build your own tabbed web browser with PyQt5

Now we've learnt the basics, we'll put it into practice building a real-life app. In this course we'll create a functional web browser using Qt5 widgets. Starting with the basics and then gradually extending it to add features like opening and saving pages, help, printing and tabbed browsing. Follow the tutorial step by step to create your own app, but feel free to experiment as you go.

5 tutorials 11:28

Mozzerella Ashbadger (01:14)
The first steps building the browser with PyQt5

Adding navigational controls to a PyQt5 Web Browser (03:03)
Hook up QAction signals to web browser slots

Open and save HTML in a PyQt5 browser (01:15)
Adding file dialogs to load and save HTML

Adding application Help and About dialogs (01:51)
Put some finishing touches to your application

Tabbed web browsing (04:05)
Use signal redirection to add a multi-tab interface

Extended UI features

Extending your apps with complex GUI behaviour

In this PyQt5 tutorial we'll cover some advanced features of Qt that you can use to improve your Python GUIs.

2 tutorials 09:53

Transmitting extra data with Qt Signals (06:06)
Modifying widget signals to pass contextual information to slots

System tray & Mac menu bar applications (03:47)
Add quick access functions to your apps

Threads & Processes

Run concurrent tasks without impacting your UI

As your applications become more complex you may finding yourself wanting to perform long-running tasks, such as interacting with remote APIs or performing complex calculations. By default any code you write exists in the same thread and process, meaning your long-running code can actually block Qt execution and cause your Python GUI app to "hang". In this PyQt5 tutorial we'll cover how to avoid this happening and keep your applications running smoothly, no matter the workload.

2 tutorials 23:05

Multithreading PyQt5 applications with QThreadPool (12:41)
Run background tasks concurrently without impacting your UI

Using QProcess to run external programs (10:24)
Run background programs without impacting your UI

ModelViews and Databases

Connecting your application to data sources

All but the simplest of apps will usually need to interact with some kind of external data store — whether that's a database, a remote API or simple configuration data. The Qt ModelView architecture simplifies the linking and updating your UI with data in custom formats or from external sources. In this PyQt5 tutorial we'll discover how you can use Qt ModelViews to build high performance Python GUIs.

2 tutorials 30:03

The ModelView Architecture (12:43)
Qt's MVC-like interface for displaying data in views

Displaying tabular data in Qt5 ModelViews (17:20)
Create customized table views with conditional formatting, numpy and pandas data sources.

Graphics and Plotting

Vector graphics and plotting using PyQtGraph

Python is one of the most popular languages in the data science and machine learning fields. Effective visualization of data is a key part of building usable interfaces for data science. Matplotlib is the most popular plotting library in Python, and comes with support for PyQt built in. In addition, there are PyQt-specific plotting options available such as PyQtGraph which provide a better interactive experience. In this tutorial we'll look at these alternatives and build some simple plot interfaces.

2 tutorials 26:51

Plotting With PyQtGraph (14:53)
Create Custom Plots in PyQt with PyQtGraph

Plotting with Matplotlib (11:58)
Create PyQt5 plots with the popular Python plotting library

QGraphics Framework

Vector graphic interfaces in PyQt5

The Qt Graphics View framework is a scene-based vector graphics API. Using this you can create dynamic interactive interfaces for anything from vector graphics tools, data analysis workflow designers to simple 2D games. The Graphics View Framework allows you to develop fast & efficient scenes, containing millions of items, each with their own distinct graphic features and behaviors.

1 tutorial 12:54

Introduction to the QGraphics framework (12:54)
Creating vector interfaces using the QGraphics View framework

Custom Widgets

Designing your own custom widgets in PyQt

Widgets in Qt are built on bitmap graphics — drawing pixels on a rectangular canvas to construct the "widget". To be able to create your own custom widgets you first need to understand how the QPainter system works and what you can do with it. In this PyQt5 tutorial we'll go from basic bitmap graphics to our own entirely custom widget.

3 tutorials 50:06

QPainter and Bitmap Graphics (15:56)
Introduction to the core features of QPainter

Creating custom GUI widgets in PyQt5 (19:13)
Build a completely functional custom widget from scratch using QPainter

Animating custom widgets with QPropertyAnimation (14:57)
Add dynamic visual effects to your custom widgets

Packaging and distribution

Sharing your awesome applications with other people

There comes a point in any app's development where it needs to leave home — half the fun in writing software is being able to share it with other people. Packaging Python GUI apps can be a little tricky, but in this PyQt5 tutorial we'll cover how to package up your apps to share, whether commercially or just for fun.

5 tutorials 1:42:20

Packaging PyQt5 applications for Windows with PyInstaller & InstallForge (23:51)
Turn your PyQt5 application into a distributable installer for Windows

Packaging PyQt5 applications into a macOS app with PyInstaller (23:48)
Turn your PyQt5 application into a distributable app

Packaging PyQt5 applications for Linux with PyInstaller & fpm (24:13)
Turn your PyQt5 application into installable Linux packages

Using QResource to package data files with PyInstaller (16:50)
Serialize data files for easy packaging in Python

Packaging PyQt5 apps with fbs (13:38)
Distribute cross-platform GUI applications with the fman Build System

QtQuick & QML

Building modern PyQt5 GUIs with QtQuick & QML

Qt Quick is Qt's declarative UI design system, using the Qt Modeling Language (QML) to define custom user interfaces. Originally developed for use in mobile applications, it offers dynamic graphical elements and fluid transitions and effects allowing you to replicate the kinds of UIs you find on mobile devices. Qt Quick is supported on all desktop platforms too and is a great choice for building desktop widgets or other interactive tools. Qt Quick is also a great choice for developing UIs for hardware and microcontrollers with PyQt5.

2 tutorials 28:23