Tutorial de PySide6: como criar aplicativos de GUI com Python

Vamos encarar a realidade: as partes interessadas não técnicas, ou os usuários finais, não têm interesse nos Jupyter Notebooks ou nos scripts em Python que você cria como profissional de dados. Eles querem interagir com a solução e ver os resultados por conta própria.

É por isso que precisamos transformar nosso trabalho em relatórios de insights, dashboards ou aplicativos de data science. Enquanto relatórios, dashboards e aplicações web são comuns, uma alternativa menos explorada são os aplicativos desktop.

Imagine poder desenhar um app em que os usuários clicam em botões, preenchem formulários e navegam por menus — tudo em uma interface clara e agradável no seu desktop. Que massa seria isso?

Neste tutorial, vamos apresentar o PySide6, ajudar você com as instalações iniciais e construir seu primeiro aplicativo desktop. Também vamos explorar os widgets mais usados, incorporar visualizações de dados de bibliotecas populares de ciência de dados e compartilhar recursos úteis.

O que é PySide6?

PySide6 é um toolkit que permite criar aplicativos de software em Python com interfaces gráficas atraentes e intuitivas.

É como um conjunto de blocos de montar para software, permitindo até a quem está começando em programação juntar os elementos visuais e interativos que compõem um app. Com PySide6, você transforma ideias em aplicativos reais e funcionais que rodam em Windows, Mac, Linux e até em plataformas móveis.

Configurando o PySide6

Para a configuração, vamos assumir que você já tem o Python instalado e seu IDE de preferência. A instalação é bem direta.

Abra o terminal e rode o comando abaixo — pronto.

pip3 install pyside6

Construindo seu primeiro aplicativo PySide6

Agora que você instalou a biblioteca com sucesso, o próximo passo é criar seu primeiro aplicativo com PySide6. Isso também serve para testarmos se a configuração está ok enquanto você tem um gostinho do que é um app desktop.

Crie um arquivo Python chamado "main.py" e copie o código a seguir.

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

Vamos entender o código em um minuto, mas antes rode o arquivo Python pelo terminal assim:

python3 run main.py

Parabéns, você construiu seu primeiro aplicativo desktop! Você deve ver algo assim:

O aplicativo desktop “Hello, PySide6” (imagem do autor)

Agora vamos dissecar o script simples em PySide6 que vimos. Primeiro, importamos os módulos relevantes:

import sys
from PySide6.QtWidgets import QApplication, QLabel

• sys é um módulo da biblioteca padrão do Python que dá acesso a variáveis usadas ou mantidas pelo interpretador Python. No contexto de um app PySide6, é comumente usado para argumentos de linha de comando. Confira nosso tutorial de parsing de argumentos na linha de comando para saber mais.
• QApplication e QLabel são importados de PySide6.QtWidgets. QApplication é a classe central de gerenciamento do aplicativo em PySide6, necessária para qualquer app de GUI. QLabel é um widget que exibe texto, que usamos para mostrar uma mensagem simples.

Em seguida, criamos uma instância de QApplication.

app = QApplication(sys.argv)

Isso é obrigatório em todo app PySide6. sys.argv é usado para passar argumentos de linha de comando para o app. Mesmo que você não use argumentos, sys.argv ainda é necessário, pois inicializa a QApplication com alguns padrões.

label = QLabel('Hello, PySide6!')

Depois, criamos um widget QLabel com o texto "Hello, PySide6!". Esse é o texto exibido na janela do aplicativo.

label.show()

Esta linha torna o label visível. Por padrão, widgets em PySide6 não ficam visíveis até você chamá-los explicitamente.

sys.exit(app.exec_())

Por fim, esta linha inicia o loop de eventos do aplicativo. O método exec_() de QApplication entra no loop principal do app, onde todos os eventos (como cliques do mouse e teclas pressionadas) são processados. A chamada sys.exit() garante uma saída limpa quando o app é fechado. O loop de eventos roda até a instância de QApplication receber um sinal de saída, como fechar a janela.

Como vimos no resultado anterior, nosso script cria um app GUI básico com uma única janela exibindo o texto “Hello, PySide6!”.

Incorporando widgets do PySide6 no aplicativo GUI

Widgets, no contexto de PySide6 e GUIs, são os blocos básicos usados para criar a interface de usuário de um aplicativo. Pense nos widgets como os vários elementos com que você vê e interage em qualquer software — como botões, caixas de texto, rótulos, sliders e menus suspensos.

No primeiro app em PySide6, vimos um widget de label usado para exibir texto. Ao construir uma GUI com PySide6, essencialmente organizamos esses widgets em uma janela de um jeito que faça sentido para o app. Cada widget tem um propósito específico e interage com o usuário de forma diferente.

A lista completa de widgets e seus usos está na documentação oficial, mas os mais comuns são:

• QLabel: widget usado para exibir texto ou imagens. É muito utilizado para mostrar instruções, mensagens ou até imagens em uma GUI.
• QPushButton: botão clicável com o qual o usuário interage para disparar ações. É um dos widgets mais fundamentais no desenvolvimento de GUIs, usado para enviar formulários, iniciar processos e muito mais.
• QLineEdit: permite ao usuário digitar e editar uma única linha de texto. É comum em formulários e configurações que exigem entrada de texto, como nome ou número.
• QComboBox: combinação de uma lista suspensa com um campo de texto, permitindo escolher uma opção de uma lista predefinida ou digitar a sua.
• QCheckBox: apresenta uma caixa que o usuário pode marcar ou desmarcar. Geralmente é usada para ativar/desativar recursos ou indicar concordância com termos e condições.
• QRadioButton: projetado para selecionar uma opção dentre um conjunto; permite apenas uma escolha dentro do grupo, ideal para opções exclusivas.
• QTextEdit: widget para edição de texto multilinha, oferecendo mais recursos que o QLineEdit, como formatação, copiar e colar e rolagem.
• QSlider: fornece um controle deslizante, útil para inserir valores numéricos dentro de um intervalo, como ajustar volume ou um filtro de preço.
• QSpinBox: permite selecionar um número em um intervalo; o usuário aumenta ou diminui usando setas para cima/baixo.
• QProgressBar: exibe o progresso de uma tarefa. Representa visualmente a porcentagem de conclusão, útil para uploads, downloads e processos em geral.
• QTableWidget: útil para exibir dados em formato tabular. Organiza dados em linhas e colunas, facilitando a visualização e a interação com dados estruturados.

Vamos criar um aplicativo que usa esses widgets comuns e os exibe:

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_())

A saída é a seguinte:

O aplicativo desktop com widgets (imagem do autor)

Criamos com sucesso um app desktop que incorpora os widgets mais comuns. Para facilitar o entendimento, adicionamos rótulos ao lado de cada widget. Embora este seja um app de exemplo, agora podemos escolher e usar um desses widgets populares em aplicações mais complexas.

Um aplicativo de visualização de dados com PySide6, Matplotlib e Seaborn

Para criar este app, primeiro vamos escolher um conjunto de dados popular e criar visualizações independentes. Esta etapa lembra a análise exploratória do dia a dia que fazemos em data science. Depois, vamos empacotar essas visualizações em um aplicativo desktop — assim como transformar relatórios e análises em uma aplicação interativa.

Antes de começar, vamos garantir que temos todas as bibliotecas necessárias rodando o comando abaixo no terminal.

pip3 install matplotlib seaborn

Passo 1: criando visualizações simples e independentes

Aqui, carregamos o famoso “iris dataset”, disponível nativamente no pacote de visualização em Python — Seaborn. Usamos o próprio Seaborn, junto com Matplotlib, para criar as visualizações. Para um entendimento completo sobre gráficos com Seaborn, confira nosso guia de visualização com Seaborn em Python.

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

Em seguida, criamos as visualizações assim:

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()

A primeira visualização é um diagrama de dispersão de comprimento da sépala vs. largura da sépala, colorido por espécie.

Visualização #1: comprimento da sépala vs. largura da sépala (imagem do autor)

A segunda visualização é um histograma do comprimento da pétala, colorido por espécie.

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

E vemos o resultado assim:

Visualização #2: histograma do comprimento da pétala (imagem do autor)

Por fim, vamos traçar um boxplot mostrando a distribuição da largura da pétala entre as diferentes espécies.

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

A visualização fica assim:

Esses gráficos trazem diferentes insights sobre o dataset Iris, mostrando relações e distribuições de várias variáveis entre as espécies.

Passo 2: integrando as visualizações ao aplicativo desktop

Primeiro, vamos ver o código e entender.

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_())

Estruturamos o aplicativo em torno da classe IrisVisualizer, que estende o QMainWindow do PySide6. Essa classe configura a janela principal e seu layout, funcionando como um contêiner para as visualizações. Cada gráfico é incorporado à GUI usando FigureCanvasQTAgg do Matplotlib, que permite exibir figuras do Matplotlib como widgets PySide6.

O segredo da integração está no método addPlotCanvas. Ele cria uma figura do Matplotlib, renderiza um gráfico nela e então incorpora essa figura ao layout do app. Métodos específicos como addScatterPlot, addHistogram e addBoxPlot definem os gráficos individuais — os mesmos que criamos de forma independente antes. O layout da janela principal é um layout vertical (QVBoxLayout), que empilha todos os gráficos um abaixo do outro.

Veja o aplicativo final:

Aplicativo desktop com visualizações do dataset Iris (imagem do autor)

Este app não é melhor do que um gráfico no Jupyter Notebook? Claro, é um exemplo simples, mas depois que entendemos os conceitos por trás da criação desses aplicativos, dá para evoluir para um dashboard completo de insights ou até um app de data science.

Conclusão

Este tutorial apresentou o PySide6, uma biblioteca Python que permite a profissionais de dados criarem aplicativos desktop com GUI usando a linguagem mais familiar — Python. Começamos instalando o PySide6 e criando nosso primeiro aplicativo desktop.

Depois, ampliamos para cobrir os widgets mais comuns usados em aplicativos desktop.

Por fim, vimos como incorporar visualizações de bibliotecas populares como Seaborn e Matplotlib diretamente nos nossos apps PySide6.

Para continuar aprendendo, recomendamos consultar a documentação oficial e seguir sua curiosidade para criar seus aplicativos favoritos. Se preferir, confira também nosso tutorial que cria aplicativos desktop em Python usando uma biblioteca alternativa, o Tkinter.