PyQt - Quick Guide

PyQt - Introduction

PyQt is a GUI widgets toolkit. It is a Python interface for Qt, one of the most powerful, and popular cross-
platform GUI library. PyQt was developed by RiverBank Computing Ltd. The latest version of PyQt can
be downloaded from its official website − riverbankcomputing.com
PyQt API is a set of modules containing a large number of classes and functions. While QtCore module
contains non-GUI functionality for working with file and directory etc., QtGui module contains all the
graphical controls. In addition, there are modules for working with XML (QtXml), SVG (QtSvg), and SQL
(QtSql), etc.

Supporting Environments
PyQt is compatible with all the popular operating systems including Windows, Linux, and Mac OS. It is
dual licensed, available under GPL as well as commercial license.

Windows

You can download and install an appropriate installer from the above download link corresponding to
Python version (2.7 or 3.4) and hardware architecture (32 bit or 64 bit). Note that there are two versions
of PyQt that are available namely, PyQt 4.8 and PyQt 5.5.

While PyQt4 is available for Python 2 as well as Python 3, PyQt5 can be used along with Python 3.* only.

PyQt4 Windows Binaries

PyQt4-4.11.4-gpl-Py3.4-Qt4.8.7-x64.exe Windows 64 bit installer

PyQt4-4.11.4-gpl-Py3.4-Qt4.8.7-x32.exe Windows 32 bit installer

PyQt4-4.11.4-gpl-Py3.4-Qt5.5.0-x64.exe Windows 64 bit installer

PyQt4-4.11.4-gpl-Py3.4-Qt5.5.0-x32.exe Windows 32 bit installer

PyQt4-4.11.4-gpl-Py2.7-Qt4.8.7-x64.exe Windows 64 bit installer

PyQt4-4.11.4-gpl-Py2.7-Qt4.8.7-x32.exe Windows 32 bit installer

PyQt5 Windows Binaries

PyQt5-5.5-gpl-Py3.4-Qt5.5.0-x64.exe Windows 64 bit installer

PyQt5-5.5-gpl-Py3.4-Qt5.5.0-x32.exe Windows 32 bit installer

Linux
For Ubuntu or any other debian Linux distribution, use the following command to install PyQt −

sudo apt-get install python-qt4

or
sudo apt-get install pyqt5-dev-tools

You can also build from the source code available on the ‘download’ page.

PyQt-x11-gpl-4.11.4.tar.gz Linux, UNIX source for PyQt4

PyQt-gpl-5.5.tar.gz Linux, UNIX, MacOS/X source for PyQt5

Mac OS

PyQtX project (http://sourceforge.net/projects/pyqtx/) hosts binaries of PyQt for Mac. Use Homebrew
installer as per the following command −

brew install pyqt

PyQt - Hello World

Creating a simple GUI application using PyQt involves the following steps −

Import QtGui module.

Create an application object.

A QWidget object creates top level window. Add QLabel object in it.

Set the caption of label as “hello world”.

Define the size and position of window by setGeometry() method.

Enter the mainloop of application by app.exec_() method.

import sys
from PyQt4 import QtGui

def window():
app = QtGui.QApplication(sys.argv)
w = QtGui.QWidget()
b = QtGui.QLabel(w)
b.setText("Hello World!")
w.setGeometry(100,100,200,50)
b.move(50,20)
w.setWindowTitle(“PyQt”)
w.show()
sys.exit(app.exec_())

if __name__ == '__main__':
window()

The above code produces the following output −

 PyQt - Major Classes

PyQt API is a large collection of classes and methods. These classes are defined in more than 20
modules. Following are some of the frequently used modules −
Sr.No. Modules & Description

1
QtCore

Core non-GUI classes used by other modules

2
QtGui

Graphical user interface components

3
QtMultimedia

Classes for low-level multimedia programming

4
QtNetwork

Classes for network programming

5
QtOpenGL

OpenGL support classes

6
QtScript

Classes for evaluating Qt Scripts

7
QtSql

Classes for database integration using SQL

8
QtSvg

Classes for displaying the contents of SVG files

9
QtWebKit

Classes for rendering and editing HTML

10
QtXml

Classes for handling XML

11
QtAssistant

Support for online help

12
QtDesigner

Classes for extending Qt Designer

PyQt API contains more than 400 classes. The QObject class is at the top of class hierarchy. It is the
base class of all Qt objects. Additionally, QPaintDevice class is the base class for all objects that can be
painted.

QApplication class manages the main settings and control flow of a GUI application. It contains main
event loop inside which events generated by window elements and other sources are processed and
dispatched. It also handles system-wide and application-wide settings.

QWidget class, derived from QObject and QPaintDevice classes is the base class for all user interface
objects. QDialog and QFrame classes are also derived from QWidget class. They have their own sub-
class system.

Following diagrams depict some important classes in their hierarchy.

Here is a select list of frequently used widgets −

Given below are the commonly used Widgets.

Sr.No. Widgets & Description

1
QLabel

Used to display text or image

2
QLineEdit
Allows the user to enter one line of text

3
QTextEdit

Allows the user to enter multi-line text

4
QPushButton
A command button to invoke action

5
QRadioButton

Enables to choose one from multiple options

6
QCheckBox

Enables choice of more than one options

7
QSpinBox
Enables to increase/decrease an integer value

8
QScrollBar

Enables to access contents of a widget beyond display aperture

9
QSlider
Enables to change the bound value linearly.

10
QComboBox

Provides a dropdown list of items to select from

11
QMenuBar
Horizontal bar holding QMenu objects

12
QStatusBar
Usually at bottom of QMainWindow, provides status information.
13 QToolBar

Usually at top of QMainWindow or floating. Contains action buttons

14
QListView
Provides a selectable list of items in ListMode or IconMode

15
QPixmap

Off-screen image representation for display on QLabel or QPushButton object

16
QDialog
Modal or modeless window which can return information to parent window

A typical GUI based application’s top level window is created by QMainWindow widget object. Some
widgets as listed above take their appointed place in this main window, while others are placed in the
central widget area using various layout managers.
The following diagram shows the QMainWindow framework −

PyQt - Using Qt Designer

The PyQt installer comes with a GUI builder tool called Qt Designer. Using its simple drag and drop
interface, a GUI interface can be quickly built without having to write the code. It is however, not an IDE
such as Visual Studio. Hence, Qt Designer does not have the facility to debug and build the application.

Creation of a GUI interface using Qt Designer starts with choosing a top level window for the application.
You can then drag and drop required widgets from the widget box on the left pane. You can also assign
value to properties of widget laid on the form.

The designed form is saved as demo.ui. This ui file contains XML representation of widgets and their
properties in the design. This design is translated into Python equivalent by using pyuic4 command line
utility. This utility is a wrapper for uic module. The usage of pyuic4 is as follows −

pyuic4 –x demo.ui –o demo.py

In the above command, -x switch adds a small amount of additional code to the generated XML so that it
becomes a self-executable standalone application.

if __name__ == "__main__":
import sys
 app = QtGui.QApplication(sys.argv)
Dialog = QtGui.QDialog()
ui = Ui_Dialog()
ui.setupUi(Dialog)
Dialog.show()
sys.exit(app.exec_())

The resultant python script is executed to show the following dialog box −

The user can input data in input fields but clicking on Add button will not generate any action as it is not
associated with any function. Reacting to user-generated response is called as event handling.

PyQt - Signals & Slots

Unlike a console mode application, which is executed in a sequential manner, a GUI based application is
event driven. Functions or methods are executed in response to user’s actions like clicking on a button,
selecting an item from a collection or a mouse click etc., called events.
Widgets used to build the GUI interface act as the source of such events. Each PyQt widget, which is
derived from QObject class, is designed to emit ‘signal’ in response to one or more events. The signal
on its own does not perform any action. Instead, it is ‘connected’ to a ‘slot’. The slot can be any callable
Python function.

In PyQt, connection between a signal and a slot can be achieved in different ways. Following are most
commonly used techniques −

QtCore.QObject.connect(widget, QtCore.SIGNAL(‘signalname’), slot_function)

A more convenient way to call a slot_function, when a signal is emitted by a widget is as follows −

widget.signal.connect(slot_function)

Suppose if a function is to be called when a button is clicked. Here, the clicked signal is to be connected
to a callable function. It can be achieved in any of the following two techniques −

QtCore.QObject.connect(button, QtCore.SIGNAL(“clicked()”), slot_function)

or
 button.clicked.connect(slot_function)

Example

In the following example, two QPushButton objects (b1 and b2) are added in QDialog window. We want
to call functions b1_clicked() and b2_clicked() on clicking b1 and b2 respectively.
When b1 is clicked, the clicked() signal is connected to b1_clicked() function

b1.clicked.connect(b1_clicked())

When b2 is clicked, the clicked() signal is connected to b2_clicked() function

QObject.connect(b2, SIGNAL("clicked()"), b2_clicked)

Example

import sys
from PyQt4.QtCore import *
from PyQt4.QtGui import *

def window():
app = QApplication(sys.argv)
win = QDialog()
b1 = QPushButton(win)
b1.setText("Button1")
b1.move(50,20)
b1.clicked.connect(b1_clicked)

b2 = QPushButton(win)
b2.setText("Button2")
b2.move(50,50)
QObject.connect(b2,SIGNAL("clicked()"),b2_clicked)

win.setGeometry(100,100,200,100)
win.setWindowTitle("PyQt")
win.show()
sys.exit(app.exec_())

def b1_clicked():
print "Button 1 clicked"

def b2_clicked():
print "Button 2 clicked"

if __name__ == '__main__':
window()

The above code produces the following output −

Output

Button 1 clicked
Button 2 clicked

PyQt - Layout Management

A GUI widget can be placed inside the container window by specifying its absolute coordinates
measured in pixels. The coordinates are relative to the dimensions of the window defined by
setGeometry() method.

setGeometry() syntax

QWidget.setGeometry(xpos, ypos, width, height)

In the following code snippet, the top level window of 300 by 200 pixels dimensions is displayed at
position (10, 10) on the monitor.

import sys
from PyQt4 import QtGui

def window():
app = QtGui.QApplication(sys.argv)
w = QtGui.QWidget()

b = QtGui.QPushButton(w)
b.setText("Hello World!")
b.move(50,20)

w.setGeometry(10,10,300,200)
w.setWindowTitle(“PyQt”)
w.show()
sys.exit(app.exec_())

if __name__ == '__main__':
window()

A PushButton widget is added in the window and placed at a position 50 pixels towards right and 20
pixels below the top left position of the window.
This Absolute Positioning, however, is not suitable because of following reasons −
The position of the widget does not change even if the window is resized.
The appearance may not be uniform on different display devices with different resolutions.

Modification in the layout is difficult as it may need redesigning the entire form.

PyQt API provides layout classes for more elegant management of positioning of widgets inside the
container. The advantages of Layout managers over absolute positioning are −
Widgets inside the window are automatically resized.

Ensures uniform appearance on display devices with different resolutions.

Adding or removing widget dynamically is possible without having to redesign.

Here is the list of Classes which we will discuss one by one in this chapter.

Sr.No. Classes & Description

1 QBoxLayout

QBoxLayout class lines up the widgets vertically or horizontally. Its derived classes are
QVBoxLayout (for arranging widgets vertically) and QHBoxLayout (for arranging widgets
horizontally).

2 QGridLayout
A GridLayout class object presents with a grid of cells arranged in rows and columns. The
class contains addWidget() method. Any widget can be added by specifying the number of
rows and columns of the cell.

3 QFormLayout
QFormLayout is a convenient way to create two column form, where each row consists of
an input field associated with a label. As a convention, the left column contains the label
and the right column contains an input field.

PyQt - Basic Widgets

Here is the list of Widgets which we will discuss one by one in this chapter.
Sr.No Widgets & Description

1 QLabel

A QLabel object acts as a placeholder to display non-editable text or image, or a movie of

animated GIF. It can also be used as a mnemonic key for other widgets.

2 QLineEdit

QLineEdit object is the most commonly used input field. It provides a box in which one line of
text can be entered. In order to enter multi-line text, QTextEdit object is required.

3 QPushButton

In PyQt API, the QPushButton class object presents a button which when clicked can be
programmed to invoke a certain function.

4 QRadioButton

A QRadioButton class object presents a selectable button with a text label. The user can
select one of many options presented on the form. This class is derived from QAbstractButton
class.

5 QCheckBox

A rectangular box before the text label appears when a QCheckBox object is added to the
parent window. Just as QRadioButton, it is also a selectable button.

6 QComboBox

A QComboBox object presents a dropdown list of items to select from. It takes minimum
screen space on the form required to display only the currently selected item.

7 QSpinBox

A QSpinBox object presents the user with a textbox which displays an integer with up/down
button on its right.

8 QSlider Widget & Signal

QSlider class object presents the user with a groove over which a handle can be moved. It is
a classic widget to control a bounded value.

9 QMenuBar, QMenu & QAction

A horizontal QMenuBar just below the title bar of a QMainWindow object is reserved for
displaying QMenu objects.

10 QToolBar

A QToolBar widget is a movable panel consisting of text buttons, buttons with icons or other
widgets.

11 QInputDialog
 This is a preconfigured dialog with a text field and two buttons, OK and Cancel. The parent
window collects the input in the text box after the user clicks on Ok button or presses Enter.

12 QFontDialog

Another commonly used dialog, a font selector widget is the visual appearance of QDialog
class. Result of this dialog is a Qfont object, which can be consumed by the parent window.

13 QFileDialog

This widget is a file selector dialog. It enables the user to navigate through the file system and
select a file to open or save. The dialog is invoked either through static functions or by calling
exec_() function on the dialog object.

14 QTab

If a form has too many fields to be displayed simultaneously, they can be arranged in different
pages placed under each tab of a Tabbed Widget. The QTabWidget provides a tab bar and a
page area.

15 QStacked

Functioning of QStackedWidget is similar to QTabWidget. It also helps in the efficient use of

window’s client area.

16 QSplitter

This is another advanced layout manager which allows the size of child widgets to be
changed dynamically by dragging the boundaries between them. The Splitter control provides
a handle that can be dragged to resize the controls.

17 QDock

A dockable window is a subwindow that can remain in floating state or can be attached to the
main window at a specified position. Main window object of QMainWindow class has an area
reserved for dockable windows.

18 QStatusBar

QMainWindow object reserves a horizontal bar at the bottom as the status bar. It is used to
display either permanent or contextual status information.

19 QList

QListWidget class is an item-based interface to add or remove items from a list. Each item in
the list is a QListWidgetItem object. ListWidget can be set to be multiselectable.

20 QScrollBar

A scrollbar control enables the user to access parts of the document that is outside the
viewable area. It provides visual indicator to the current position.

21 QCalendar
 QCalendar widget is a useful date picker control. It provides a month-based view. The user
can select the date by the use of the mouse or the keyboard, the default being today’s date.

PyQt - QDialog Class

A QDialog widget presents a top level window mostly used to collect response from the user. It can be
configured to be Modal (where it blocks its parent window) or Modeless (the dialog window can be
bypassed).
PyQt API has a number of preconfigured Dialog widgets such as InputDialog, FileDialog, FontDialog,
etc.

Example

In the following example, WindowModality attribute of Dialog window decides whether it is modal or
modeless. Any one button on the dialog can be set to be default. The dialog is discarded by
QDialog.reject() method when the user presses the Escape key.
A PushButton on a top level QWidget window, when clicked, produces a Dialog window. A Dialog box
doesn’t have minimize and maximize controls on its title bar.
The user cannot relegate this dialog box in the background because its WindowModality is set to
ApplicationModal.

import sys
from PyQt4.QtGui import *
from PyQt4.QtCore import *

def window():
app = QApplication(sys.argv)
w = QWidget()
b = QPushButton(w)
b.setText("Hello World!")
b.move(50,50)
b.clicked.connect(showdialog)
w.setWindowTitle("PyQt Dialog demo")
w.show()
sys.exit(app.exec_())

def showdialog():
d = QDialog()
b1 = QPushButton("ok",d)
b1.move(50,50)
d.setWindowTitle("Dialog")
d.setWindowModality(Qt.ApplicationModal)
d.exec_()

if __name__ == '__main__':
window()

The above code produces the following output −

 PyQt - QMessageBox

QMessageBox is a commonly used modal dialog to display some informational message and optionally
ask the user to respond by clicking any one of the standard buttons on it. Each standard button has a
predefined caption, a role and returns a predefined hexadecimal number.
Important methods and enumerations associated with QMessageBox class are given in the following
table −
Sr.No. Methods & Description

1
setIcon()
Displays predefined icon corresponding to severity of the message

Question

Information

Warning

Critical

2
setText()
Sets the text of the main message to be displayed

3
setInformativeText()

Displays additional information

4
setDetailText()
Dialog shows a Details button. This text appears on clicking it

5
setTitle()
Displays the custom title of dialog

6
setStandardButtons()

List of standard buttons to be displayed. Each button is associated with

QMessageBox.Ok 0x00000400
QMessageBox.Open 0x00002000
QMessageBox.Save 0x00000800

QMessageBox.Cancel 0x00400000
QMessageBox.Close 0x00200000
QMessageBox.Yes 0x00004000
QMessageBox.No 0x00010000
 QMessageBox.Abort 0x00040000
QMessageBox.Retry 0x00080000
QMessageBox.Ignore 0x00100000

7
setDefaultButton()
Sets the button as default. It emits the clicked signal if Enter is pressed

8
setEscapeButton()
Sets the button to be treated as clicked if the escape key is pressed

Example

In the following example, click signal of the button on the top level window, the connected function
displays the messagebox dialog.

msg = QMessageBox()
msg.setIcon(QMessageBox.Information)
msg.setText("This is a message box")
msg.setInformativeText("This is additional information")
msg.setWindowTitle("MessageBox demo")
msg.setDetailedText("The details are as follows:")

setStandardButton() function displays desired buttons.

msg.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)

buttonClicked() signal is connected to a slot function, which identifies the caption of source of the signal.

msg.buttonClicked.connect(msgbtn)

The complete code for the example is as follows −

import sys
from PyQt4.QtGui import *
from PyQt4.QtCore import *

def window():
app = QApplication(sys.argv)
w = QWidget()
b = QPushButton(w)
b.setText("Show message!")

b.move(50,50)
b.clicked.connect(showdialog)
w.setWindowTitle("PyQt Dialog demo")
w.show()
sys.exit(app.exec_())
 def showdialog():
msg = QMessageBox()
msg.setIcon(QMessageBox.Information)

msg.setText("This is a message box")

msg.setInformativeText("This is additional information")
msg.setWindowTitle("MessageBox demo")
msg.setDetailedText("The details are as follows:")
msg.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)
msg.buttonClicked.connect(msgbtn)

retval = msg.exec_()
print "value of pressed message box button:", retval

def msgbtn(i):
print "Button pressed is:",i.text()

if __name__ == '__main__':
window()

The above code produces the following output −

PyQt - Multiple Document Interface

A typical GUI application may have multiple windows. Tabbed and stacked widgets allow to activate one
such window at a time. However, many a times this approach may not be useful as view of other
windows is hidden.
One way to display multiple windows simultaneously is to create them as independent windows. This is
called as SDI (single Document Interface). This requires more memory resources as each window may
have its own menu system, toolbar, etc.
MDI (Multiple Document Interface) applications consume lesser memory resources. The sub windows
are laid down inside main container with relation to each other. The container widget is called QMdiArea.
QMdiArea widget generally occupies the central widget of QMainWondow object. Child windows in this
area are instances of QMdiSubWindow class. It is possible to set any QWidget as the internal widget of
subWindow object. Sub-windows in the MDI area can be arranged in cascaded or tile fashion.

The following table lists important methods of QMdiArea class and QMdiSubWindow class −

Sr.No. Methods & Description

1
addSubWindow()
Adds a widget as a new subwindow in MDI area

2
removeSubWindow()
Removes a widget that is internal widget of a subwindow

3
setActiveSubWindow()

Activates a subwindow

4
cascadeSubWindows()
Arranges subwindows in MDiArea in a cascaded fashion

5
tileSubWindows()
Arranges subwindows in MDiArea in a tiled fashion

6
closeActiveSubWindow()

Closes the active subwindow

7
subWindowList()
Returns the list of subwindows in MDI Area

8
setWidget()
Sets a QWidget as an internal widget of a QMdiSubwindow instance

QMdiArea object emits subWindowActivated() signal whereas windowStateChanged() signal is emitted

by QMdisubWindow object.

Example
In the following example, top level window comprising of QMainWindow has a menu and MdiArea.

self.mdi = QMdiArea()
self.setCentralWidget(self.mdi)
bar = self.menuBar()
file = bar.addMenu("File")

file.addAction("New")
file.addAction("cascade")
file.addAction("Tiled")

Triggered() signal of the menu is connected to windowaction() function.

file.triggered[QAction].connect(self.windowaction)

The new action of menu adds a subwindow in MDI area with a title having an incremental number to it.

MainWindow.count = MainWindow.count+1
sub = QMdiSubWindow()
sub.setWidget(QTextEdit())
sub.setWindowTitle("subwindow"+str(MainWindow.count))
self.mdi.addSubWindow(sub)
sub.show()

Cascaded and tiled buttons of the menu arrange currently displayed subwindows in cascaded and tiled
fashion respectively.
The complete code is as follows −

import sys
from PyQt4.QtCore import *
from PyQt4.QtGui import *

class MainWindow(QMainWindow):
count = 0

def __init__(self, parent = None):

super(MainWindow, self).__init__(parent)
self.mdi = QMdiArea()
self.setCentralWidget(self.mdi)
bar = self.menuBar()

file = bar.addMenu("File")
file.addAction("New")
file.addAction("cascade")
file.addAction("Tiled")
file.triggered[QAction].connect(self.windowaction)
self.setWindowTitle("MDI demo")

def windowaction(self, q):

print "triggered"

if q.text() == "New":
MainWindow.count = MainWindow.count+1
sub = QMdiSubWindow()
 sub.setWidget(QTextEdit())
sub.setWindowTitle("subwindow"+str(MainWindow.count))
self.mdi.addSubWindow(sub)
sub.show()

if q.text() == "cascade":
self.mdi.cascadeSubWindows()

if q.text() == "Tiled":
self.mdi.tileSubWindows()

def main():
app = QApplication(sys.argv)
ex = MainWindow()
ex.show()
sys.exit(app.exec_())

if __name__ == '__main__':
main()

The above code produces the following output −

 PyQt - Drag & Drop

The provision of drag and drop is very intuitive for the user. It is found in many desktop applications
where the user can copy or move objects from one window to another.
MIME based drag and drop data transfer is based on QDrag class. QMimeData objects associate the
data with their corresponding MIME type. It is stored on clipboard and then used in the drag and drop
process.
The following QMimeData class functions allow the MIME type to be detected and used conveniently.
 Tester Getter Setter MIME Types

hasText() text() setText() text/plain

hasHtml() html() setHtml() text/html

hasUrls() urls() setUrls() text/uri-list

hasImage() imageData() setImageData() image/ *

hasColor() colorData() setColorData() application/x-color

Many QWidget objects support the drag and drop activity. Those that allow their data to be dragged have
setDragEnabled() which must be set to true. On the other hand, the widgets should respond to the drag
and drop events in order to store the data dragged into them.
DragEnterEvent provides an event which is sent to the target widget as dragging action enters
it.
DragMoveEvent is used when the drag and drop action is in progress.
DragLeaveEvent is generated as the drag and drop action leaves the widget.

DropEvent, on the other hand, occurs when the drop is completed. The event’s proposed
action can be accepted or rejected conditionally.

Example

In the following code, the DragEnterEvent verifies whether the MIME data of the event contains text. If
yes, the event’s proposed action is accepted and the text is added as a new item in the ComboBox.

import sys
from PyQt4.QtGui import *
from PyQt4.QtCore import *

class combo(QComboBox):

def __init__(self, title, parent):

super(combo, self).__init__( parent)

self.setAcceptDrops(True)

def dragEnterEvent(self, e):

print e

if e.mimeData().hasText():
e.accept()
else:
e.ignore()

def dropEvent(self, e):

self.addItem(e.mimeData().text())

class Example(QWidget):

def __init__(self):
 super(Example, self).__init__()

self.initUI()

def initUI(self):
lo = QFormLayout()
lo.addRow(QLabel("Type some text in textbox and drag it into combo box"))

edit = QLineEdit()
edit.setDragEnabled(True)
com = combo("Button", self)
lo.addRow(edit,com)
self.setLayout(lo)
self.setWindowTitle('Simple drag & drop')

def main():
app = QApplication(sys.argv)
ex = Example()
ex.show()
app.exec_()

if __name__ == '__main__':
main()

The above code produces the following output −

PyQt - Database Handling

PyQt API contains an elaborate class system to communicate with many SQL based databases. Its
QSqlDatabase provides access through a Connection object. Following is the list of currently available
SQL drivers −
 Sr.No. Driver Type & Description

1
QDB2
IBM DB2

2
QIBASE

Borland InterBase Driver

3
QMYSQL
MySQL Driver

4
QOCI
Oracle Call Interface Driver

5
QODBC
ODBC Driver (includes Microsoft SQL Server)

6
QPSQL
PostgreSQL Driver

7
QSQLITE
SQLite version 3 or above

8
QSQLITE2
SQLite version 2

Example

A connection with a SQLite database is established using the static method −

db = QtSql.QSqlDatabase.addDatabase('QSQLITE')
db.setDatabaseName('sports.db')

Other methods of QSqlDatabase class are as follows −

 Sr.No. Methods & Description

1
setDatabaseName()
Sets the name of the database with which connection is sought

2
setHostName()

Sets the name of the host on which the database is installed

3
setUserName()
Specifies the user name for connection

4
setPassword()
Sets the connection object’s password if any

5
commit()
Commits the transactions and returns true if successful

6
rollback()
Rolls back the database transaction

7
close()
Closes the connection

QSqlQuery class has the functionality to execute and manipulate SQL commands. Both DDL and DML
type of SQL queries can be executed. The most important method in the class is exec_(), which takes as
an argument a string containing SQL statement to be executed.

query = QtSql.QSqlQuery()
query.exec_("create table sportsmen(id int primary key,
" "firstname varchar(20), lastname varchar(20))")

The following script creates a SQLite database sports.db with a table of sportsperson populated with five
records.

from PyQt4 import QtSql, QtGui

def createDB():
db = QtSql.QSqlDatabase.addDatabase('QSQLITE')
db.setDatabaseName('sports.db')

if not db.open():
QtGui.QMessageBox.critical(None, QtGui.qApp.tr("Cannot open database"),
QtGui.qApp.tr("Unable to establish a database connection.\n"
 "This example needs SQLite support. Please read "
"the Qt SQL driver documentation for information "
"how to build it.\n\n" "Click Cancel to exit."),
QtGui.QMessageBox.Cancel)

return False

query = QtSql.QSqlQuery()

query.exec_("create table sportsmen(id int primary key, "

"firstname varchar(20), lastname varchar(20))")

query.exec_("insert into sportsmen values(101, 'Roger', 'Federer')")

query.exec_("insert into sportsmen values(102, 'Christiano', 'Ronaldo')")
query.exec_("insert into sportsmen values(103, 'Ussain', 'Bolt')")
query.exec_("insert into sportsmen values(104, 'Sachin', 'Tendulkar')")
query.exec_("insert into sportsmen values(105, 'Saina', 'Nehwal')")
return True

if __name__ == '__main__':
import sys

app = QtGui.QApplication(sys.argv)
createDB()

QSqlTableModel class in PyQt is a high-level interface that provides editable data model for reading and
writing records in a single table. This model is used to populate a QTableView object. It presents to the
user a scrollable and editable view that can be put on any top level window.
A QTableModel object is declared in the following manner −

model = QtSql.QSqlTableModel()

Its editing strategy can be set to any of the following −

QSqlTableModel.OnFieldChange All changes will be applied immediately

QSqlTableModel.OnRowChange Changes will be applied when the user selects a different row

QSqlTableModel.OnManualSubmit All changes will be cached until either submitAll() or revertAll() is called

Example

In the following example, sportsperson table is used as a model and the strategy is set as −

model.setTable('sportsmen')
model.setEditStrategy(QtSql.QSqlTableModel.OnFieldChange)

model.select()

QTableView class is part of Model/View framework in PyQt. The QTableView object is created as follows
−
 view = QtGui.QTableView()
view.setModel(model)
view.setWindowTitle(title)
return view

This QTableView object and two QPushButton widgets are added to the top level QDialog window.
Clicked() signal of add button is connected to addrow() which performs insertRow() on the model table.

button.clicked.connect(addrow)
def addrow():
print model.rowCount()
ret = model.insertRows(model.rowCount(), 1)
print ret

The Slot associated with the delete button executes a lambda function that deletes a row, which is
selected by the user.

btn1.clicked.connect(lambda: model.removeRow(view1.currentIndex().row()))

The complete code is as follows −

import sys
from PyQt4 import QtCore, QtGui, QtSql
import sportsconnection

def initializeModel(model):
model.setTable('sportsmen')
model.setEditStrategy(QtSql.QSqlTableModel.OnFieldChange)
model.select()
model.setHeaderData(0, QtCore.Qt.Horizontal, "ID")
model.setHeaderData(1, QtCore.Qt.Horizontal, "First name")
model.setHeaderData(2, QtCore.Qt.Horizontal, "Last name")

def createView(title, model):

view = QtGui.QTableView()
view.setModel(model)
view.setWindowTitle(title)
return view

def addrow():
print model.rowCount()
ret = model.insertRows(model.rowCount(), 1)
print ret

def findrow(i):
delrow = i.row()

if __name__ == '__main__':

app = QtGui.QApplication(sys.argv)
db = QtSql.QSqlDatabase.addDatabase('QSQLITE')
db.setDatabaseName('sports.db')
model = QtSql.QSqlTableModel()
delrow = -1
 initializeModel(model)

view1 = createView("Table Model (View 1)", model)

view1.clicked.connect(findrow)

dlg = QtGui.QDialog()
layout = QtGui.QVBoxLayout()
layout.addWidget(view1)

button = QtGui.QPushButton("Add a row")

button.clicked.connect(addrow)
layout.addWidget(button)

btn1 = QtGui.QPushButton("del a row")

btn1.clicked.connect(lambda: model.removeRow(view1.currentIndex().row()))
layout.addWidget(btn1)

dlg.setLayout(layout)
dlg.setWindowTitle("Database Demo")
dlg.show()
sys.exit(app.exec_())

The above code produces the following output −

PyQt - Drawing API

All the QWidget classes in PyQt are sub classed from QPaintDevice class. A QPaintDevice is an
abstraction of two dimensional space that can be drawn upon using a QPainter. Dimensions of paint
device are measured in pixels starting from the top-left corner.
QPainter class performs low level painting on widgets and other paintable devices such as printer.
Normally, it is used in widget’s paint event. The QPaintEvent occurs whenever the widget’s appearance
is updated.
The painter is activated by calling the begin() method, while the end() method deactivates it. In between,
the desired pattern is painted by suitable methods as listed in the following table.
Sr.No. Methods & Description

1
begin()
Starts painting on the target device

2
drawArc()
Draws an arc between the starting and the end angle

3
drawEllipse()

Draws an ellipse inside a rectangle

4
drawLine()
Draws a line with endpoint coordinates specified

5
drawPixmap()
Extracts pixmap from the image file and displays it at the specified position

6
drwaPolygon()
Draws a polygon using an array of coordinates

7
drawRect()
Draws a rectangle starting at the top-left coordinate with the given width and height

8
drawText()
Displays the text at given coordinates

9
fillRect()
Fills the rectangle with the QColor parameter

10
setBrush()
Sets a brush style for painting

11
setPen()
Sets the color, size and style of pen to be used for drawing
 PyQt - BrushStyle Constants

Predefined QColor Styles

Qt.NoBrush No brush pattern

Qt.SolidPattern Uniform color

Qt.Dense1Pattern Extremely dense brush pattern

Qt.HorPattern Horizontal lines

Qt.VerPattern Vertical lines

Qt.CrossPattern Crossing horizontal and vertical lines

Qt.BDiagPattern Backward diagonal lines

Qt.FDiagPattern Forward diagonal lines

Qt.DiagCrossPattern Crossing diagonal lines

Predefined QColor Objects

Qt.white

Qt.black

Qt.red

Qt.darkRed

Qt.green

Qt.darkGreen

Qt.blue

Qt.cyan

Qt.magenta

Qt.yellow

Qt.darkYellow

Qt.gray

Custom color can be chosen by specifying RGB or CMYK or HSV values.

Example
The following example implements some of these methods.

import sys
from PyQt4.QtGui import *
from PyQt4.QtCore import *

class Example(QWidget):

def __init__(self):
super(Example, self).__init__()
self.initUI()

def initUI(self):
self.text = "hello world"
self.setGeometry(100,100, 400,300)
self.setWindowTitle('Draw Demo')
self.show()

def paintEvent(self, event):

qp = QPainter()
qp.begin(self)
qp.setPen(QColor(Qt.red))
qp.setFont(QFont('Arial', 20))

qp.drawText(10,50, "hello Pyth

on")
qp.setPen(QColor(Qt.blue))
qp.drawLine(10,100,100,100)
qp.drawRect(10,150,150,100)

qp.setPen(QColor(Qt.yellow))
qp.drawEllipse(100,50,100,50)
qp.drawPixmap(220,10,QPixmap("python.jpg"))
qp.fillRect(200,175,150,100,QBrush(Qt.SolidPattern))
qp.end()

def main():
app = QApplication(sys.argv)
ex = Example()
sys.exit(app.exec_())

if __name__ == '__main__':
main()

The above code produces the following output −

 PyQt - QClipboard

The QClipboard class provides access to system-wide clipboard that offers a simple mechanism to copy
and paste data between applications. Its action is similar to QDrag class and uses similar data types.
QApplication class has a static method clipboard() which returns reference to clipboard object. Any type
of MimeData can be copied to or pasted from the clipboard.
Following are the clipboard class methods that are commonly used −
 Sr.No. Methods & Description

1
clear()
Clears clipboard contents

2
setImage()
Copies QImage into clipboard

3
setMimeData()

Sets MIME data into clipboard

4
setPixmap()
Copies Pixmap object in clipboard

5
setText()
Copies QString in clipboard

6
text()
Retrieves text from clipboard

Signal associated with clipboard object is −

Sr.No. Method & Description

1
dataChanged()
Whenever clipboard data changes

Example
In the following example, two TextEdit objects and two Pushbuttons are added to a top level window.
To begin with the clipboard object is instantiated. Copy() method of textedit object copies the data onto
the system clipboard. When the Paste button is clicked, it fetches the clipboard data and pastes it in
other textedit object.
 PyQt - QPixmap Class

QPixmap class provides an off-screen representation of an image. It can be used as a QPaintDevice

object or can be loaded into another widget, typically a label or button.
Qt API has another similar class QImage, which is optimized for I/O and other pixel manipulations.
Pixmap, on the other hand, is optimized for showing it on screen. Both formats are interconvertible.
The types of image files that can be read into a QPixmap object are as follows −
 BMP Windows Bitmap

GIF Graphic Interchange Format (optional)

JPG Joint Photographic Experts Group

JPEG Joint Photographic Experts Group

PNG Portable Network Graphics

PBM Portable Bitmap

PGM Portable Graymap

PPM Portable Pixmap

XBM X11 Bitmap

XPM X11 Pixmap

Following methods are useful in handling QPixmap object −

Sr.No. Methods & Description

1
copy()
Copies pixmap data from a QRect object

2
fromImage()
Converts QImage object into QPixmap

3
grabWidget()
Creates a pixmap from the given widget

4
grabWindow()
Create pixmap of data in a window

5
Load()
Loads an image file as pixmap

6
save()

Saves the QPixmap object as a file

7
toImage
Converts a QPixmap to QImage
The most common use of QPixmap is to display image on a label/button.

Example
The following example shows an image displayed on a QLabel by using the setPixmap() method. The
complete code is as follows −

import sys
from PyQt4.QtCore import *
from PyQt4.QtGui import *

def window():
app = QApplication(sys.argv)
win = QWidget()
l1 = QLabel()
l1.setPixmap(QPixmap("python.jpg"))

vbox = QVBoxLayout()
vbox.addWidget(l1)
win.setLayout(vbox)
win.setWindowTitle("QPixmap Demo")
win.show()
sys.exit(app.exec_())

if __name__ == '__main__':
window()

The above code produces the following output −