Creación de aplicaciones de escritorio con Python, Qt y PyQt

Las aplicaciones web son muy populares, pero todavía hay momentos en que solo una aplicación de escritorio puede ofrecer una excelente experiencia de usuario. Por ejemplo, las aplicaciones como Adobe After Effects o Word todavía se usan principalmente en el escritorio para que puedan usar ventanas de diálogo y métodos abreviados de teclado para mejorar el flujo de trabajo del usuario. También hay momentos en que una aplicación tiene que ser muy eficiente en la memoria y necesitará una baja latencia (aplicaciones con uso intensivo de gráficos, por ejemplo).

Una opción popular para desarrollar aplicaciones de escritorio multiplataforma es Electron y JavaScript. Otra opción es Python y PyQt5. PyQt5 es la interfaz que le permite usar la biblioteca Qt basada en C ++ desde Python. Qt es un juego de herramientas de interfaz gráfica de usuario para crear aplicaciones de escritorio. Puede ser menos popular, pero le mostraré cuán efectivo puede ser PyQt5 para producir una aplicación de escritorio. Primero, crearemos una aplicación Hello World antes de crear una aplicación de escritorio más útil para que los desarrolladores independientes calculen sus impuestos y tarifas por hora. Necesitará un poco de codificación de Python para seguir este tutorial.

Instalar PyQt

Puede instalar PyQt instalando Python y usando pip con este comando:

pip install PyQt5

Puede hacer referencia a la documentación para PyQt esta página y si falta parte de la documentación, puede consultar la documentación oficial de la biblioteca Qt esta página.

La documentación anterior cubre los aspectos principales de la interfaz PyQt, mientras que la segunda es para la API basada en C ++ de Qt.

Hola mundo en Python y Qt

Comencemos con un ejemplo simple que muestra "Hola Mundo". Puedes ver el código fuente completo esta página.

Comenzaremos importando los widgets PyQt5 que necesitaremos:

# hello.py
from PyQt5.QtWidgets import QApplication, QMainWindow, QLabel, QGridLayout, QWidget

Los widgets son los objetos que se dibujan en la pantalla como parte de la interfaz gráfica de usuario en Qt. También se conocen como componentes en otros marcos.

Configurar la aplicación y la ventana

A continuación, configuremos la aplicación, la ventana y el diseño de la ventana:

app = QApplication([])
window = QMainWindow()
widget = QWidget(window)
layout = QGridLayout()
widget.setLayout(layout)

Para hacer un diseño en Qt, debe utilizar un objeto genérico QWidget porque la ventana mostrará un widget a la vez. Hay otros tipos de diseño que se pueden usar, como VBoxLayout para diseñar widgets en una dirección vertical, o puede usar un HBoxLayout para un diseño horizontal.

Estamos utilizando un diseño de cuadrícula donde cada widget agregado al diseño se puede colocar con precisión en una fila y columna en particular, y puede abarcar varias filas o columnas. Si estuviera usando Electron o haciendo una aplicación web, usaría algo como el framework CSS Bootstrap o CSS Flexbox para hacer un diseño de cuadrícula. Con Qt, está integrado y es mucho más fácil de hacer.

Ahora, creemos el "¡Hola mundo!" etiqueta:

label = QLabel()
label.setText('Hello world!')

Luego lo agregaremos a la primera fila y columna:

layout.addWidget(label, 0, 0)

Inicio del bucle de eventos Qt

Después de eso, vamos a establecer el widget de ventana en el widget de diseño, mostrar la ventana e iniciar el ciclo de eventos Qt que iniciará la aplicación:

window.setCentralWidget(widget)
window.show()
app.exec_()

Así es como se verá:

Crear una aplicación de utilidad independiente

Ahora que hemos practicado con una sencilla aplicación Hello World, creemos una aplicación de escritorio para desarrolladores independientes. La ventana mostrará una tabla de ganancias semanales y permitirá que el profesional independiente calcule en qué categoría impositiva marginal se encuentra utilizando un cuadro de diálogo.

Puedes ver el código fuente completo de esta aplicación esta página.

Comencemos con algunas de las estructuras que utilizamos en la aplicación Hello World:

# freelancer.py
from PyQt5.QtWidgets import QApplication, QMainWindow, QLabel, QGridLayout, QWidget, QPushButton, QTableWidget, QTableWidgetItem, QInputDialog app = QApplication([])
window = QMainWindow() screen = QWidget()
layout = QGridLayout()
screen.setLayout(layout)

Estamos importando todos los widgets Qt que necesitamos y configurando la aplicación y la ventana. También usaremos el diseño de cuadrícula nuevamente. Este es un buen valor predeterminado, pero para aplicaciones de escritorio más complejas, querrá evaluar los otros diseños que son posibles con Qt.

Después de crear todos los widgets, tendremos este código en la parte inferior del archivo:

window.setCentralWidget(screen)
window.setWindowTitle('Freelancer Utility')
window.setMinimumSize(500, 200)
window.show() app.exec_()

Esto establecerá el screen widget como el que se muestra, el título y el tamaño de la ventana, y mostrarlo. los app.exec_ inicia el bucle de eventos Qt.

Abrir un cuadro de diálogo para entrada

Necesitamos algo para mostrar en la pantalla, así que comencemos con algo básico: dos etiquetas que muestran el ingreso anual del profesional independiente y la tasa impositiva marginal máxima que deben estar preparados para la próxima temporada de impuestos:

yearly_income = QLabel()
yearly_income.setText('Yearly Income: $0.00')
layout.addWidget(yearly_income, 0, 0) tax_rate = QLabel()
tax_rate.setText('Highest Marginal Tax Rate: 0%')
layout.addWidget(tax_rate, 0, 1)

Estamos utilizando el widget QLabel para esto y formateando el texto de una manera particular, antes de agregar cada widget al diseño de la cuadrícula. Ambas etiquetas están en la misma fila, 0. La etiqueta de ingreso anual está en la primera columna con la etiqueta de tasa de impuestos está en la segunda columna.

Crear un botón y abrir un QInputDialog

Agreguemos un botón de "calculadora":

button = QPushButton()
button.setText('Calculator')

Necesitamos definir la devolución de llamada que se llamará cuando se presione este botón:

def open_calculator(): value, ok = QInputDialog.getDouble( window, # parent widget 'Tax Calculator', # window title 'Yearly Income:', # entry label min=0.0, max=1000000.0, ) if not ok: return yearly_income.setText('Yearly Income: ${:,.2f}'.format(value)) if value <= 9700: rate = 10.0 elif value <= 39475: rate = 12.0 elif value <= 84200: rate = 22.0 elif value <= 160725: rate = 24.0 elif value <= 204100: rate = 32.0 tax_rate.setText('Highest Marginal Tax Rate: {}%'.format(rate))

Lo primero a tener en cuenta es que obtenemos dos valores que tendremos que desempaquetar después de llamar QInputDialog.getDouble. El primer valor es el valor real ingresado por el usuario, el segundo valor es si el usuario presionó o no el botón "ok". Proporcionamos un valor mínimo y máximo para restringir el valor.

Observe que estamos actualizando las dos etiquetas en la pantalla con valores actualizados desde el diálogo de entrada. QInputDialog tiene múltiples métodos estáticos para solicitar tipos particulares de valores al usuario. Estamos usando getDouble aquí, pero también podríamos usar getInt para obtener un número entero, o getText para una cuerda

A continuación, conectemos esta devolución de llamada al botón y colóquelo en el diseño:

button.clicked.connect(open_calculator)
layout.addWidget(button, 1, 0, 1, 2)

Va a estar en la segunda fila (recuerde que las filas y columnas están basadas en 0), y abarcará dos columnas.

Así es como se verá:

Mostrar una tabla de datos

Ahora mostraremos una tabla de las horas trabajadas por el usuario independiente y cuánto han facturado por ese trabajo.

Comenzamos definiendo las columnas de la tabla:

columns = ('Week', 'Hours Worked', 'Hourly Rate', 'Earned Income')

Utilizaremos datos de marcador de posición:

table_data = [ [7, 40.0, 100.0], [8, 37.5, 85.0], [9, 65, 150.0],
]

Configurando el QTableWidget

Estamos usando el QTableWidget para crear la tabla Comencemos estableciendo el número de columnas que se mostrarán y sus etiquetas:

table = QTableWidget()
table.setColumnCount(len(columns))
table.setHorizontalHeaderLabels(columns)

Luego estableceremos el número de filas que se mostrarán. Esto coincidirá con el número de filas que tenemos en table_data:

table.setRowCount(len(table_data))

Uso de QTableWidgetItem para mostrar datos en la tabla

Ahora, estableceremos los valores de cada fila a partir de table_data. Recorreremos los valores de cada columna, crearemos un QTableWidgetItem, y almacenar en la celda de la tabla exacta donde debe estar. También calcularemos la suma y la almacenaremos en la última columna de la fila:

for row_index, row in enumerate(table_data): # Set each column value in the table for column_index, value in enumerate(row): item = QTableWidgetItem(str(value)) table.setItem(row_index, column_index, item) # Calculate the total and add it as another column table.setItem(row_index, 3, QTableWidgetItem(str(row[1] * row[2])))

Agreguemos la tabla al diseño en la tercera fila, que abarca dos columnas:

layout.addWidget(table, 2, 0, 1, 2)

No olvides que tenemos app.exec_ y otro código al final del archivo para mostrar la ventana.

Así es como se verá:

Conclusión

Y así es como se crea una aplicación de escritorio utilizando Python y PyQt5, respaldada por el impresionante marco de la interfaz gráfica de usuario Qt5. En lugar de escribir JavaScript para Electron o C ++ con Qt, puede usar Python y Qt para crear su próxima aplicación de escritorio para Windows, Mac OS X o Linux. Deja un comentario si lo pruebas, me encantaría saber lo que piensas.

Recursos

• Encuentra el código fuente completo de este tutorial esta página

• Encuentra la documentación de PyQt esta página

• Se pueden encontrar más instrucciones de configuración e instalación para PyQt esta página

Aprenda Python construyendo proyectos con Proyectos de desarrollo

Fuente: https://www.codementor.io/blog/desktop-app-pyqt-8jwfnotu1y