Este artículo introduce principalmente el ejemplo de PYQT5 para implementar MVC a través de la señal, ayudando a todos a entender y usar mejor PyQT5, amigos interesados pueden entender
Es bien sabido que MVC es algo bueno. La matriz frontal ha sido buscada, pero todavía hay una escasez de documentos chinos que implementa MVC con PYQT5, y sólo se han encontrado documentos de alta calidad. En este caso, ven, abre un pozo, aprende nuevos conocimientos, atrae el tráfico. Por ejemplo, acerca de PYQT5, el diseño necesita mirarlo, el control de contenedor necesita ver, hay pruebas multiproceso y automatizadas. Pero para escribir la GUI perfecta requiere mucha experiencia de código y la capacidad de la consulta de documentos. Entonces, um, esta parte de la fosa está llena.
Tirar hacia atrás: Suponiendo que la escena que se enfrenta a esto es que un software implica varias páginas, cada página es un código independiente. Y cada página necesita tener su propio controlador, y finalmente todo el controlador se resume juntos, administración unificada.
En este artículo, el texto es sólo comprensión auxiliar, y es necesario leer el código.
Señal
Como es bien sabido, la GUI necesita notificar a otro control cuando cambia un estado de control, es decir, se implementa la comunicación entre los objetos. Cuando se produce un evento o cambia el estado, se enviará una señal, la señal activa la función asociada a este evento y nuestra función es una ranura. La señal y las ranuras pueden ser relaciones de varios a varios. La señal se define cuando se crea la clase, es decir, la definición frontal de la inicialización.
Señal personalizada y ranura
No preguntes, siente en silencio el siguiente código. En el código siguiente, se han incluido una serie de procesos como definiciones de señal, tipos, funciones de transmisión y ranura de enlace de los parámetros especificados.
de PyQt5.QtCore importar QObject, pyqtSignal
# Objeto de señal
clase QSignal(QObject):
# Definir la señal
# Durante la creación de clases, no puede agregar los atributos de la clase tras clase.
# Especifique el número, el tipo, etc. de los parámetros de transmisión de señal
send_msg = pyqtSignal(str, str)
def __init__(uno mismo):
super(QSignal, self).__init__()
def run(self):
# Emisión de señal
self.send_msg.emit(‘First arg’, ‘Second arg’)
#
clase QSlot(QObject):
def __init__(uno mismo):
super(QSlot, self).__init__()
def get(self, *args):
# recepción de señal
print(«Obtener mensaje =>» + args[0]Args[1], sep=’, ‘)
si __name__ == ‘__main__’:
enviar = QSignal()
ranura = QSlot()
# Enlazar la señal con la función groove
send.send_msg.connect(slot.get)
# Señal de transmisión de llamada externa
send.run()
#
send.send_msg.disconnect(slot.get)
send.run()
Ranura personalizada de enlace de señal incorporada
De esta manera, a continuación, mira uno y la ventana combinar ejemplos. Hay un botón en la ventana y haga clic en el botón para salir de la ventana. Aunque este ejemplo es muy simple, se puede lograr sin señales y ranuras. Pero aquí dar una sensación de meditación: conexión de señal, transmitir, y recibir la lógica completa.
importar sys
de functools importar parciales
de PyQt5.QtCore importar pyqtSignal
de PyQt5.QtWidgets import (QMainWindow, QApplication, QPushButton, QWidget,
QHBoxLayout)
clase MainWindow(QMainWindow):
btn_signal = pyqtSignal()
def __init__(uno mismo):
super(MainWindow, self).__init__()
a = qpushbutton («exit»)
# Añadir información adicional a la función de ranura de enlace
a.clicked.connect(partial(self.btn_clicked, 1))
self.btn_signal.connect(self.close)
Self.SetWindowtitle («Demo»)
main_widget = QWidget()
diseño = QHBoxLayout()
layout.addWidget(a)
main_widget.setLayout(layout)
# Qmainwindow no puede establecer el diseño
self.setCentralWidget(main_widget)
def btn_clicked(self, n):
print(n)
self.btn_signal.emit()
def close(self):
app = QApplication.instance()
app.quit()
si __name__ == «__main__»:
# Ejecutar en el shell
aplicación = QApplication(sys.argv)
mywin = MainWindow()
mywin.show()
# Inicie el bucle principal hasta que salga
sys.exit(app.exec())
Aquí, desea entregar parámetros adicionales a la función de ranura enlazada btn_clicked, pero no se pueden agregar parámetros adicionales al enlazar la señal. Correspondiente al ejemplo anterior, Close () puede aumentar los parámetros especificando los parámetros y el tipo de la señal, pero btn_clicked () no puede ser. Una solución es extraer la función parcial universal, enlazar la función y los parámetros juntos.
En este punto, debe entenderse el modo de funcionamiento y el principio de la señal. Y más contenido, como sobrecarga, decorador, etc., no hacen más introducción, consulte la documentación oficial. También admiro la forma de aprender: «Voy a tocar todo el código.» Hoy en día, he olvidado el significado de la mayoría de los controles y el código de varios estilos, convirtiéndose en: voy a comprobar la API.
Mvc
El gran nombre del MVC debería haber escuchado ese modelo, vista y control, es decir, base de datos, páginas y procesamiento de la separación de fase lógica, que está más especializado. Aquí, los tres contenidos se implementan en tres clases, y los individuos no lo recomiendan. Se recomienda colocar los archivos en tres carpetas en lugar de introducirse en un código:
importar sys
de PyQt5 importar QtCore
de PyQt5.QtWidgets import (QWidget, QHBoxLayout, QPushButton, QMessageBox,
QLineEdit, QApplication)
# Ver
clase MainWindow(QWidget):
verifySignal = QtCore.pyqtSignal()
def __init__(self, *args, **kwargs):
super(MainWindow, self).__init__(*args, **kwargs)
self.id_line = QLineEdit()
SELF.ID_LINE. SETPLACEHOLDERTEXT («Por favor, introduzca una cuenta»)
self.psd_line = QLineEdit()
Self.psd_line.setPlaceHoldertext («Introduzca su contraseña»)
self.init()
def init(self):
diseño = QHBoxLayout()
self.setLayout(layout)
Self.Button = qpushbutton («Inicio de sesión»)
layout.addWidget(self.button)
layout.addWidget(self.id_line)
layout.addWidget(self.psd_line)
# Conecte la señal definida
self.button.clicked.connect(self.verify_emit)
def verify_emit(uno mismo):
self.verifySignal.emit()
def verify_ok(uno mismo):
QMessageBox.about (Self, «Password is correct», «Logged in»)
def verify_no(self):
QMessageBox.about (Self, «You make a loud error», «Please re-check»)
# modelo
clase Student(object):
def __init__(uno mismo):
self.name = «aaa»
self.password = «aaa»
# control
clase LoginControll(object):
def __init__(uno mismo):
# No hay necesidad de introducir parámetros desde la línea de comandos
self._app = QApplication([])
self._model = Estudiante()
self._view = MainWindow()
self.init()
def init(self):
self._view.verifySignal.connect(self.verify_user)
def verify_user(uno mismo):
id_ = self._view.id_line.text()
psd_ = self._view.psd_line.text()
si id_ == self._model.name y psd_ == self._model.password:
self._view.verify_ok()
Más:
self._view.verify_no()
def run(self):
self._view.show()
# , hasta que la aplicación salga
devolver self._app.exec_()
# main.py
si __name__ == «__main__»:
login_control_ = LoginControll()
# Salir del programa principal
sys.exit(login_control_.run())
Debe tenerse en cuenta en este ejemplo que MODEL, View y Controller se dividen en tres clases. Defina la señal y la señal cuando la señal se define en la vista, y la función de ranura después de que la señal se defina en el regulador, es decir, qué tipo de respuesta se activa. De esta manera, el VIEW y el controlador se enlazan junto con la transmisión y la conexión de la señal. View es responsable de la visualización de la página y la definición de señal, la implementación del controlador, perfecto.
Implementación de MVC
Página única
Si lees el contenido anterior, deberías poder luchar. Primero dar un DEMO, es dividir un ejemplo del MVC más simple anterior en tres archivos. Aquí hay código inconveniente, por favor muévase a mi github para ver, esta es la estructura de archivos, este es el archivo principal.
Multi-página
En la realización de una lógica de puntos compleja, varias páginas, varios controladores, estructura de archivos de la siguiente manera, un archivo principal, con tres carpetas, perfecto. Trate de estandarizar, los nombres de archivo, los nombres de clase y los nombres de función al nombrar aquí, de lo contrario es fácil de hacer usted mismo. Python main.py se ejecuta.
MVC-demo
├main.py
├- IU
│ ├leftbtn_ui.py
│ ├login_ui.py
│ ├main_window_ui.py
│ └verify_ui.py
├- control
│ ├controller.py
│ ├leftbtn_control.py
│ ├login_control.py
│ └verify_control.py
└- modelo
└model.py
La relación de llamada es la siguiente:
Aquí usted necesita señalar que el volumen de la variable, el regulador principal de la llamada, y el regulador llama al otro subcontrolador, es fácil desaparecer después de declarar una clase, dando lugar a la señal incapaz de conectar. Al igual que en Controller.py, se escribe un error típico:
clase Controll(object):
def __init__(uno mismo):
self._app = QApplication([])
self._stu = Estudiante()
self._view = MainWindow()
self.init()
def init(self):
# controlador Como variable local, desaparece inmediatamente inmediatamente, por lo que la señal y la ranura no se pueden conectar.
# Este problema me ha plagado tres días, es gracioso.
login_controller = login_control. Controlador(self._view, self._stu.name, self._stu.password)
Debido a que el archivo de código es demasiado y confuso, no se mostrará aquí, de lo contrario el lector fácilmente sentirá caos. Sólo se muestra un efecto aquí, y el código completo ve mi github. De hecho, mira un ejemplo, entiendes.
Lo anterior son los detalles de la implementación pyqt5 del ejemplo del MVC, más sobre la información del PYQT5 a través de la señal para implementar el MVC, por favor preste atención a la familia de otros artículos relacionados del script!
.
