home Tecnología de fabricación Equipo de fabricación
Manufactura industrial
Internet industrial de las cosas | Materiales industriales | Mantenimiento y reparación de equipos | Programación industrial |
home  MfgRobots >> Manufactura industrial >  >> Industrial programming >> python

Tutorial de PyQt5 con ejemplos:Diseño de GUI usando PyQt en Python

¿Qué es PyQt?

PyQt es un enlace de python del widget-toolkit de código abierto Qt, que también funciona como un marco de desarrollo de aplicaciones multiplataforma. Qt es un marco C++ popular para escribir aplicaciones GUI para las principales plataformas integradas, móviles y de escritorio (compatible con Linux, Windows, MacOS, Android, iOS, Raspberry Pi y más).

PyQt es un software gratuito desarrollado y mantenido por Riverbank Computing, una empresa con sede en Inglaterra, mientras que Qt es desarrollado por una empresa finlandesa llamada The Qt Company.

En este tutorial de PyQt5, aprenderá:

Características de PyQT

Estas son características importantes de PyQt:

Aprenda PyQt, que consta de más de seiscientas clases que cubren una variedad de características como

Estas funciones se pueden combinar para crear interfaces de usuario avanzadas y aplicaciones independientes. Muchas de las principales empresas de todas las industrias utilizan Qt. Algunos ejemplos son LG, Mercedes, AMD, Panasonic, Harman, etc.

Versiones de PyQt

PyQt está disponible en dos ediciones, PyQt4 y PyQt5. PyQt4 proporciona un código de enlace para vincular las versiones 4.x y 5.x del marco Qt, mientras que PyQt5 proporciona un enlace solo para las versiones 5.x. Como resultado, PyQt5 no es compatible con los módulos obsoletos de la versión anterior. En este tutorial de Qt GUI, PyQt5 se usará para la demostración de ejemplos. Además de estas dos versiones,

Riverbank Computing también proporciona PyQt3D, los enlaces de Python para el marco Qt3D. Qt3D es un marco de aplicación utilizado para crear sistemas de simulación en tiempo real con renderizado 2D/3D.

Cómo instalar PyQt5

En este tutorial de PyQt5, veremos las dos formas de instalar PyQt:

Qt (pronunciado lindo) es un sistema complejo, y el código base de PyQt contiene código compilado de C++ y Python bajo el capó. Como resultado, es un proceso complicado construirlo e instalarlo desde la fuente en comparación con otras bibliotecas de Python. Sin embargo, puede instalar fácilmente PyQt5 usando ruedas.

Instalación con ruedas

Las ruedas son el nuevo formato estándar de empaquetado y distribución de Python. Simplemente hablando, una rueda es un archivo ZIP con un nombre especial y .whl extensión de archivo. Wheels se puede instalar usando pip (administrador de paquetes de Python), que se incluye de manera predeterminada en las versiones recientes de Python.

Entonces, si tiene instalado Python 3.4 o posterior, ya tiene pip. Sin embargo, si está utilizando una versión anterior de Python, debe descargar e instalar pip antes de continuar. Puede buscar instrucciones para eso en este enlace:https://pypi.org/project/pip/.

Para instalar PyQt5,

Paso 1) Abra el símbolo del sistema.
Abra el símbolo del sistema o PowerShell en su máquina con Windows.

Paso 2) Escribe lo siguiente.

 pip install PyQt5

Paso 3) Instalación exitosa.
Este paso en este tutorial de PyQt5 descargará el paquete whl de PyQt5 (alrededor de 50 MB) y lo instalará en su sistema.

Alternativamente, también puede descargar un binario de Windows para la versión de python instalada en su computadora.

Una vez que esté completo, continúe con la siguiente sección de este tutorial de PyQt5 para escribir su primera aplicación GUI.

Conceptos y programas básicos de PyQt

Ahora que ha instalado correctamente PyQt5 en su computadora, está listo para escribir aplicaciones de diseño de GUI de Python.

Comencemos con una aplicación simple en este tutorial de PyQt5 que mostrará una ventana vacía en su pantalla.

Inicie su python IDLE y escriba lo siguiente:

Programa 1 

import sys
from PyQt5.QtWidgets import QApplication, QWidget
if __name__ == "__main__":
    app = QApplication(sys.argv)
    w = QWidget()
    w.resize(300,300)
    w.setWindowTitle("Guru99")
    w.show()
    sys.exit(app.exec_())

Guárdelo como app.py (el nombre no importa) y presione F5 para ejecutar el programa. Alternativamente, simplemente haga doble clic en su archivo guardado para iniciar la aplicación. Si ha hecho todo bien, se abrirá una nueva ventana con el título Guru99 como se muestra a continuación.

¡Excelente! Esta funcionando. No es mucho, pero es suficiente para comprender los conceptos básicos. Ahora, en este tutorial de PyQt, veamos en detalle qué hace cada una de las líneas de su programa.

from PyQt5.QtWidgets import QApplication, QWidget

Esta declaración importa todos los módulos que necesita para crear una GUI en el espacio de nombres actual. El módulo QtWidgets contiene todos los widgets principales que utilizará en este tutorial de Python Qt.

app = QApplication(sys.argv)

Aquí, está creando un objeto de la clase QApplication. Este paso es una necesidad para PyQt5; cada aplicación de interfaz de usuario debe crear una instancia de QApplication, como una especie de punto de entrada a la aplicación. Si no lo crea, se mostrarán errores.

sys.argv es la lista de parámetros de la línea de comandos que puede pasar a la aplicación al iniciarla a través del shell o al automatizar la interfaz.

En este ejemplo de PyQt5, no pasó ningún argumento a QApplications. Por lo tanto, también puede reemplazarlo con el siguiente código y ni siquiera tener que importar el módulo sys.

app = QApplication([])
w = QWidget()

A continuación, creamos un objeto de la clase QWidget. QWidget es la clase base de todos los objetos de la interfaz de usuario en Qt, y prácticamente todo lo que ve en una aplicación es un widget. Eso incluye diálogos, textos, botones, barras, etc. La función que le permite diseñar interfaces de usuario complejas es que los widgets se pueden anidar, es decir, puede tener un widget dentro de un widget, que está dentro de otro widget más. Verá esto en acción en la siguiente sección.

w.resize(300,300)

El método de cambio de tamaño de la clase QWidget le permite establecer las dimensiones de cualquier widget. En este caso, ha cambiado el tamaño de la ventana a 300 px por 300 px.

Aquí, debe recordar que los widgets se pueden anidar juntos, el widget más externo (es decir, el widget sin padre) se llama Ventana.

w.setWindowTitle("Guru99")

El método setWindowTitle() le permite pasar una cadena como argumento que establecerá el título de la ventana en la cadena que pase. En el ejemplo de PyQt5, la barra de título mostrará Guru99.

w.show()

show() simplemente muestra el widget en la pantalla del monitor.

sys.exit(app.exec_())

El método app.exec_() inicia el ciclo de eventos de Qt/C++. Como sabe, PyQt está escrito en gran parte en C++ y utiliza el mecanismo de bucle de eventos para implementar la ejecución en paralelo. app.exec_() pasa el control a Qt, que saldrá de la aplicación solo cuando el usuario la cierre desde la GUI. Es por eso que ctrl+c no saldrá de la aplicación como en otros programas de python. Dado que Qt tiene control sobre la aplicación, los eventos de Python no se procesan a menos que los configuremos dentro de la aplicación. Además, tenga en cuenta que el método exec tiene un guión bajo en su nombre; esto se debe a que exec() ya era una palabra clave en python y el guión bajo resuelve el conflicto de nombres.

Más allá de las ventanas vacías

En la sección anterior, viste cómo hacer un widget básico en Qt. Ahora es el momento de crear algunas interfaces más complejas con las que los usuarios puedan interactuar de verdad. De nuevo, enciende tu IDLE y escribe lo siguiente.

import sys
from PyQt5.QtWidgets import QApplication, QWidget, QLabel, QPushButton, QMessageBox

def dialog():
    mbox = QMessageBox()

    mbox.setText("Your allegiance has been noted")
    mbox.setDetailedText("You are now a disciple and subject of the all-knowing Guru")
    mbox.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)
            
    mbox.exec_()

if __name__ == "__main__":
    app = QApplication(sys.argv)
    w = QWidget()
    w.resize(300,300)
    w.setWindowTitle("Guru99")
    
    label = QLabel(w)
    label.setText("Behold the Guru, Guru99")
    label.move(100,130)
    label.show()

    btn = QPushButton(w)
    btn.setText('Beheld')
    btn.move(110,150)
    btn.show()
    btn.clicked.connect(dialog)

    
    w.show()
    sys.exit(app.exec_())

Guarde el archivo como appone.py o lo que desee y presione F5 para ejecutar el programa. Si no ha cometido ningún error, IDLE abrirá una nueva ventana con texto y un botón como se muestra a continuación.

  1. Una vez que haga clic en el botón en la primera ventana, se abrirá un nuevo cuadro de mensaje con el texto que había escrito.
  2. Ahora puede hacer clic en el botón Ocultar detalles/Mostrar detalles para alternar la visibilidad del texto adicional.

Como puede ver, dado que no habíamos establecido ningún título de ventana en el cuadro de mensaje, python proporcionó un título predeterminado.

Ahora que está funcionando, echemos un vistazo al código adicional que agregó al ejemplo anterior de PyQt5.

from PyQt5.QtWidgets import QApplication, QWidget, QLabel, QPushButton, QMessageBox

Esto importa algunos widgets más que ha usado en los ejemplos de PyQt5, a saber, QLabel, QPushButton y QMessageBox.

def dialog():
    mbox = QMessageBox()

    mbox.setText("Your allegiance has been noted")
    mbox.setDetailedText("You are now a disciple and subject of the all-knowing Guru")
    mbox.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)
            
    mbox.exec_()

Aquí, ha definido un método llamado diálogo que crea un widget de cuadro de mensaje y establece algo de texto en los botones y otros campos.

El método de diálogo se llama desde el bloque principal del programa cuando se presiona un botón en un widget específico (en este caso, el botón pulsador btn). El evento de clic activado en ese botón hace que se ejecute esta función. Esta función se denomina ranura en Qt y aprenderá más sobre las señales. y ranuras en los próximos párrafos.

if __name__ == "__main__":
    app = QApplication(sys.argv)
    w = QWidget()
    w.resize(300,300)
    w.setWindowTitle("Guru99")

Esta es la sección principal de la aplicación y, como en el ejemplo anterior, comienza creando una instancia de QApplication seguida de un widget simple, es decir, una instancia de QWidget.

label = QLabel(w)
    btn = QPushButton(w)

Ha agregado dos nuevos widgets en esta aplicación:QLabel y QPushButton. QLabel se usa para imprimir texto no editable o marcadores de posición dentro de un widget, mientras que QPushButton se usa para crear un botón en el que se puede hacer clic.

Lo más importante a tener en cuenta aquí es que cuando crea los objetos label y btn, está pasando el objeto de ventana (w) a los constructores de QLabel y QPushButton. Así es como funciona el anidamiento en PyQt5. Para crear un widget dentro de otro widget, pasa la referencia del widget padre al constructor del hijo.

label.move(100,130)
btn.move(110,150)

move() se usa para establecer la posición de un widget con respecto a su widget principal. En el primer caso, la etiqueta se moverá 100 píxeles desde la izquierda y 130 píxeles desde la parte superior de la ventana.

Del mismo modo, el botón se colocará a 110 px de la izquierda y a 150 px de la parte superior de la ventana. Este ejemplo es una forma cruda de lograr diseños y generalmente no se usa en producción; solo se incluye aquí con fines de aprendizaje. Qt admite diferentes diseños que verá en detalle en las próximas secciones de este tutorial de PyQt.

btn.clicked.connect(dialog)

Finalmente, este es un ejemplo de señales y ranuras en Qt. En las aplicaciones basadas en GUI, las funciones se ejecutan en función de las acciones realizadas por el usuario, como pasar el cursor sobre un elemento o hacer clic en un botón. Estas acciones se llaman eventos . Recuerde que el método app.exec_() transfiere el control al Qt event- círculo. Para esto está el bucle de eventos:para escuchar eventos y realizar acciones en respuesta.

Cada vez que ocurre un evento, como que un usuario haga clic en un botón, el widget Qt correspondiente genera una señal. . Estas señales se pueden conectar a funciones de Python (como la función de diálogo en este ejemplo) para que la función se ejecute cuando se active una señal. Estas funciones se denominan ranuras en Qt jerga.

Posteriormente, la sintaxis básica para activar una función de ranura en respuesta a la señal de un evento es la siguiente

 widget.signal.connect(slot)

Lo que significa que cada vez que una señal es activado por un widget , la ranura conectada se ejecutará la función. En resumen, Qt utiliza señales y ranuras para comunicarse entre objetos y facilitar la reutilización e interactividad de los componentes.

Ahora que sabe cómo anidar widgets e implementar interacciones usando señales y ranuras, aquí hay una lista de widgets útiles y otras clases que puede usar en sus aplicaciones PyQt.

Componentes y widgets

Hay una gran cantidad de widgets disponibles en PyQt para crear aplicaciones GUI. Sin embargo, con PyQt5, ha habido una reorganización de clases en diferentes módulos y revisiones en las licencias.

Por lo tanto, es crucial tener una vista de alto nivel de la estructura de PyQt5. En esta sección, verá cómo PyQt5 está organizado internamente y conocerá los diferentes módulos, bibliotecas y clases de API proporcionados por PyQt5.

Estructura de directorio PyQt5

Estos son los módulos fundamentales utilizados por el enlace Qt de Python, específicamente PyQt5.

Aparatos de PyQt5

Aquí hay una lista de los widgets más utilizados en PyQt5

Diseños y temas

En los ejemplos anteriores de PyQt5, solo has estado usando los métodos move() y resize() para establecer las posiciones de los widgets en tu GUI.

Sin embargo, PyQt tiene un motor de gestión de diseño sólido que se puede utilizar para crear interfaces de usuario avanzadas para aplicaciones. En esta sección, aprenderá sobre dos clases importantes que se usan en Qt para crear y administrar diseños.

  1. QBoxLayout
  2. QGridLayout

Diseño de QBox

QBoxLayout se usa para alinear los widgets secundarios del diseño en una fila horizontal o vertical. Las dos clases de interés que heredan de QBoxLayout son:

Por ejemplo, así es como se verán tres botones alineados con QHBoxLayout.

import sys
from PyQt5.QtWidgets import *

if __name__ == "__main__":

    app = QApplication([])
    w = QWidget()
    w.setWindowTitle("Musketeers")

    btn1 = QPushButton("Athos")
    btn2 = QPushButton("Porthos")
    btn3 = QPushButton("Aramis")

    hbox = QHBoxLayout(w)

    hbox.addWidget(btn1)
    hbox.addWidget(btn2)
    hbox.addWidget(btn3)

    w.show()

    sys.exit(app.exec_())

Y así es como se verán en QVBoxLayout.

import sys
from PyQt5.QtWidgets import *

if __name__ == "__main__":

    app = QApplication([])
    w = QWidget()
    w.setWindowTitle("Musketeers")

    btn1 = QPushButton("Athos")
    btn2 = QPushButton("Porthos")
    btn3 = QPushButton("Aramis")

    vb = QVBoxLayout(w)

    vb.addWidget(btn1)
    vb.addWidget(btn2)
    vb.addWidget(btn3)

    w.show()

    sys.exit(app.exec_())

La única función que necesita alguna explicación en este punto es el método addWidget(). Se utiliza para insertar widgets en el diseño de HBox o VBox. También se usa en otros diseños donde toma un número diferente de parámetros como verá en la siguiente sección. Los widgets aparecerán dentro del diseño en el orden en que los insertes.

QGridLayout

QGridLayout se utiliza para crear interfaces en las que los widgets se disponen en forma de cuadrícula (como una matriz o una matriz 2D). Para insertar elementos en un diseño de cuadrícula, puede usar la representación matricial para definir el número de filas y columnas en la cuadrícula, así como la posición de esos elementos.

Por ejemplo, para crear una cuadrícula de 3*3 (es decir, una cuadrícula con tres filas y tres columnas), escribirá el siguiente código:

Import sys
from PyQt5.QtWidgets import *

if __name__ == "__main__":
    app = QApplication([])

    w = QWidget()

    grid = QGridLayout(w)

    for i in range(3):
        for j in range(3):
            grid.addWidget(QPushButton("Button"),i,j)


    w.show()
    sys.exit(app.exec_())

Esta será la salida:

El método addWidget() en el diseño de cuadrícula toma estos argumentos:

Para comprenderlo mejor, puede insertar manualmente cada widget como se muestra a continuación

import sys
from PyQt5.QtWidgets import *

if __name__ == "__main__":
    app = QApplication([])

    w = QWidget()

    grid = QGridLayout(w)
    grid.addWidget(QPushButton("Button one"),0,0)
    grid.addWidget(QPushButton("Button two"),0,1)
    grid.addWidget(QPushButton("Button three"),1,0)
    grid.addWidget(QPushButton("Button four"),1,1)


    w.show()
    sys.exit(app.exec_())

Así es como se verá la cuadrícula:

También puede pasar los parámetros rowspan y colspan a addWidget() para abarcar más de una fila o columna.

Por ejemplo,

grid.addWidget(QPushButton("Button five"),2,0,1,0)

Esto creará un botón que se extiende sobre ambas columnas.

Temas

PyQt5 viene con algunos temas integrados que puede usar en sus aplicaciones. El setStyle() El método invocado en la instancia de QApplication se usa para establecer un tema particular para su aplicación.

Por ejemplo, agregar la siguiente línea de código cambiará el tema de su aplicación de predeterminado a Fusion

app.setStyle("Fusion")

Así se verá el ejemplo anterior en Fusion Theme

Otra función útil para tematizar tus aplicaciones es el método setPalette(). Aquí está el código para cambiar el color de diferentes widgets usando setPalette().

import sys
from PyQt5.QtCore import Qt
from PyQt5.QtWidgets import *
from PyQt5.QtGui import QPalette

if __name__ == "__main__":
    app = QApplication([])
    app.setStyle("Fusion")
    
    qp = QPalette()
    qp.setColor(QPalette.ButtonText, Qt.black)
    qp.setColor(QPalette.Window, Qt.black)
    qp.setColor(QPalette.Button, Qt.gray)
    app.setPalette(qp)

    w = QWidget()

    grid = QGridLayout(w)
    grid.addWidget(QPushButton("Button one"),0,0)
    grid.addWidget(QPushButton("Button two"),0,1)
    grid.addWidget(QPushButton("Button three"),1,0)
    grid.addWidget(QPushButton("Button four"),1,1)


    w.show()
    sys.exit(app.exec_())

Este es el resultado.

Para usar el método setPalette(), primero debe definir una paleta. Esto se hace creando un objeto de la clase QPalette.

 qp = QPalette()

Tenga en cuenta que la clase QPalette pertenece al módulo QtGui y deberá importarla para que funcione. Una vez que haya creado el objeto QPalette, use el método setColor() para pasar el nombre de un widget cuyo color desea cambiar y el color que desea configurar.

 qp.setColor(QPalette.Window, Qt.black)

Esto cambiará el color de la ventana a negro. Después de haber definido su esquema de color, use la función setPalette() para aplicar la paleta a su aplicación.

app.setPalette(qp)

Eso es todo lo que necesita hacer si desea crear algunos temas básicos para su aplicación. PyQt también le permite usar hojas de estilo para definir el aspecto de sus widgets. Si está familiarizado con CSS, puede definir fácilmente estilos avanzados para su aplicación utilizando las hojas de estilo Qt.

Resumen


python

  • Lenguaje C
  • VHDL
  • Verilog
  • MATLAB
  • python
  • Java

    1. Tutorial de colecciones de C# con ejemplos
    2. Declaración Python Print():cómo imprimir con ejemplos
    3. Python String count () con EJEMPLOS
    4. Python String format() Explicar con EJEMPLOS
    5. Método Python String find() con ejemplos
    6. Funciones Python Lambda con EJEMPLOS
    7. Función Python round() con EJEMPLOS
    8. Función Python map() con EJEMPLOS
    9. Python Timeit() con ejemplos
    10. Contador de Python en colecciones con ejemplo
    11. type() y isinstance() en Python con ejemplos