Como criar uma GUI Python para gravar dados em um arquivo com PyQt5

Você pode pensar que Python só é bom para aplicativos baseados em texto e desenvolvimento de aplicativos da web, mas nesse aspecto você está errado. Para aqueles que estão interessados ​​em criar aplicativos GUI com Python, algumas bibliotecas e ligações tornam isso possível.

Uma dessas ligações é PyQT5. Da última vez, passei pelo processo de criação de uma GUI básica com esse conjunto de bibliotecas C++ multiplataforma, mas esse aplicativo realmente não fez muito além de Hello, World.

Desta vez, quero demonstrar como usar PyQT5 para criar um aplicativo Python GUI que aceita entrada de um usuário e depois grava essa entrada em um arquivo. Isso pode ser útil quando você deseja aceitar a entrada de um usuário e anexá-la a um arquivo… tudo a partir de uma GUI amigável.

Isso é possível com a ajuda do PyQT5.

Antes de entrarmos nisso, há algumas coisas que queremos revisar. Farei uma rápida recapitulação sobre esses pontos.

• O sublinhado duplo é usado para confundir nomes. O pré-sublinhado duplo instrui o interpretador Python a reescrever o nome do atributo de uma subclasse para evitar conflitos de nomenclatura.
• Temos que importar vários recursos da biblioteca sys
• A biblioteca sys do Python fornece acesso a variáveis ​​e funções que interagem com o interpretador Python e permite que os desenvolvedores manipulem o ambiente de execução e acessem informações específicas do sistema.
• Python permite que você grave em arquivos por meio das funções (w)write e (a)ppend.

Vamos escrever nosso aplicativo. Faremos isso em pequenos pedaços, para que seja mais fácil de entender.

Instalando PyQt5

Antes de podermos fazer qualquer coisa, devemos instalar o PyQT5, caso contrário os módulos não estariam disponíveis para nossa aplicação.

Para instalar o PyQT5, faça login em sua máquina e emita o comando:

pip instalar PyQt5

Quando isso for concluído, você estará pronto para prosseguir.

Importando nossas bibliotecas

A primeira coisa que devemos fazer é importar sys e depois os módulos necessários para nossa GUI.

Importe sys com a linha:

import sys

A seguir, disponibilizamos os módulos sys necessários. Cada um deles vem da biblioteca PyQt5.QtWidgets e inclui o seguinte:

• QAppliation – lida com a inicialização e finalização específicas do widget.
• QWidget – a classe base de todos os objetos da interface do usuário.
• QLabel – fornece uma exibição de texto ou imagem.
• QLineEdit – um editor de texto de uma linha.
• QPushButton – fornece um botão de comando.
• QVBoxLayout – alinha widgets verticalmente.

A linha fica assim:

from PyQt5.QtWidgets import QApplication, QWidget, QLabel, QLineEdit, QPushButton, QVBoxLayout

Até agora, nosso aplicativo inclui:

import sys
from PyQt5.QtWidgets import QApplication, QWidget, QLabel, QLineEdit, QPushButton, QVBoxLayout

Defina nosso widget

A próxima seção define nosso widget e se parece com isto:

class UserInputApp(QWidget):
    def __init__(self):
        super().__init__()
        self.init_ui()

O código acima cria uma nova classe, chamada UserInputApp, que usa a ligação QWidget e inicializa a classe. Em seguida, ele chama o construtor da classe pai e inicializa os elementos da UI com o init_ui método.

Em seguida, definimos o título e a geometria do nosso widget com o seguinte código:

  def init_ui(self):
        self.setWindowTitle('User Input App')
        self.setGeometry(100, 100, 400, 200)

Observação: def __init__(self): é um método Python especial conhecido como método construtor (ou inicializador). É usado para inicializar uma instância de objeto recém-criada de uma classe.

Permitir que a GUI insira texto e salve em um arquivo

Agora configuramos nossa GUI para inserir texto e salvá-lo em um arquivo. Este código é o seguinte:

self.label = QLabel('Enter text:')
        self.text_input = QLineEdit()
        self.save_button = QPushButton('Save to File')
        self.save_button.clicked.connect(self.save_to_file)

        layout = QVBoxLayout()
        layout.addWidget(self.label)
        layout.addWidget(self.text_input)
        layout.addWidget(self.save_button)

        self.setLayout(layout)

    def save_to_file(self):
        text = self.text_input.text()
        with open('user_input.txt', 'a+') as file:
            file.write(text + 'n')
        print('Text saved to file.')

Um pouco sobre o código acima:

• self.label = QLabel(‘Enter text:’): – cria um widget QLabel com o texto ‘Enter text:’.
• self.text_input = QLineEdit(): – cria um widget QLineEdit como um campo de entrada para o usuário inserir texto.
• self.save_button = QPushButton(‘Salvar em arquivo’): – cria um widget QPushButton com o texto ‘Salvar em arquivo’.
• layout = QVBoxLayout(): – cria um objeto QVBoxLayout (um gerenciador de layout vertical usado para organizar widgets verticalmente em uma UI).
• layout.addWidget(self.label): – adiciona o widget de rótulo.
• layout.addWidget(self.text_input): – adiciona o widget text_input.
• layout.addWidget(self.save_button): – adiciona o widget save_button.
• def save_to_file(self): – é responsável por salvar no arquivo o texto digitado pelo usuário no widget text_input, user_input.txt.
• text = self.text_input.text(): – recupera o texto inserido pela variável de texto do usuário.
• com open(‘user_input.txt’, ‘a+’) como arquivo: – abre o user_input.txt arquivo no modo anexar (‘a+’).
• file.write(text + ‘n’): – grava o texto inserido pelo usuário, seguido por um caractere de nova linha, no user_input.txt.
• print(‘Texto salvo no arquivo.’): – imprime uma mensagem no console (janela do terminal) indicando que o texto foi salvo no arquivo.

Inicialize e execute o aplicativo

A seção final do código é semelhante a esta:

if __name__ == '__main__':
    app = QApplication(sys.argv)
    window = UserInputApp()
    window.show()
    sys.exit(app.exec_())

Aqui está o que cada linha faz:

• if __name__ == ‘__main__’: – verifica se o script está sendo executado diretamente como o programa principal em vez de ser importado como um módulo.
• app = QApplication(sys.argv): – inicializa uma instância QApplication.
• window = UserInputApp(): – cria uma instância da classe UserInputApp que representa a janela principal da GUI do nosso aplicativo.
• window.show(): – exibe a janela principal criada na etapa anterior para que fique visível para o usuário.
• sys.exit(app.exec_()): – inicia o loop de eventos do aplicativo PyQt chamando app.exec_() para manter a GUI aberta até que seja fechada pelo usuário.

O código completo

O código completo da nossa aplicação é assim:

import sys
from PyQt5.QtWidgets import QApplication, QWidget, QLabel, QLineEdit, QPushButton, QVBoxLayout

class UserInputApp(QWidget):
    def __init__(self):
        super().__init__()
        self.init_ui()

    def init_ui(self):
        self.setWindowTitle('User Input App')
        self.setGeometry(100, 100, 400, 200)

        self.label = QLabel('Enter text:')
        self.text_input = QLineEdit()
        self.save_button = QPushButton('Save to File')
        self.save_button.clicked.connect(self.save_to_file)

        layout = QVBoxLayout()
        layout.addWidget(self.label)
        layout.addWidget(self.text_input)
        layout.addWidget(self.save_button)

        self.setLayout(layout)

    def save_to_file(self):
        text = self.text_input.text()
        with open('user_input.txt', 'a+') as file:
            file.write(text + 'n')
        print('Text saved to file.')

if __name__ == '__main__':
    app = QApplication(sys.argv)
    window = UserInputApp()
    window.show()
    sys.exit(app.exec_())

Vamos chamar esse aplicativo inputGui.py. Salve o código em um arquivo com esse nome e execute-o com:

python3 inputGui.py

Uma pequena GUI irá aparecer, pedindo ao usuário para inserir algum texto (Figura 1).

figura 1

Nossa GUI Python está em execução.

Depois que o usuário insere o texto, ele clica em Salvar em arquivo e tudo o que digitou será anexado ao arquivo user_input.txt. Continue adicionando novo texto e clicando em Salvar em arquivo e você continuará adicionando texto ao arquivo. Quando terminar, feche a GUI e pronto.

E é assim que você pode criar uma GUI Python com PyQT5 que aceita entrada do usuário e a anexa a um arquivo de texto.

A postagem Como criar uma GUI Python para gravar dados em um arquivo com PyQt5 apareceu pela primeira vez em The New Stack.