Interfaces Gráficas con PyQt6
Crea ventanas, widgets y layouts con PyQt6. Conecta señales y slots, separa UI de lógica, y maneja múltiples ventanas.
article
QApplication y la ventana básica
Las interfaces gráficas usan un modelo event-driven (orientado a eventos): el programa no corre en un loop activo revisando el estado — simplemente espera a que el usuario haga algo (click, tecla, movimiento) y responde.
Esto contrasta con el modelo de polling, donde el programa pregunta constantemente "¿pasó algo?". El event-driven es más eficiente: el proceso duerme y el OS lo despierta cuando hay un evento.
QApplication y QWidget
QApplication(sys.argv)→ gestiona el event loop de toda la aplicación. Debe crearse antes de cualquier widget — sin ella, los widgets fallan al instanciarse.QWidget→ clase base de todos los elementos gráficos en PyQt6. Una subclase deQWidgetpuede ser tanto una ventana independiente como un componente dentro de otra ventana.app.exec()→ inicia el event loop y bloquea hasta que se cierra la aplicación.
Sistema de coordenadas
El origen (0, 0) está en la esquina superior izquierda de la ventana. X crece hacia la derecha y Y crece hacia abajo (distinto a la matemática usual).
python
import sysfrom PyQt6.QtWidgets import QApplication, QWidget class MiVentana(QWidget): def __init__(self): super().__init__() self.setWindowTitle('Mi primera ventana') self.setGeometry(100, 100, 400, 300) # x, y, ancho, alto if __name__ == '__main__': app = QApplication(sys.argv) # SIEMPRE primero ventana = MiVentana() ventana.show() sys.exit(app.exec())Cargando Quiz...
Cargando Quiz...
schema
Widgets básicos y layouts
Widgets de entrada y salida
QLabel→ muestra texto estático o dinámico. También puede mostrar imágenes conQPixmap.QLineEdit→ campo de texto editable de una sola línea.text()retorna el contenido actual.QPushButton→ botón clickeable. Se conecta a funciones mediante señales.
Pasar self al constructor de un widget lo hace hijo de esa ventana: queda visualmente contenido en ella y se destruye cuando la ventana se destruye.
Layouts: organización automática
El posicionamiento absoluto (widget.move(x, y)) fija las coordenadas — si la ventana se redimensiona, los widgets quedan mal ubicados.
Los layouts organizan widgets automáticamente y se adaptan al tamaño:
QHBoxLayout→ organiza widgets en fila (horizontal)QVBoxLayout→ organiza widgets en columna (vertical)QGridLayout→ grilla de filas × columnas;addWidget(w, fila, col)addStretch()→ espacio flexible que empuja los widgets hacia un lado
Para componer layouts complejos se anidan: un QVBoxLayout puede contener QHBoxLayout como ítem.
python
from PyQt6.QtWidgets import (QWidget, QLabel, QLineEdit, QPushButton, QVBoxLayout, QHBoxLayout) class Formulario(QWidget): def __init__(self):hub
Señales y slots
El mecanismo central de PyQt6 es señal-slot:
- Señal: evento emitido por un widget cuando algo sucede (click, cambio de texto, etc.).
- Slot: función (método) que se ejecuta en respuesta a una señal.
Conectar señales
La sintaxis es widget.signal.connect(handler), donde handler se pasa sin paréntesis. Con paréntesis, Python llama la función inmediatamente y conecta su valor de retorno (normalmente None) — error muy común.
python
from PyQt6.QtWidgets import QWidget, QPushButton, QLabel, QVBoxLayout class MiVentana(QWidget): def __init__(self): super().__init__() self.contador = 0 self.etiqueta = QLabel('Clicks: 0') boton = QPushButton('Clickéame') boton.clicked.connect(self.al_clickear) # SIN paréntesisdata_object
Separación front-end / back-end
Un buen diseño de software separa qué se muestra (front-end) de qué se calcula (back-end). En PyQt6 esto se expresa con dos principios:
- Alta cohesión: cada clase tiene una responsabilidad bien definida. La ventana solo gestiona la UI; la lógica de negocio va en clases separadas.
- Bajo acoplamiento: las clases no se conocen directamente — se comunican a través de señales. Esto las hace independientes y fáciles de reemplazar.
Evolución del diseño
- V1 — Monolítico: toda la lógica dentro del QWidget → baja cohesión, difícil de mantener.
- V2 — Módulo separado: backend en módulo aparte, pero el frontend lo importa directamente → alta cohesión, alto acoplamiento.
- V3 — Señales: frontend y backend se comunican solo con señales; el
__main__los conecta → alta cohesión, bajo acoplamiento.
El backend en V3 hereda de QObject (no de QWidget) — esto le permite tener pyqtSignal sin crear una ventana visual.
python
# backend.pyfrom PyQt6.QtCore import QObject, pyqtSignal class Backend(QObject): senal_resultado = pyqtSignal(str) def procesar(self, texto):architecture
Múltiples ventanas
Las aplicaciones reales tienen varias ventanas. Conectarlas correctamente requiere entender cuándo Python elimina objetos de la memoria.
El problema del garbage collector
Si se crea una ventana como variable local dentro de un método, Python la destruye al salir del método — la ventana se cierra inmediatamente o nunca aparece.
python
# MAL: ventana es variable local → se destruye al salir de abrir()def abrir(self): ventana = VentanaSecundaria() ventana.show() # aparece y desaparece al instante # BIEN: guardar referencia como atributo de instanciadef abrir(self): self.ventana = VentanaSecundaria() # 'self' mantiene la referencia viva self.ventana.show()