Ask Ubuntu is a question and answer site for Ubuntu users and developers. It's 100% free.

Sign up
Here's how it works:
  1. Anybody can ask a question
  2. Anybody can answer
  3. The best answers are voted up and rise to the top

Recently I've been involved in conversations about creating a Quickly template for a Qt and QtQuick Ubuntu app. The idea is to make it as easy to develop Qt apps from concept to package as it is right now with GTK, on which the Ubuntu application Quickly template is based.

The intention is still to use Python as the base programming language, and the first question that comes to mind is: which Python bindings should we use PyQt or PySide?

I'd like to hear from the folks experienced in both technologies what the pros and cons of each one are, how well maintaned each one is, how well mapped the Qt API is to the bindings, etc.


share|improve this question
Well python-qt4 is in main and python-pyside is in universe. I think you should probably ask this to Kubuntu guys too. – Jeremy Bicha May 22 '12 at 23:39
This question may be better placed on or – DrAl May 24 '12 at 12:18
Thanks @DrAl, yeah, I was wondering that too, but it was specifically for creating a Quickly template for Ubuntu, which is why I decided for AskUbuntu. – David Planella May 24 '12 at 12:20
I've been also pointed out to – David Planella May 24 '12 at 12:24
up vote 60 down vote accepted

Both PyQt4 and PySide have very similar mappings to the Qt API. There are, however, some differences, my opinions on which are described below:


They are both well maintained. The PySide produces a lot more regular releases at the moment: I think it's more closely linked to Qt than PyQt4 and as a newer project has a more active community at the moment. However, that is just my impression and it may be wrong.

PyQt4 has the option of commercial support available (I don't know whether this is true for PySide or not).


PyQt4 is released under either a commercial licence or the GPL; PySide is released under the LGPL. For commercial applications, this is a significant difference.

APIs and Python versions

PyQt4 supports two different APIs. API version 1 is the default for python 2.x applications and API version 2 is the default for python 3.x applications.

PySide only supports one API, which is roughly equivalent to PyQt4's API version 2. API version 2 (or the PySide API) is much nicer to work with than PyQt4's API version 1. In API version 1 you have a lot of code that casts python strings to QtCore.QStrings and back again. In API version 2 (and PySide) you just use python strings throughout. See below for a simple way of switching between PyQt4 and PySide if you want to play with both.

Most code I write seems to work equally well in PyQt4 and PySide. Historically, I had always used PyQt4 for python GUIs but most new stuff I write now uses PySide (mainly due to the more flexible licensing). I'd certainly recommend you try both and see how you find them. If you use (below), switching between them is trivial and when you make a decision there will only be one file that needs updating.


The documentation for both PyQt4 and PySide are auto-generated from the main Qt documentation. In my opinion, the PySide documentation is a better representation of what you actually use, but in practice I tend to just use the Qt documentation anyway (it's quite easy to mentally translate the C++ documentation to python).

External Libraries

If you're using external libraries, some do not work with PySide yet. There aren't many that you need to work with PySide to be honest, but a couple of years ago I wrote some code that used twisted (with the Qt reactor) and matplotlib and that forced me down the line of using PyQt4 rather than PySide. I think it's quite likely that these libraries will have been updated to support both by now, but I haven't checked.

Making Code work with either PyQt4 or PySide

Assuming you're using python 2.x, you can fairly easily make your code compatible with both PySide and PyQt4 by making a and using:

from QtVariant import QtGui, QtCore

or whatever. The that I use looks like this:

import sys
import os

default_variant = 'PySide'

env_api = os.environ.get('QT_API', 'pyqt')
if '--pyside' in sys.argv:
    variant = 'PySide'
elif '--pyqt4' in sys.argv:
    variant = 'PyQt4'
elif env_api == 'pyside':
    variant = 'PySide'
elif env_api == 'pyqt':
    variant = 'PyQt4'
    variant = default_variant

if variant == 'PySide':
    from PySide import QtGui, QtCore
    # This will be passed on to new versions of matplotlib
    os.environ['QT_API'] = 'pyside'
    def QtLoadUI(uifile):
        from PySide import QtUiTools
        loader = QtUiTools.QUiLoader()
        uif = QtCore.QFile(uifile)
        result = loader.load(uif)
        return result
elif variant == 'PyQt4':
    import sip
    api2_classes = [
            'QData', 'QDateTime', 'QString', 'QTextStream',
            'QTime', 'QUrl', 'QVariant',
    for cl in api2_classes:
        sip.setapi(cl, 2)
    from PyQt4 import QtGui, QtCore
    QtCore.Signal = QtCore.pyqtSignal
    QtCore.QString = str
    os.environ['QT_API'] = 'pyqt'
    def QtLoadUI(uifile):
        from PyQt4 import uic
        return uic.loadUi(uifile)
    raise ImportError("Python Variant not specified")

__all__ = [QtGui, QtCore, QtLoadUI, variant]
share|improve this answer
Since PySide accepts high-level Python objects a lot of the time, your UI loader function can be simplified to something like return QtUiTools.QUiLoader().load(uifile), taking the filepath without any of that QFile boilerplate. – Chris Billington Oct 12 '12 at 10:45

Your Answer


By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.