Tutorial de PySide6: crea aplicaciones de escritorio con Python

Seamos sinceros: a las personas no técnicas, o a los usuarios finales, no les interesan los Jupyter Notebooks ni los scripts de Python que creas como profesional de datos. Quieren poder interactuar con la solución y ver los resultados por sí mismos.

Por eso necesitamos transformar nuestro trabajo en informes con insights, paneles de control o aplicaciones de ciencia de datos. Mientras que los informes, los dashboards y las aplicaciones web son habituales, una alternativa menos explorada son las aplicaciones de escritorio.

Imagina poder diseñar una app en la que los usuarios hagan clic en botones, rellenen formularios y naveguen por menús, todo desde una interfaz clara y agradable en tu escritorio. ¿A que suena bien?

En este tutorial te presentaremos PySide6, te ayudaremos con las instalaciones iniciales y crearás tu primera aplicación de escritorio. También veremos los widgets más usados, incorporaremos visualizaciones de datos de librerías populares y compartiremos recursos útiles.

¿Qué es PySide6?

PySide6 es un conjunto de herramientas que te permite crear aplicaciones de software con el lenguaje de programación Python y con interfaces gráficas atractivas e intuitivas.

Es como un juego de piezas para software que permite, incluso a quien empieza a programar, combinar elementos visuales e interactivos para dar forma a una app. Con PySide6 puedes convertir tus ideas en aplicaciones reales y funcionales que funcionan en Windows, Mac, Linux e incluso en plataformas móviles.

Configurar PySide6

Para la configuración, suponemos que ya tienes Python instalado y tu IDE habitual. La instalación es bastante directa.

Abre la terminal y ejecuta lo siguiente. Con eso basta.

pip3 install pyside6

Crea tu primera aplicación con PySide6

Ahora que has instalado la librería correctamente, el siguiente paso es crear tu primera aplicación con PySide6. Esto también nos sirve para comprobar que todo funciona bien mientras te haces una idea de cómo son las aplicaciones de escritorio.

Crea un archivo de Python llamado “main.py” y copia y pega el siguiente código.

import sys
from PySide6.QtWidgets import QApplication, QLabel
app = QApplication(sys.argv)
label = QLabel('Hello, PySide6!')
label.show()
sys.exit(app.exec_())

Enseguida entenderemos el código, pero primero ejecuta el archivo de Python desde tu terminal así:

python3 run main.py

¡Enhorabuena, has creado tu primera aplicación de escritorio! Deberías ver algo como esto:

La aplicación de escritorio “Hello, PySide6” (imagen del autor)

Desgranemos ahora el sencillo script de PySide6 que vimos antes. Primero importamos los módulos relevantes:

import sys
from PySide6.QtWidgets import QApplication, QLabel

• sys es un módulo de la librería estándar de Python que da acceso a variables usadas o mantenidas por el intérprete. En el contexto de una aplicación PySide6, se usa habitualmente para los argumentos de la línea de comandos. Consulta nuestro tutorial sobre análisis de argumentos en la línea de comandos para saber más.
• QApplication y QLabel se importan de PySide6.QtWidgets. QApplication es la clase central de gestión de la aplicación en PySide6, necesaria para cualquier GUI. QLabel es un widget que muestra texto, que usamos para enseñar un mensaje sencillo.

A continuación, creamos una instancia de QApplication.

app = QApplication(sys.argv)

Esto es obligatorio en toda aplicación PySide6. sys.argv se usa para pasar argumentos de la línea de comandos a la aplicación. Incluso si no los usas, sys.argv sigue siendo necesario, ya que inicializa QApplication con algunos valores por defecto.

label = QLabel('Hello, PySide6!')

Después, creamos un widget QLabel con el texto "Hello, PySide6!". Este es el texto que se mostrará en la ventana de la aplicación.

label.show()

Esta línea hace visible el label. Por defecto, los widgets en PySide6 no son visibles hasta que los muestras explícitamente.

sys.exit(app.exec_())

Por último, esta línea inicia el bucle de eventos de la aplicación. El método exec_() de QApplication entra en el bucle principal, donde se procesan todos los eventos (como clics y pulsaciones de teclado). La llamada a sys.exit() garantiza una salida limpia cuando se cierra la aplicación. El bucle de eventos se ejecuta hasta que la instancia de QApplication recibe una señal de salida, como cerrar la ventana.

Como vimos en la salida anterior, nuestro script crea una GUI básica con una sola ventana que muestra el texto “Hello, PySide6!”.

Incorporar widgets de PySide6 en la aplicación

Los widgets, en el contexto de PySide6 y las GUIs, son los bloques básicos con los que se construye la interfaz de usuario de una aplicación. Piensa en ellos como los distintos elementos con los que ves e interactúas en cualquier software: botones, cuadros de texto, etiquetas, deslizadores y menús desplegables.

En la primera aplicación con PySide6 vimos un widget de etiqueta usado para mostrar texto. Al construir una GUI con PySide6, básicamente colocamos estos widgets en una ventana de la forma que más sentido tenga para nuestra aplicación. Cada widget cumple una función concreta y se relaciona con el usuario de forma distinta.

La lista completa de widgets y su uso está en la documentación oficial, pero los más comunes son:

• QLabel: Widget para mostrar texto o imágenes. Suele utilizarse para mostrar instrucciones, mensajes o incluso imágenes en una GUI.
• QPushButton: Botón clicable con el que el usuario interactúa para lanzar acciones. Es uno de los widgets más básicos en desarrollo de GUIs, usado para enviar formularios, iniciar procesos, etc.
• QLineEdit: Permite introducir y editar una sola línea de texto. Muy utilizado en formularios y ajustes donde se requiere entrada de texto, como un nombre o un número.
• QComboBox: Combina una lista desplegable y un campo de texto, permitiendo elegir entre opciones predefinidas o escribir una propia.
• QCheckBox: Presenta una casilla que se puede marcar o desmarcar. Suele usarse para activar o desactivar funciones o indicar conformidad con términos y condiciones.
• QRadioButton: Diseñado para seleccionar una opción dentro de un conjunto; en cada grupo solo se puede elegir una, ideal para selecciones exclusivas.
• QTextEdit: Widget para edición de texto multilínea, con más funcionalidades que QLineEdit, como formato, copiar y pegar y desplazamiento.
• QSlider: Proporciona un control deslizante, útil para introducir valores numéricos dentro de un rango, como ajustar el volumen o un filtro de precio.
• QSpinBox: Permite seleccionar un número dentro de un rango dado, aumentando o disminuyendo con flechas arriba y abajo.
• QProgressBar: Muestra el progreso de una tarea representando visualmente el porcentaje de completado; útil para cargas o descargas de archivos.
• QTableWidget: Útil para mostrar datos en formato tabular, organizando filas y columnas para facilitar la visualización e interacción con datos estructurados.

Vamos a crear una aplicación que use estos widgets comunes y los muestre:

import sys
from PySide6.QtWidgets import QApplication, QMainWindow, QLabel, QPushButton, QLineEdit, QComboBox, QCheckBox, QRadioButton, QTextEdit, QSlider, QSpinBox, QProgressBar, QTableWidget, QTableWidgetItem, QVBoxLayout, QHBoxLayout, QWidget

class DemoWindow(QMainWindow):
   def __init__(self):
       super().__init__()

       # Main Widget and Layout
       main_widget = QWidget()
       self.setCentralWidget(main_widget)
       main_layout = QVBoxLayout(main_widget)

       # Function to add widget with label
       def add_widget_with_label(layout, widget, label_text):
           hbox = QHBoxLayout()
           label = QLabel(label_text)
           hbox.addWidget(label)
           hbox.addWidget(widget)
           layout.addLayout(hbox)

       # QLabel
       self.label = QLabel('Hello PySide6!')
       add_widget_with_label(main_layout, self.label, 'QLabel:')

       # QPushButton
       self.button = QPushButton('Click Me')
       self.button.clicked.connect(self.on_button_clicked)
       add_widget_with_label(main_layout, self.button, 'QPushButton:')

       # QLineEdit
       self.line_edit = QLineEdit()
       add_widget_with_label(main_layout, self.line_edit, 'QLineEdit:')

       # QComboBox
       self.combo_box = QComboBox()
       self.combo_box.addItems(['Option 1', 'Option 2', 'Option 3'])
       add_widget_with_label(main_layout, self.combo_box, 'QComboBox:')

       # QCheckBox
       self.check_box = QCheckBox('Check Me')
       add_widget_with_label(main_layout, self.check_box, 'QCheckBox:')

       # QRadioButton
       self.radio_button = QRadioButton('Radio Button')
       add_widget_with_label(main_layout, self.radio_button, 'QRadioButton:')

       # QTextEdit
       self.text_edit = QTextEdit()
       add_widget_with_label(main_layout, self.text_edit, 'QTextEdit:')

       # QSlider
       self.slider = QSlider()
       add_widget_with_label(main_layout, self.slider, 'QSlider:')

       # QSpinBox
       self.spin_box = QSpinBox()
       add_widget_with_label(main_layout, self.spin_box, 'QSpinBox:')

       # QProgressBar
       self.progress_bar = QProgressBar()
       add_widget_with_label(main_layout, self.progress_bar, 'QProgressBar:')

       # QTableWidget
       self.table_widget = QTableWidget(5, 3) 
       for i in range(5):
           for j in range(3):
               item = QTableWidgetItem(f"Cell {i+1},{j+1}")
               self.table_widget.setItem(i, j, item)
       add_widget_with_label(main_layout, self.table_widget, 'QTableWidget:')

   def on_button_clicked(self):
       self.label.setText('Button Clicked!')

# Run the application
app = QApplication(sys.argv)
window = DemoWindow()
window.show()
sys.exit(app.exec_())

La salida es la siguiente:

Aplicación de escritorio con widgets (imagen del autor)

Hemos creado con éxito una aplicación de escritorio que incorpora los widgets más comunes. Para facilitar la comprensión, hemos añadido etiquetas junto a cada widget. Aunque es una aplicación de ejemplo, ahora podemos elegir y usar cualquiera de estos widgets en aplicaciones más complejas.

Una aplicación de visualización de datos con PySide6, Matplotlib y Seaborn

Para crear esta aplicación, primero elegiremos un conjunto de datos popular y crearemos visualizaciones independientes. Este paso se parece al análisis exploratorio del día a día que hacemos en ciencia de datos. Después integraremos estas visualizaciones en una aplicación de escritorio, igual que cuando pasamos de informes y análisis a una app interactiva.

Antes de empezar, asegurémonos de tener todas las librerías necesarias ejecutando este comando en la terminal.

pip3 install matplotlib seaborn

Paso 1: crear visualizaciones independientes sencillas

Aquí cargamos el conocido “iris dataset”, disponible de forma nativa en el paquete de visualización de Python, Seaborn. Usamos este mismo paquete, junto con Matplotlib, para crear las visualizaciones. Para una comprensión completa del trazado con Seaborn, quizá te interese nuestro guía de visualización con Python Seaborn.

import seaborn as sns
import matplotlib.pyplot as plt
# Load the Iris dataset
iris = sns.load_dataset("iris")

Luego, creamos visualizaciones como estas:

plt.figure(figsize=(6, 4))
sns.scatterplot(data=iris, x="sepal_length", y="sepal_width", hue="species")
plt.title("Sepal Length vs Sepal Width")
plt.show()

La primera visualización es un diagrama de dispersión de longitud del sépalo frente a anchura del sépalo, coloreado por especie.

Visualización n.º 1: longitud del sépalo vs. anchura del sépalo (imagen del autor)

La segunda visualización es un histograma de la longitud del pétalo, coloreado por especie.

plt.figure(figsize=(6, 4))
sns.histplot(iris, x="petal_length", hue="species", kde=True)
plt.title("Histogram of Petal Length")
plt.show()

Y obtenemos el siguiente resultado:

Visualización n.º 2: histograma de la longitud del pétalo (imagen del autor)

Por último, tracemos un diagrama de caja que muestre la distribución de la anchura del pétalo según la especie.

plt.figure(figsize=(6, 4))
sns.boxplot(x="species", y="petal_width", data=iris)
plt.title("Box Plot of Petal Width")
plt.show()

La visualización queda así:

Estas gráficas aportan distintas perspectivas sobre el conjunto Iris, mostrando relaciones y distribuciones de varias características según la especie.

Paso 2: integrar las visualizaciones en la aplicación de escritorio

Primero, veamos el código y entendámoslo.

import sys
import seaborn as sns
from PySide6.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QWidget
from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
from matplotlib.figure import Figure

class IrisVisualizer(QMainWindow):
   def __init__(self):
       super().__init__()
       self.setWindowTitle("Iris Dataset Visualizations")
       self.setGeometry(100, 100, 1200, 900)  # x, y, width, height
       self.initUI()

   def initUI(self):
       central_widget = QWidget(self)
       self.setCentralWidget(central_widget)
       layout = QVBoxLayout(central_widget)

       # Adding multiple plots
       self.addScatterPlot(layout)
       self.addHistogram(layout)
       self.addBoxPlot(layout)

   def addPlotCanvas(self, layout, plot_func):
       canvas = FigureCanvas(Figure(figsize=(6, 4)))
       plot_func(canvas.figure)
       layout.addWidget(canvas)

   def addScatterPlot(self, layout):
       def scatter_plot(figure):
           iris = sns.load_dataset("iris")
           ax = figure.add_subplot(111)
           sns.scatterplot(data=iris, x="sepal_length", y="sepal_width", hue="species", ax=ax)
           ax.set_title("Sepal Length vs Sepal Width")

       self.addPlotCanvas(layout, scatter_plot)

   def addHistogram(self, layout):
       def histogram(figure):
           iris = sns.load_dataset("iris")
           ax = figure.add_subplot(111)
           sns.histplot(iris, x="petal_length", hue="species", kde=True, ax=ax)
           ax.set_title("Histogram of Petal Length")

       self.addPlotCanvas(layout, histogram)

   def addBoxPlot(self, layout):
       def box_plot(figure):
           iris = sns.load_dataset("iris")
           ax = figure.add_subplot(111)
           sns.boxplot(x="species", y="petal_width", data=iris, ax=ax)
           ax.set_title("Box Plot of Petal Width")

       self.addPlotCanvas(layout, box_plot)

# Run the application
app = QApplication(sys.argv)
window = IrisVisualizer()
window.show()
sys.exit(app.exec_())

Estructuramos la aplicación alrededor de la clase IrisVisualizer, que extiende QMainWindow de PySide6. Esta clase configura la ventana principal y su layout, actuando como contenedor de nuestras visualizaciones. Cada gráfico se incrusta en la GUI usando FigureCanvasQTAgg de Matplotlib, que permite mostrar figuras de Matplotlib como widgets de PySide6.

La clave de la integración está en el método addPlotCanvas. Este método crea una figura de Matplotlib, dibuja un gráfico sobre ella y la inserta en el layout de la aplicación. Métodos concretos como addScatterPlot, addHistogram y addBoxPlot definen cada gráfico, que antes construimos como visualizaciones independientes. El layout de la ventana principal es un layout vertical (QVBoxLayout) que apila todos los gráficos uno debajo de otro.

Veamos la aplicación final:

Aplicación de escritorio con visualizaciones del dataset Iris (imagen del autor)

¿No te parece más práctico que una gráfica en Jupyter Notebook? Por supuesto, es un ejemplo sencillo, pero una vez entiendas los conceptos para crear estas aplicaciones, podrás convertirlas en un panel de insights completo o en una aplicación de ciencia de datos.

Conclusión

En este tutorial hemos presentado PySide6, una librería de Python que permite a los profesionales de datos crear aplicaciones de escritorio con GUI usando el lenguaje que mejor conocen: Python. Empezamos instalando PySide6 y creando nuestra primera aplicación de escritorio.

Después ampliamos el ejemplo para cubrir los widgets más comunes usados en aplicaciones de escritorio.

Por último, vimos cómo incorporar visualizaciones de librerías populares como Seaborn y Matplotlib directamente en nuestras aplicaciones con PySide6.

Para seguir aprendiendo, te recomendamos consultar la documentación oficial y dar rienda suelta a tu curiosidad creando tus aplicaciones favoritas. O, si lo prefieres, echa un vistazo a nuestro tutorial que crea aplicaciones de escritorio en Python usando una librería alternativa, Tkinter.