Saltar al contenido

Tutorial de PyQt: Diseñador GUI de Python

diciembre 8, 2019

¿Qué es PyQt?

PyQt es un enlace python del widget-toolkit Qt de código abierto, que también funciona como un marco de desarrollo de aplicaciones multiplataforma. Qt es un marco de trabajo C++ popular para escribir aplicaciones GUI para todas las principales plataformas de escritorio, móviles e integradas (soporta Linux, Windows, MacOS, Android, iOS, Raspberry Pi, y más).

PyQt es desarrollado y mantenido por Riverbank Computing, una compañía con sede en Inglaterra, mientras que Qt es desarrollado por una firma finlandesa llamada The Qt Company.

En este tutorial de PyQT, aprenderá:

  • ¿Qué es PyQt?
  • Características de PyQT
  • Versiones de PyQt
  • Cómo instalar PyQt
  • Conceptos y programas básicos de PyQt
  • Componentes y widgets
  • Temas

Características de PyQT

Aquí están las características importantes de PyQt:

PyQt consta de más de seiscientas clases que cubren una serie de características como

  • Interfaces gráficas de usuario
  • Bases de datos SQL
  • Juegos de herramientas web
  • Procesamiento de XML
  • Conexión en red

Estas características se pueden combinar para crear interfaces de usuario avanzadas y aplicaciones independientes. Muchas de las principales empresas de todos los sectores utilizan Qt. Algunos ejemplos son LG, Mercedes, AMD, Panasonic, Harman, etc.

Versiones de PyQt

PyQt está disponible en dos ediciones, PyQt4 y PyQt5. PyQt4 proporciona código de pegamento para encuadernar las versiones 4.x y 5.x del marco de trabajo de Qt, mientras que PyQt5 proporciona un enlace sólo para las versiones 5.x. Como resultado, PyQt5 no es compatible con los módulos obsoletos de la versión anterior. En este tutorial, PyQt5 se utilizará para la demostración de ejemplos. Aparte de estas dos versiones,

Riverbank Computing también proporciona PyQt3D, los enlaces de pitón para el marco de trabajo de Qt3D. Qt3D es un framework de aplicación utilizado para crear sistemas de simulación en tiempo real con renderizado 2D/3D.

Cómo instalar PyQt

Existen dos formas de instalar PyQt.

  • Uso de archivos de rueda
  • Construcción e instalación desde el origen

Qt es un sistema complejo, y la base de código de PyQt contiene código C++ y Python compilado bajo el capó. Como resultado, es un proceso complicado de construir e instalar desde el código fuente en comparación con otras librerías python. Sin embargo, puede instalar fácilmente PyQt5 utilizando ruedas.

Instalación con ruedas

Las ruedas son el nuevo formato estándar de embalaje y distribución de Python. Simplemente hablando, una rueda es un archivo ZIP con un nombre especial y… whl extensión de archivo. Las ruedas se pueden instalar usando pip (gestor de paquetes de Python), que se incluye por defecto en las versiones recientes de Python.

Por lo tanto, si tiene instalado Python 3.4 o posterior, ya tiene pip. Sin embargo, si está usando una versión anterior de Python, debe descargar e instalar pip antes de seguir adelante. Puede buscar instrucciones para ello en este enlace: https://pypi.org/project/pip/

Para instalar PyQt5,

Paso 1) Abra el símbolo del sistema o PowerShell en su máquina Windows.

Paso 2) Escriba lo siguiente

 pip install PyQt5 

Este paso descargará el paquete PyQt5 whl (unos 50 MB) y lo instalará en su sistema.

Paso 1) Alternativamente, también puede descargar un binario de Windows para la versión de python instalada en su ordenador.

Una vez completado, proceda a la siguiente sección para escribir su primera aplicación GUI.

Conceptos y programas básicos de PyQt

Ahora que ha instalado correctamente PyQt5 en su ordenador, está preparado para escribir aplicaciones GUI en python.

Comencemos con una simple aplicación que mostrará una ventana vacía en su pantalla.

Encienda su python IDLE y escriba lo siguiente:

Programa 1

import sys
desde PyQt5.QtWidgets importar QApplication, QWidget
si __nombre__ == «__main__»:
app = QApplication(sys.argv)
w = QWidget()
Tamaño de la pieza completa (300.300)
w.setWindowTitle($0027Guru99$0027)
w.show()
sys.exit(app.exec_())
>

Guárdelo como app.py (el nombre no importa) y pulse F5 para ejecutar el programa. Alternativamente, haga doble clic en el archivo guardado para iniciar la aplicación. Si lo has hecho todo bien, se abrirá una nueva ventana con el título Guru99 como se muestra a continuación.

¡Genial! Está funcionando. No es mucho, pero es suficiente para entender lo básico. Ahora, veamos en detalle lo que hace cada una de las líneas de su programa.

desde PyQt5.QtWidgets importar QApplication, QWidget
>

Esta sentencia importa todos los módulos que necesita para crear una GUI en el espacio de nombres actual. El módulo QtWidgets contiene todos los widgets principales que utilizará en este tutorial.

app = QApplication(sys.argv)

>

Aquí está creando un objeto de la clase QApplication. Este paso es necesario para PyQt5; cada aplicación UI debe crear una instancia de QApplication, como una especie de punto de entrada en la aplicación. Si no lo crea, se mostrarán los errores.

sys.argv es la lista de parámetros de línea de comandos que puede pasar a la aplicación cuando la lanza a través del shell o mientras automatiza la interfaz.

En este ejemplo, no pasó ningún argumento a QApplications. Por lo tanto, también puede reemplazarlo con el siguiente código y no tener que importar el módulo sys.

app = QApplication([])
w = QWidget()

>

A continuación, hacemos un objeto de la clase QWidget. QWidget es la clase base de todos los objetos de interfaz de usuario en Qt, y prácticamente todo lo que ves en una aplicación es un widget. Esto incluye diálogos, textos, botones, barras, etc. La característica que le permite diseñar interfaces de usuario complejas es que los widgets pueden anidarse, es decir, puede tener un widget dentro de un widget, que está dentro de otro widget. Verá esto en acción en la siguiente sección.

w.resize(300,300)

>

El método de redimensionamiento de la clase QWidget le permite establecer las dimensiones de cualquier widget. En este caso, ha cambiado el tamaño de la ventana a 300px por 300px.

Aquí, debe recordar que los widgets pueden anidarse juntos, el widget más externo (es decir, el widget sin padre) se llama Ventana.

w.setWindowTitle($0027Guru99$0027)
>

El método setWindowTitle() le permite pasar una cadena como argumento que establecerá el título de la ventana a la cadena que usted pasa. En el ejemplo, la barra de título mostrará Guru99.

w.show()

>

show() simplemente muestra el widget en la pantalla del monitor.

sys.exit(app.exec_())

>

El método app.exec_() inicia el bucle de eventos Qt/C++. Como sabes, PyQt está escrito en C++ y utiliza el mecanismo de bucle de eventos para implementar la ejecución paralela. app.exec_() pasa el control a Qt, que saldrá de la aplicación sólo cuando el usuario la cierre desde la GUI. Es por eso que ctrl+c no saldrá de la aplicación como en otros programas de python. Como Qt tiene control sobre la aplicación, los eventos python no son procesados a menos que los configuremos dentro de la aplicación. Además, tenga en cuenta que el método exec tiene un subrayado en su nombre; esto se debe a que exec() ya era una palabra clave en python y el subrayado resuelve el conflicto de nombres.

Más allá de las ventanas vacías

En la sección anterior, usted vio cómo hacer un widget básico en Qt. Ahora es el momento de hacer algunas interfaces más involucradas con las que los usuarios puedan interactuar realmente. Una vez más, encienda su IDLE y escriba lo siguiente.

import sys
desde PyQt5.QtWidgets importar QApplication, QWidget, QLabel, QPushButton, QMessageBox
def dialog():
mbox = QMessageBox()
mbox.setText(«Su lealtad ha sido anotada»)
mbox.setTextoDetallado («Ahora eres un discípulo y sujeto del Gurú que todo lo sabe»)
mbox.setBotones estándar(QMessageBox.Ok | QMessageBox.Cancel)
mbox.exec_()
si __nombre__ == «__main__»:
app = QApplication(sys.argv)
w = QWidget()
Tamaño de la pieza completa (300.300)
w.setWindowTitle($0027Guru99$0027)
label = QLabel(w)
label.setText(«Contempla al Gurú, Gurú99»)
etiqueta.move(100,130)
etiqueta.show()
btn = QPulsador(w)
btn.setText($0027Beheld$0027)
btn.move(110.150)
btn.show()
btn.clicked.connect(diálogo)
w.show()
sys.exit(app.exec_())
>

Guarda el archivo como appone.py o lo que quieras y pulsa F5 para ejecutar el programa. Si no ha cometido ningún error, el IDLE abrirá una nueva ventana con un poco de texto y un botón como se muestra a continuación.

  1. Una vez que haga clic en el botón de la primera ventana, se abrirá un nuevo cuadro de mensaje con el texto que ha escrito.
  2. Ahora puede hacer clic en el botón Ocultar detalles/Mostrar detalles para cambiar la visibilidad del texto adicional.

Como puede ver, como no habíamos establecido ningún título de ventana en el cuadro de mensaje, el propio python proporcionó un título por defecto.

Ahora que está funcionando, echemos un vistazo al código extra que ha añadido al ejemplo anterior.

desde PyQt5.QtWidgets importar QApplication, QWidget, QLabel, QPushButton, QMessageBox
>

Esto importa algunos otros widgets que ha utilizado en este ejemplo, a saber, QLabel, QPushButton y QMessageBox.

def dialog():
mbox = QMessageBox()
mbox.setText(«Su lealtad ha sido anotada»)
mbox.setTextoDetallado («Ahora eres un discípulo y sujeto del Gurú que todo lo sabe»)
mbox.setBotones estándar(QMessageBox.Ok | QMessageBox.Cancel)
mbox.exec_()
>

Aquí, ha definido un método llamado diálogo que crea un widget de caja de mensajes y establece algún texto en los botones y otros campos.

El método de diálogo se llama desde el bloque principal del programa cuando se pulsa un botón en un widget específico (en este caso, el botón pulsador btn). El evento de clic desencadenado en ese botón hace que se ejecute esta función. Esta función se llama ranura en Qt, y aprenderá más sobre señales y ranuras en los párrafos siguientes.

si __nombre__ == «__main__»:
app = QApplication(sys.argv)
w = QWidget()
Tamaño de la pieza completa (300.300)
w.setWindowTitle($0027Guru99$0027)
>

Esta es la sección principal de la aplicación y, como en el ejemplo anterior, se empieza por crear una instancia de QApplication seguida de un widget simple, es decir, una instancia de QWidget.

 etiqueta = QLabel(w)
    btn = QPulsador(w)

>

Has añadido dos nuevos widgets en esta aplicación: QLabel y QPushButton. QLabel se utiliza para imprimir texto no editable o marcadores de posición dentro de un widget, mientras que QPushButton se utiliza para crear un botón pulsable.

Lo más importante que hay que tener en cuenta aquí es que cuando se crean los objetos etiqueta y btn, se está pasando el objeto ventana (w) a los constructores de QLabel y QPushButton. Así es como funciona el anidamiento en PyQt5. Para crear un widget dentro de otro widget, pase la referencia del widget padre al constructor del hijo.

label.move(100,130)
btn.move(110.150)

>

move() se usa para establecer la posición de un widget con respecto a su widget padre. En el primer caso, la etiqueta se moverá 100px desde la izquierda y 130px desde la parte superior de la ventana.

Del mismo modo, el botón se colocará a 110px desde la izquierda y a 150px desde la parte superior de la ventana. Este ejemplo es una manera cruda de lograr diseños y generalmente no se utiliza en la producción; sólo se incluye aquí con fines de aprendizaje. Qt soporta diferentes diseños que podrás ver en detalle en las próximas secciones de este tutorial.

btn.clicked.connect(diálogo)
>

Finalmente, este es un ejemplo de señales y ranuras en Qt. En las aplicaciones basadas en GUI, las funciones se ejecutan en función de las acciones realizadas por el usuario, como pasar el ratón por encima de un elemento o hacer clic en un botón. Estas acciones se denominan eventos . Recuerde que el método app.exec_() transfiere el control al bucle Qt event- . Para esto está el bucle de eventos: para escuchar los eventos y realizar acciones en respuesta.

Cada vez que ocurre un evento, al igual que un usuario que hace clic en un botón, el widget Qt correspondiente genera una señal . Estas señales pueden conectarse a las funciones de python (como la función de diálogo de este ejemplo) para que la función se ejecute cuando se dispara una señal. Estas funciones se llaman slots en la jerga Qt.

Posteriormente, la sintaxis básica para activar una función de ranura en respuesta a la señal de un evento es la siguiente

 widget.signal.connect(slot) 

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>.

Lo que significa que siempre que una señal es disparada por un widget , se ejecutará la función de ranura conectada . En resumen, las señales y ranuras son utilizadas por Qt para comunicarse entre objetos y facilitar la reutilización e interactividad de los componentes.

Ahora que sabes cómo anidar widgets e implementar interacciones usando señales y slots, aquí tienes una lista de widgets útiles y otras clases que puedes usar en tus aplicaciones PyQt.

Componentes y widgets

Hay un gran número de widgets disponibles en PyQt para crear aplicaciones GUI. Sin embargo, con PyQt5, ha habido una reorganización de las clases en diferentes módulos y revisiones en las licencias.

Por lo tanto, es crucial tener una visión de alto nivel de la estructura de PyQt5. En esta sección, verá cómo PyQt5 está organizado internamente y aprenderá sobre los diferentes módulos, bibliotecas y clases de API proporcionados por PyQt5.

Estructura de directorios de PyQt5

Estos son los módulos fundamentales utilizados por la encuadernación Qt de Python, específicamente PyQt5.

  • Qt : Combina todas las clases/módulos mencionados abajo en un solo módulo. Aumenta considerablemente la memoria utilizada por la aplicación. Sin embargo, es más fácil gestionar el framework importando sólo un módulo.
  • QtCore : Contiene las clases no gráficas principales utilizadas por otros módulos. Aquí es donde se implementan el bucle de eventos Qt, las señales, la conectividad de ranura, etc.
  • QtWidgets : Contiene la mayoría de los widgets disponibles en Pyqt5.
  • QtGui : Contiene componentes GUI y extiende el módulo QtCore.
  • QtNetwork : Contiene clases utilizadas para implementar la programación de red a través de Qt. Soporta servidores TCP, sockets TCP, sockets UDP, manejo de SSL, sesiones de red y búsquedas de DNS.
  • QtMultimedia proporciona funcionalidad multimedia de bajo nivel.
  • QtSql : implementa la integración de bases de datos para bases de datos SQL. Soporta ODBC, MySQL, Oracle, SQLite y PostgreSQL.

Widgets de PyQt5

Aquí hay una lista de los widgets más usados en PyQt5

  • QLineEdit : Este es un campo de entrada que permite al usuario introducir una línea de texto.

    line = QLineEdit()
  • QRadioButton : Este es un campo de entrada con un botón seleccionable, similar a los botones de radio en html.

    rad = QRadioButton("título del botón")
    rad.setChecked(True) # para seleccionar el botón por defecto.
    
  • QComboBox : Se utiliza para mostrar un menú desplegable con una lista de elementos seleccionables. drop = QComboBox(w)
    drop.addItems([«item one», «item two», «item three»])
  • QCheckBox : Muestra una casilla cuadrada seleccionable delante de la etiqueta que está marcada si está seleccionada, similar a los botones de radio.

    check = QCheckBox("título del botón")
    
  • QMenuBar : muestra una barra de menú horizontal en la parte superior de una ventana. Sólo puede añadir objetos de la clase QMenu a esta barra. Estos objetos QMenu pueden contener además cadenas, objetos QAction u otros objetos QMenu.
  • QToolBar : Es una barra o panel horizontal que se puede mover dentro de la ventana. Puede contener botones y otros widgets.
  • QTab : se utiliza para dividir el contenido de una ventana en varias páginas a las que se puede acceder a través de diferentes pestañas en la parte superior del widget. Consta de dos secciones: la barra de pestañas y la etiqueta.
  • QScrollBar : Se utiliza para crear barras de desplazamiento que permiten al usuario desplazarse hacia arriba y hacia abajo dentro de una ventana. Consiste en un control deslizante móvil, una pista deslizante y dos botones para desplazar el control deslizante hacia arriba o hacia abajo. scroll = QScrollBar()
  • QSplitter : Los Splitters se utilizan para separar el contenido de una ventana para que los widgets estén agrupados correctamente y no aparezcan desordenados. QSplitter es uno de los principales gestores de diseño disponibles en PyQt5 y se utiliza para dividir el contenido tanto horizontal como verticalmente.
  • QDock : Un widget dock es una subventana con dos propiedades:

    • Se puede mover dentro de la ventana principal y
    • Se puede acoplar fuera de la ventana principal a otra ubicación en la pantalla.

Diseños y temas

En los ejemplos anteriores, sólo ha estado usando los métodos move() y resize() para establecer las posiciones de los widgets en su GUI.

Sin embargo, PyQt tiene un robusto motor de gestión de diseño que puede utilizarse para crear interfaces de usuario avanzadas para aplicaciones. En esta sección, aprenderá sobre dos clases importantes que se usan en Qt para crear y administrar diseños.

  1. QBoxLayout
  2. QGridLayout

QBoxLayout

QBoxLayout se utiliza para alinear los widgets hijos del diseño en una fila horizontal o vertical. Las dos clases de interés que heredamos de QBoxLayout son:

  • QHBoxLayout: se usa para alinear los widgets hijos horizontalmente.
  • QVBoxLayout: se usa para alinear los widgets hijos verticalmente.

Por ejemplo, así es como se verán los tres botones alineados con QHBoxLayout.

import sys
de la importación de PyQt5.QtWidgets *
si __nombre__ == «__main__»:
app = QApplication([])
w = QWidget()
w.setWindowTitle(«Mosqueteros»)
btn1 = QPulsador («Athos»)
btn2 = QPulsador(«Porthos»)
btn3 = QPulsador(«Aramis»)
hbox = QHBoxLayout(w)
hbox.addWidget(btn1)
hbox.addWidget(btn2)
hbox.addWidget(btn3)
w.show()
sys.exit(app.exec_())
>

Y así es como se verán en QVBoxLayout.

import sys
de la importación de PyQt5.QtWidgets *
si __nombre__ == «__main__»:
app = QApplication([])
w = QWidget()
w.setWindowTitle(«Mosqueteros»)
btn1 = QPulsador («Athos»)
btn2 = QPulsador(«Porthos»)
btn3 = QPulsador(«Aramis»)
vb = QVBoxLayout(w)
vb.addWidget(btn1)
vb.addWidget(btn2)
vb.addWidget(btn3)
w.show()
sys.exit(app.exec_())
>

La única función que necesita una explicación en este punto es el método addWidget(). Se utiliza para insertar widgets en el diseño de HBox o VBox. También se utiliza en otros layouts donde se toma un número diferente de parámetros, como se verá en la siguiente sección. Los widgets aparecerán dentro de la maqueta en el orden en el que se inserten.

QGridLayout

QGridLayout se utiliza para crear interfaces en las que los widgets se disponen en forma de cuadrícula (como una matriz o un array 2D). Para insertar elementos en un diseño de cuadrícula, puede utilizar la representación de la matriz para definir el número de filas y columnas en la cuadrícula, así como la posición de esos elementos.

Por ejemplo, para crear una cuadrícula de 3*3 (es decir, una cuadrícula con tres filas y tres columnas), escribirá el siguiente código:

Importar sistema
de la importación de PyQt5.QtWidgets *
si __nombre__ == «__main__»:
app = QApplication([])
w = QWidget()
grid = QGridLayout(w)
para i in range(3):
para j en el rango(3):
grid.addWidget(QPulsador(«Botón»),i,j)
w.show()
sys.exit(app.exec_())
>

Este será el resultado:

El método addWidget() en el diseño de la cuadrícula toma estos argumentos:

  • El objeto widget que desea añadir a la cuadrícula
  • La coordenada x del objeto
  • La coordenada y del objeto
  • La extensión de la fila (por defecto =0)
  • El col-span (default=0)

Para entenderlo mejor, puede insertar manualmente cada widget como se muestra a continuación

import sys
de la importación de PyQt5.QtWidgets *
si __nombre__ == «__main__»:
app = QApplication([])
w = QWidget()
grid = QGridLayout(w)
grid.addWidget(QPushButton(«Botón uno»),0,0)
grid.addWidget(QPushButton(«Botón dos»),0,1)
grid.addWidget(QPushButton(«Botón tres»),1,0)
grid.addWidget(QPushButton(«Botón cuatro»),1,1)
w.show()
sys.exit(app.exec_())
>

Así es como se verá la rejilla:

También puede pasar los parámetros rowspan y colspan a addWidget() para poder abarcar más de una fila o columna.

Por ejemplo,

grid.addWidget(QPushButton(«Botón cinco»),2,0,1,0)

Esto creará un botón que se extiende sobre ambas columnas.

Temas

PyQt5 viene con algunos temas incorporados que puedes usar en tus aplicaciones. El método setStyle() llamado en la instancia de QApplication se utiliza para establecer un tema particular para su aplicación.

Por ejemplo, añadir la siguiente línea de código cambiará el tema de su aplicación de predeterminado a Fusion

app.setStyle(«Fusión»)
>

Así es como se verá el ejemplo anterior en Fusion Theme

Otra función útil para darle un tema a tus aplicaciones es el método setPalette(). Aquí está el código para cambiar el color de los diferentes widgets usando setPalette().

import sys
de la importación de PyQt5.QtCore Qt
de la importación de PyQt5.QtWidgets *
desde PyQt5.QtGui importar Qpalette
si __nombre__ == «__main__»:
app = QApplication([])
app.setStyle(«Fusion»)
qp = Qpalette()
qp.setColor(Qpalette.ButtonText, Qt.black)
qp.setColor(Ventana.de.paleta, Qt.negro)
qp.setColor(Botón.de.paleta, Qt.gris)
set.app. paleta(qp)
w = QWidget()
grid = QGridLayout(w)
grid.addWidget(QPushButton(«Botón uno»),0,0)
grid.addWidget(QPushButton(«Botón dos»),0,1)
grid.addWidget(QPushButton(«Botón tres»),1,0)
grid.addWidget(QPushButton(«Botón cuatro»),1,1)
w.show()
sys.exit(app.exec_())
>

Aquí está el resultado.

Para utilizar el método setPalette(), primero debe definir una paleta. Esto se hace creando un objeto de la clase QPalette.

 qp = Qpalette()

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>.

Note que la clase QPalette pertenece al módulo QtGui y necesitará importarla para que esto funcione. Una vez que haya creado el objeto QPalette, utilice el método setColor() para pasar el nombre de un widget cuyo color desea cambiar y el color que desea que se establezca.

Esto cambiará el color de la ventana a negro. Después de haber definido su esquema de colores, utilice la función setPalette() para aplicar la paleta a su aplicación.

Paleta(qp) app.set(qp)

Eso es todo lo que necesitas hacer si quieres crear algunos temas básicos para tu aplicación. PyQt también le permite utilizar hojas de estilo para definir el aspecto de sus widgets. Si estás familiarizado con CSS, puedes definir fácilmente estilos avanzados para tu aplicación usando Qt Style Sheets.

Resumen

  • PyQt es el enlace de python para el marco de trabajo de la interfaz de usuario de C++, Qt.
  • PyQt4 y PyQt5 son las dos versiones principales desarrolladas por Riverbank Computing.
  • Los principales módulos del marco de trabajo de PyQt son:
    1. Qt
    2. QtCore
    3. QtWidgets
    4. QtGui
    5. QtSql
    6. QtNetwork
  • PyQt soporta varios widgets como:
    1. Botones
    2. Etiquetas de texto
    3. Campos de texto
    4. Botones de opción y casillas de verificación
    5. Barras de herramientas y barras de menú
    6. Webkit
    7. Pestañas
    8. Muelles
  • En PyQt, la interactividad se implementa utilizando señales y ranuras .
  • Un evento es una acción realizada por un usuario en la interfaz gráfica de usuario (como hacer clic en un botón).
  • Una señal es levantada por el widget correspondiente cuando ocurre un evento en él.
  • Una ranura es una función que se conecta a la señal y se ejecuta cuando ésta se eleva.
  • PyQt cuenta con un motor de diseño robusto y es compatible con el diseño y la gestión de diseño avanzados. Se trata de dos esquemas de diseño que se utilizan con frecuencia en PyQt:
    1. Disposición de cajas
    2. Disposición de la cuadrícula
  • PyQt le permite crear temas personalizados para aplicaciones GUI y tiene soporte incorporado para hojas de estilo.
  • PyQt puede utilizarse para crear interfaces de usuario y aplicaciones independientes.