Qt is a set of C++ libraries and development tools that includes platform independent abstractions for graphical user interfaces, networking, threads, regular expressions, SQL databases, SVG, OpenGL, XML, user and application settings, positioning and location services, short range communications (NFC and Bluetooth) and access to the cloud. PyQt5 implements over 1000 of these classes as a set of Python modules.
PyQt5 supports the Windows, Linux, UNIX, Android, OS X and iOS platforms.
PyQt does not include a copy of Qt. You must obtain a correctly licensed copy of Qt yourself. However, binary wheels of the GPL version of PyQt5 are provided and these include a copy of the appropriate parts of the LGPL version of Qt.
The homepage for PyQt5 is https://www.riverbankcomputing.com/software/pyqt/. Here you will always find the latest stable version, current development previews, and the latest version of this documentation.
PyQt5 is built using the SIP bindings generator. SIP must be installed in order to build and use PyQt5.
Earlier versions of Qt are supported by PyQt4.
PyQt5 is dual licensed on all platforms under the Riverbank Commercial License and the GPL v3. Your PyQt5 license must be compatible with your Qt license. If you use the GPL version then your own code must also use a compatible license.
PyQt5, unlike Qt, is not available under the LGPL.
You can purchase a commercial PyQt5 license here.
PyQt5 comprises a number of different components. First of all there are a
number of Python extension modules. These are all installed in the
PyQt5 Python package.
QAxContainercontains classes that allow access to ActiveX controls and COM objects. It does not support the ability to write ActiveX servers in Python. It is only available under Windows.
QtBluetoothcontains classes that enables an application to scan for devices and connect and interact with them.
QtCorecontains the core classes, including the event loop and Qt’s signal and slot mechanism. It also includes platform independent abstractions for animations, state machines, threads, mapped files, shared memory, regular expressions, and user and application settings.
QtDBuscontains classes that support Inter-Process Communication using the D-Bus protocol. It is not available under Windows.
QtDesignercontains classes that allow Qt Designer to be extended using PyQt5. See Writing Qt Designer Plugins for a full description of how to do this.
QtGuicontains classes for windowing system integration, event handling, 2D graphics, basic imaging, fonts and text. It also containes a complete set of OpenGL and OpenGL ES bindings (see Support for OpenGL). Application developers would normally use this with higher level APIs such as those contained in the
QtHelpcontains classes for creating and viewing searchable documentation.
QtLocationcontains classes for accessing geocoding and navigation information, and also place search. It allows the creation of mapping solutions using data from some of the popular location services.
QtMacExtrascontains additional classes that are specific to OS X and iOS.
QtMultimediacontains classes to handle multimedia content and APIs to access camera and radio functionality.
QtNetworkcontains classes for writing UDP and TCP clients and servers. It includes classes that implement HTTP clients and support DNS lookups.
QtNfccontains classes to provide connectivity between NFC enabled devices. The NFC API provides APIs for interacting with NFC Forum Tags and NFC Forum Devices, including target detection and loss, registering NDEF message handlers, reading and writing NDEF messages on NFC Forum Tags and sending tag specific commands.
QtOpenGLcontains classes that allow the use of OpenGL in rendering 3D graphics in
QtPositioningcontains classes to determine a position by using a variety of possible sources, including satellite, or Wi-Fi, or a text file, and so on. That information can then be used to, for example, determine a position on a map. In addition satellite information can be retrieved and area based monitoring can be performed.
QtPrintSupportcontains classes to allow applications to print to locally attached and remote printers. It also enables the generation of PostScript and PDF files.
QtQuickcontains classes that provide the basic elements necessary for creating user interfaces with QML.
QtQuickWidgetscontains classes that support the display of a QML scene in a traditional widget.
QtSensorscontains classes that provide access to a system’s hardware sensors including accelerometers, altimeters, ambient light and temperature sensors, gyroscopes and magnetometers. Note that sensor gestures are not currently supported.
QtSerialPortcontains classes that provide access to a system’s serial ports.
QtSqlcontains classes that integrate with SQL databases. It includes editable data models for database tables that can be used with GUI classes. It also includes an implementation of SQLite.
QtSvgcontains classes for displaying the contents of SVG files.
QtTestcontains functions that enable unit testing of PyQt5 applications. (PyQt5 does not implement the complete Qt unit test framework. Instead it assumes that the standard Python unit test framework will be used and implements those functions that simulate a user interacting with a GUI.) In addition the
QSignalSpyclass provides easy introspection of Qt’s signals and slots.
QtWebEnginecontains classes that exposes further functionality of Web Engine objects created in QML to Python.
QtWebEngineWidgetscontains classes for a Chromium based implementation of a web browser. This supercedes the
QtWebEngineWidgetsis not normally available under Windows using versions of Python earlier than v3.5 because of compiler incompatibilities.
QtWebKitcontains classes for a WebKit2 based implementation of a web browser.
QtWebKitWidgetscontains classes for a WebKit1 based implementation of a web browser for use in
QtWebSocketscontains classes that implement the WebSocket protocol described in RFC 6455.
QtWidgetscontains classes that provide a set of UI elements to create classic desktop-style user interfaces.
QtWinExtrascontains additional classes that are specific to Windows, for example providing access to Jump Lists, a progress indicator on a taskbar button, and a thumbnail toolbar.
QtX11Extrascontains additional classes that are specific to X11.
QtXmlmodule. This module contains classes that implement SAX and DOM interfaces to Qt’s XML parser.
QtXmlPatternscontains classes that provide support for XPath, XQuery, XSLT and XML Schema validation.
Enginioimplements the client-side library for accessing the Qt Cloud Services Managed Application Runtime.
Qtconsolidates the classes contained in all of the modules described above into a single module. This has the advantage that you don’t have to worry about which underlying module contains a particular class. It has the disadvantage that it loads the whole of the Qt framework, thereby increasing the memory footprint of an application. Whether you use this consolidated module, or the individual component modules is down to personal taste.
uiccontains classes for handling the
.uifiles created by Qt Designer that describe the whole or part of a graphical user interface. It includes classes that load a
.uifile and render it directly, and classes that generate Python code from a
.uifile for later execution.
PyQt5 also contains a number of utility programs.
- pyuic5 corresponds to the Qt uic utility. It converts
QtWidgetsbased GUIs created using Qt Designer to Python code.
- pyrcc5 corresponds to the Qt rcc utility. It embeds arbitrary resources (eg. icons, images, translation files) described by a resource collection file in a Python module.
- pylupdate5 corresponds to the Qt lupdate utility. It
extracts all of the translatable strings from Python code and creates or
.tstranslation files. These are then used by Qt Linguist to manage the translation of those strings.
The DBus support
module is installed as
dbus.mainloop.pyqt5. This module provides
support for the Qt event loop in the same way that the
dbus.mainloop.glib included with the standard
package provides support for the GLib event loop. The API is described in
DBus Support. It is only available if the
dbus-python v0.80 (or later)
bindings package is installed. The
QtDBus module provides a more
Qt-like interface to DBus.
When PyQt5 is configured a file called
PyQt5.api is generated. This
can be used by the
editor component to enable the use of auto-completion and call tips when
editing PyQt5 code. The API file is installed automatically if
is already installed.
PyQt5 includes a large number of examples. These are ports to Python of many
of the C++ examples provided with Qt. They can be found in the
Finally, PyQt5 contains the
.sip files used by SIP to generate PyQt5
itself. These can be used by developers of bindings of other Qt based class
An Explanation of Version Numbers¶
Historically the version number of PyQt bears no relation to the version of Qt supported. It’s no longer even true that PyQt4 requires Qt v4 as it will also build against Qt v5. People sometimes mistakenly believe that, for example, PyQt4 v4.8 is needed when building against Qt v4.8.
When refering to a version number we assume it consists of three numbers
separated by a dot. These are the major number, the minor number and the
maintenance number. The major number will always be
5. The maintenance
number may be omitted if it is
Starting with PyQt5 the version number of PyQt5 is tied, to a certain extent, to the version of Qt v5. This is based on the following assumptions.
- All parts of the Qt API will be supported throughout the life of Qt v5 even though some may be marked as deprecated or obsolete at some point.
- When new parts of the Qt API are introduced the minor number of the version
will be increased and the maintenance number will be reset to
Therefore, for PyQt5 v5.n.* the following are true.
- It will build against any version of Qt v5, but will not support any new features introduced in Qt v5.n+1 or later.
- It will support all the features of supported modules of Qt v5.n or earlier.
- Support for new modules may be added to PyQt5 at any time. This would result in a change of maintenance number only.
The maintenance numbers of PyQt5 and Qt v5 are entirely unrelated to each other.
So, for example, PyQt5 v5.1 will build against Qt v5.2 but will not support any new features introduced in Qt v5.2. PyQt5 v5.1 will support all the features of supported modules of Qt v5.0 and those new features introduced in Qt v5.1.
In summary, just as with PyQt4, you should always try and use the latest version of PyQt5 no matter what version of Qt v5 you are using.