Por E. E. del Valle Pino ([email protected].

cu)
Licenciado bajo GPL v3
Potenciado por GIMP y OpenOffice.org
Revisión 07012010

¿Este tutorial es para mí?

Este documento está dirigido a personas que ya saben programar en Python y que desean
dar los primeros pasos para desarrollar aplicaciones con el framework Qt en dicho lenguaje.

Para Windows o Mac podemos descargar el intérprete de Python desde w w w .python.org/dow nload/
y PyQt4 desde w w w .riverbankcom puting.co.uk/softw are/pyqt/dow nload, con esto es suficiente
para hacer todo lo que aquí se enseña.

¿Qué es Qt?
Qt es una framework multiplataforma para desarrollar interfaces gráficas de usuario. La
biblioteca la desarrolla la que fue su creadora, la compañía noruega Trolltech, actualmente
renombrada a Qt Software, y que desde junio de 2008 es propiedad de Nokia.

Qt es utilizada en KDE, un entorno de escritorio para sistemas como GNU/Linux o FreeBSD,

entre otros. Utiliza el lenguaje de programación C++ de forma nativa y además existen
extensiones para C, Python (PyQt), Java (Qt Jambi), Perl (PerlQt), Gambas (gb.qt), Ruby
(QtRuby), PHP (PHP-Qt) y Mono (Qyoto) entre otros.

El API de la biblioteca cuenta con métodos para acceder a bases de datos mediante SQL, así
Desarrollar aplicaciones con PyQt4

como uso de XML y una multitud de otros para el manejo de ficheros, además de estructuras
de datos tradicionales.

Preparando el ambiente
Lo primero que hacemos en GNU/Linux para desarrollar aplicaciones con Python y Qt4 es
primero tener algún escritorio previamente instalado y entonces instalar [Ver Nota] los
paquetes

qt4-designer El diseñador de interfaces gráficas Qt4

python-qt4 El biding de python para Qt4
pyqt4-dev-tool Otras herramientas para trabajar con PyQt4

Recuerde que para instalar paquetes en Debian/Ubuntu/Mint se hace de la siguiente forma:

sudo apt-get install <nombre-paquete1>[, <nombre-paquete2>[, ...]]

y para desinstalar:
sudo apt-get remove [--purge] <nombre-paquete1>[, <nombre-paquete2>[, ...]]

La opción --purge se escribe cuando deseamos que junto con la desinstalación del paquete se borren sus
Programación

archivos de configuración.

 ͳ͵
 Si deseamos documentación sobre la API de PyQt4 podemos instalar qt4-doc (esta ayuda se
ve con Qt Assistent), si deseamos ayuda en HTML instalamos qt4-doc-html el cual se instala
en /usr/share/doc/qt4-doc-html. Si lo deseemos podemos copiar la carpeta para conservar la
documentación y desinstalar el paquete.
Si deseamos soporte para SQL en PyQt4 instalamos python-qt4-sql y el driver SQL
correspondiente de Qt4:

libqt4-sql-mysql MySQL
libqt4-sql-odbc Microsoft SQL Server
libqt4-sql-psql PostgreSQL
libqt4-sql-sqlite SQLite3
libqt4-sql-sqlite2 SQLite2

¿Qué vamos a hacer?

Vamos a hacer un programa sencillo que se verá así:
El cual cuando se presione Go! mostrará el mismo texto
de la región editable en el botón Go!, y al presionarse
"Cerrar" cerrará la ventana.

Diseñemos la interfaz
Para ello primero abrimos Qt4-Designer, el cual se
encuentra en la categoría de aplicaciones de desarrollo.
Una vez abierto este lo primero que nos pregunta qué
tipo de ventana queremos crear. Seleccionamos Main
Desarrollar aplicaciones con PyQt4

Window y hacemos clic en Create.

Luego de esto vemos

la ventana principal de
diseñador que está
dividida en las
siguientes subventana:
Programación

1
2

Caja de widgets, donde se encuentran los componentes visuales más comunes.
Ventana de diseño, donde diseñamos la interfaz
ͳͶ
 Para diseñar la interfaz arrastramos desde la caja de
widgest (1), los componentes LineEdit y dos PushButtons
hacia la ventana de diseño (2). Luego para poner el
WH[WR³ponga su texto aquí´HQHO LineEdit, marcamos este
componente y vamos al editor de propiedades (5) y
buscamos entre sus últimas opciones, que son las
específicas del componente seleccionado.

Por comodidad personalmente he decidido nombrar los

componentes con las dos primeras letras minúsculas de las
iniciales del nombre del componente. Por ejemplo al botón
*RSRQHUOH³SE*R´push button Go), para luego cuando esté
codificando saber qué tipo de componente me estoy
refiriendo.

CambiamRV HO QRPEUH GH *R D ³SJ*R´ \ VX WH[WR D ³*R´ HO ERWyQ &HUUDU OH SRQHPRV
³SE&ORVH´\OHSRQHPRVHOWH[WRFRUUHVSRQGLHQWHFRPRPLVPRKLFLPRVFRQHO LineEdit.

Los slots
Qt nos permite hacer parte de la programación en el diseño de la interfaz gráfica, usando los
slots. Estos son señales que se pueden enviar los componentes de una ventana entre ellos.
Por ejemplo, cuando se haga clic en pbClose este ejecute el método close() de MainWindows, para
finalizar la ejecución del programa.

Esto lo realizamos de la siguiente forma, en el editor de slots (6 KDFHPRV FOLF HQ ³´ SDUD
DJUHJDU XQD QXHYR VORW OXHJR VHOHFFLRQDPRV HQ HO FRPER ³6HQGHU´ HO FRPSRQHQWH TXH
Desarrollar aplicaciones con PyQt4

inicializa la acción, que en este caso es el pbClose; OXHJRHQ³6LJQDO´ODVHxDOSRUODFXDO pbClose

debe actuar, esta es clicked() OXHJR VHOHFFLRQDPRV HQ ³5HFLYHU´ HO FRPSRQHQWH TXH UHFLEH OD
señal, MainWindow\ODDFFLyQTXHVHYDDUHDOL]DUVREUHHVWH³6ORW´ close().

Debe quedar más o menos así:

Luego de realizado esto salvamos nuestro diseño en una carpeta.

En realidad lo que hace QtDesigner es crear un archivo XML, con la descripción de la interfaz
gráfica, pues a partir de este archivo se pude generar con diferentes herramientas en varios
lenguajes.

Todo el código fuente de esta aplicación se encuentra en

Programación

los adjuntos que acompañan esta edición. Para más

información, dudas o sugerencias comuníquese con el
autor:
Eddy: [email protected]
 ͳͷ
 Codificando
En nuestro caso que es Python, vamos a usar pyuic4 de la siguiente manera: Abrimos un
WHUPLQDO HQ OD FDUSHWD GRQGH JXDUGDPRV HO IRUPXODULR FRQ HO QRPEUH ³0DLQ:LQGRZXL´ \
ejecutamos:
$ pyuic4 MainWindow.ui

El resultado de esta acción es que nos muestra el código en Python de la ventana que
diseñamos en la consola; para crear un archivo con este código usamos el operador de flujo,
así que siempre debemos ejecutar:
$ pyuic4 MainWindow.ui > Ui_MainWindow.py

De esta forma el código se almacena en el archivo Ui_MainWindows.py, arbimos el archivo

con nuestro editor de código preferido y veremos:
«
from PyQt4 import QtCore, QtGui

class Ui_MainWindow(object):
def setupUi(self, MainWindow):
MainWindow.setObjectName("MainWindow")
«

Como vemos el código de nuestro formulario es una clase, de la que luego heredaremos e
implementaremos los métodos que nos interesen.

Heredando del diseño

3DUDHVWRFUHDPRVXQDUFKLYRTXHVHOODPH³0DLQ:LQGRZS\´
Desarrollar aplicaciones con PyQt4

Si se ha dado cuenta, el que contiene el código generado automático su nombre comienza

FRQ ³8L´ HVWR OR KDFHPRV SDUD GLIHUHQFLDU OD LQWHUID] GH XVXDULR UI ± User Interface) de
nuestro código; pues en caso de que tengamos que retocar o modificar la interfaz gráfica del
fichero .ui, una vez guardado regeneramos el código de Ui_MainWindow.py, y nuestro
código, en MainWindow.py, no se ve afectado. Si lo hiciéramos todo en el mismo archivo
cada vez que regeneramos el código, perderíamos nuestro código.

Volviendo al tema anterior, en al archivo MainWindow.py escribimos lo siguiente:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from PyQt4 import QtGui

from Ui_MainWindow import Ui_MainWindow
from PyQt4.QtCore import pyqtSignature

class MainWindow(QtGui.QMainWindow, Ui_MainWindow):

def __init__(self):
"""Creates a MainWindows"""
super(MainWindow, self).__init__()
self.setupUi(self)

 ͳ͸
 Este código importa de PyQt4 QtGui y la clase Ui_MainWindow del fichero que generamos
anteriormente. Luego viene la declaración de una clase MainWindow la que hereda de
QtGui.QMainWindow y de Ui_MainWindow. En su constructor podemos ver que se llama al constructor
padre de MainWindow y luego el método setupUi() que se encuentra definido en Ui_MainWindow, el
cual es el encargado de crear todos los widgets.

Nuestros eventos
Para hacer nuestros métodos, para los eventos que deseamos programar, estos se escriben
de la con el siguiente formato en la signatura:
def on_<nombreObjeto>_<señal>(self):

Por ejemplo para programar pbGo en su evento clicked() , para que el texto del LineEdit se
copie a su propiedad text. Lo hacemos de la siguiente forma, agregando este método en la
clase MainWindow:
def on_pbGo_clicked(self):
self.pbGo.setText(self.lineEdit.text())

De esta forma podemos programar cualquier otro evento, conociendo el nombre del objeto
involucrado y el nombre de la señal del evento. Para esto podemos consultar la
documentación de PyQt4.

Lancemos nuestra aplicación

Para esto creamos un archivo main.py y ponemos dentro el siguiente código.
#!/usr/bin/env python

import sys
from PyQt4 import QtGui

from mainWindow import MainWindow

Desarrollar aplicaciones con PyQt4

if __name__=="__main__":
app = QtGui.QApplication(sys.argv)
mainWindow = MainWindow()
mainWindow.show()
sys.exit(app.exec_())

En el que importamos las librerías principales de PyQt4 y MainWindow, creamos una

QtGui.QApplication con los argumentos pasados desde el terminal y un objeto MainWindow, y la
mostramos. Luego retornamos el código de salida que devuelve la aplicación.

Para ejecutar esto le damos permisos de ejecución a main.py, y le hacemos doble clic.

Luego de esto ¿qué?

Recordemos que esto es tan sólo un tutorial para iniciarnos en con PyQt4, la documentación
del framework y de su API es bastante bueno, siempre será bueno tenerla a mano para
realizar consultas y leer algún libro sobre desarrollo con Qt4. Lo otro que recomiendo cuando
creemos una aplicación con interfaz gráfica es separar cada ventana en una carpeta diferente
para que se nos forme reguero en el código y luego nos sea difícil mantener el programa; y
separar la lógica de este en un paquete a parte como en MCV (Model Controller View,
³0RGHOR9LVWD&RQWURODGRU´).
Programación

 ͳ͹