Récupération d'un variable d'une fenêtre à une autre avec PyQt5

Version imprimable

Bonjour à tous !

Dans le cadre du développement d'une petite application sur Python3 et PyQt5, je suis amené à ouvrir par un click sur un chek_box, une petite fenêtre dans laquelle deux spin_box sont présents. Une fois les valeurs des spin_box validés par un push_button, la fenêtre se referme pour revenir sur la fenêtre principale.

Mon problème est que je n'arrive pas à récupérer les variables des spin_box de la seconde fenêtre dans ma fenêtre principale. Je ne sais pas du tout comment aborder le problème.

Mes fenêtres ont été réalisées à l'aide de QtDesigner. Je suis sur Python 3.7 et PyQt5. Mon programme se structure de la manière suivante :
- "main.py" : qui lance ma première fenêtre
- "random_data.py" qui possède toutes les fonctionnalités de ma fenêtre principale
- "intervalle_intervention.py" : qui possède les fonctionnalités de ma seconde fenêtre
- dossier "form" : contenant la fenêtre principale : "random_data_form.py", et qui contient aussi la seconde fenêtre : "intervalle_form.py"

J'ai créé dans ma classe RandomData, une fonction pour appeler la deuxième fenêtre lorsqu'on click sur le checkbox. Cette fonction se nomme "openIntervalleForm" et ressemble à ceci :
Code:

1 2 3 def openIntervalleForm(self): Intervalle_intervention_form = IntervalleIntervention() Intervalle_intervention_form.exec_()
Le code présent dans le programme intervalle_intervention.py est le suivant :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 # -*- coding: utf-8 -*- from PyQt5.QtWidgets import * from form.intervalle_form import * class IntervalleIntervention(QDialog, Ui_intervalle_form): def __init__(self): QDialog.__init__(self) print("setupUi") self.setupUi(self) self.pb_ok.clicked.connect(self.retourne_valeurs) self.pb_ok.clicked.connect(self.quitter) self.pb_annuler.clicked.connect(self.quitter) def retourne_valeurs(self): value_min = self.spin_min.value() value_max = self.spin_max.value() if value_min < value_max : if type(value_min) == int : if type(value_max) == int : return(value_min, value_max) else : Q = QMessageBox() Q = QMessageBox.critical(Q, "Erreur", u"Les valeurs sont incorrectes") else: Q = QMessageBox() Q = QMessageBox.critical(Q, "Erreur", u"Les valeurs sont incorrectes") else: Q = QMessageBox() Q = QMessageBox.critical(Q, "Erreur", u"La valeur minimum est supérieur à la valeur maximum") def quitter(self): self.reject()
Les valeurs que je voudrais récupérer dans mon premier programme sont "value_min" et "value_max" autrement dit les valeurs des deux spin_box de ma fenêtre.

A l'heure actuelle, avec ce code, j'arrive à visualiser la seconde fenêtre et à gérer mes erreurs. Cependant, je n'arrive pas à capter mes variables dans mon premier programme.

Je ne sais pas si j'ai été très clair dans mes explications. Si je ne l'ai pas été, n'hésitez pas à me le dire.
Merci et bonne journée à tous.

Bonjour,

Pour récupérer des données saisies dans une fenêtre de dialogue, par la fenêtre qui l'a appelée, je crée un nouveau signal dans la fenêtre de dialogue, et j'utilise ce signal pour envoyer (emit) les données saisies à la fermeture. Il faut, bien sûr, que la récupération de ce signal ait été préparée (connect) par l'appelant.

Un petit code de test:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
#!/usr/bin/python3
# -*- coding: utf-8 -*-
 
import sys
from PyQt5 import (QtWidgets, QtCore)
 
#############################################################################
class Dialog(QtWidgets.QDialog):
 
    # nouveau signal pour transmettre les données
    donnees = QtCore.pyqtSignal(list)
 
    #========================================================================
    def __init__(self, parent=None):
        super().__init__(parent)
        self.resize(300,200)
 
        self.spinbox1 = QtWidgets.QSpinBox(self)
        self.spinbox2 = QtWidgets.QSpinBox(self)
 
        # crée les boutons pour terminer le dialogue
        qbb = QtWidgets.QDialogButtonBox.Ok | QtWidgets.QDialogButtonBox.Cancel
        self.boutonbox = QtWidgets.QDialogButtonBox(qbb)
        self.boutonbox.accepted.connect(self.quitter) # => bouton "Ok"
        self.boutonbox.rejected.connect(self.annuler) # => bouton "Annuler"
 
        posit = QtWidgets.QGridLayout()
        posit.addWidget(self.spinbox1, 0, 0)
        posit.addWidget(self.spinbox2, 1, 0)
        posit.addWidget(self.boutonbox, 2, 0)        
        self.setLayout(posit)
 
    #========================================================================
    def quitter(self):
        """fermeture normale de la fenêtre dialog (bouton "Ok")
        """
        self.donnees.emit([self.spinbox1.value(), self.spinbox2.value()])
        self.close()
 
    #========================================================================
    def annuler(self):
        """annulation de la recherche de données (bouton "Annuler")
           NB: idem pour la fermeture  par la croix ou le menu système 
        """
        self.donnees.emit([None, None])
        self.close()
 
#############################################################################
class Fenetre(QtWidgets.QWidget):
 
    #========================================================================
    def __init__(self, parent=None):
        super().__init__(parent)
        self.resize(300,100)
 
        self.bouton = QtWidgets.QPushButton("Saisie des données", self)
        self.bouton.clicked.connect(self.saisie)
 
        posit = QtWidgets.QGridLayout()
        posit.addWidget(self.bouton, 0, 0)
        self.setLayout(posit)
 
    #========================================================================
    def saisie(self):
        """lancement de la fenêtre de dialogue pour la saisie des données
        """
        self.dialog = Dialog(self)
        self.dialog.donnees.connect(self.recupinfos) # prépare la récupération des données saisies
        self.dialog.exec_()
 
    #========================================================================
    def recupinfos(self, liste):
        """Récupération des infos
        """        
        self.dialog.hide() # cache la fenêtre dialog encore affichée (elle sera fermée juste après)
        if liste!=[None, None]:
            QtWidgets.QMessageBox.information(self, 
                "Récupération des infos:", 
                "nombre 1: {}\nnombre 2: {}".format(liste[0], liste[1]))
 
#############################################################################
if __name__ == "__main__":
    app = QtWidgets.QApplication(sys.argv)
    fen = Fenetre()
    fen.show()
    sys.exit(app.exec_())

Citation:

Envoyé par GATINEAU

Mon problème est que je n'arrive pas à récupérer les variables des spin_box de la seconde fenêtre dans ma fenêtre principale. Je ne sais pas du tout comment aborder le problème.

Si vous écrivez:
Code:

1 2 3 4 5 6 def saisie(self): """lancement de la fenêtre de dialogue pour la saisie des données """ self.dialog = Dialog(self) self.dialog.donnees.connect(self.recupinfos) # prépare la récupération des données saisies self.dialog.exec_()
L'instruction self.dialog.exec_() attend que la fenetre de dialogue se termine et retourne un status traduisant accept/reject.
Et les valeurs à récupérer (value_min, value_max) peuvent être récupérées si elles ont été stockées dans des attributs de l'instance.

- W

23/07/2019, 11h05
GATINEAU

Merci beaucoup pour votre précieuse aide. J'ai effectivement pu appliquer cette méthode à mon code et cela fonctionne très bien.

Je n'avais jusqu'à présent jamais utilisé de "emit", mais je pense approfondir davantage ceci à l'avenir.

Merci encore pour votre aide.

Après avoir appliqué vos conseils, je me pose la question de la récupération de la données dans une nouvelle fonction. Les données récupérées servent normalement à une autre fonction qui est activée dans la fenêtre principale par un bouton. Cette fonction est une fonction d'export qui n'a lieu normalement qu'à la fin de l'utilisation du programme.

Je me demande donc comment récupérer les deux valeurs dans la fonction alors que la seconde fenêtre sera déjà fermée :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 def openIntervalleForm(self): if self.chk_intervention.isChecked() : Intervalle_intervention_form = IntervalleIntervention() Intervalle_intervention_form.donnees.connect(self.recupinfos) Intervalle_intervention_form.exec_() else : return def recupinfos(self, liste): value_min = "" value_max = "" print("0") Intervalle_intervention_form = IntervalleIntervention() Intervalle_intervention_form.hide() print(liste) if liste != [None, None]: value_min = liste[0] value_max = liste[1] print(value_min) print(value_max) return(liste)
J'ai l'habitude de récupérer une variable en exécutant à nouveau ma fonction comme ceci : (je prends l'exemple de ma fonction d'export)
Code:

1 2 def export(self): liste = self.recupinfos(self)
Cependant, ce n'est pas possible ici puisque la fenêtre sera déjà fermée.

Pensez-vous que c'est tout de même possible ou faut-il que je réorganise mes fonctions ?
Merci encore pour votre aide.

24/07/2019, 06h36
tyrtamos
Bonjour,

Dans mon code, la méthode recupinfos(self, liste) est lancée par la fermeture de la fenêtre de dialogue, et récupère la liste des 2 nombres pour l'afficher.
Mais au lieu de l'afficher, tu peux créer un nouvel attribut:
Code:

1 2 3 4 def recupinfos(self, liste): """Récupération des infos """ self.liste2nb = liste
Après ça, la liste de tes 2 nombres "self.liste2nb" est disponible pour être utilisée par n'importe quelle autre méthode de la classe Fenetre.

Il faut toujours se rappeler qu'une application graphique fonctionne par évènement. Si cette utilisation est déclenchée par un autre évènement comme un clic sur un bouton, il faut veiller à ce que ce clic ne puisse pas se faire AVANT que ces 2 nombres ne soient obtenus par la fenêtre de dialogue. Par exemple en désactivant temporairement ce bouton, et c'est la méthode recupinfos qui pourrait le réactiver.

Citation:

Envoyé par GATINEAU

Je me demande donc comment récupérer les deux valeurs dans la fonction alors que la seconde fenêtre sera déjà fermée

C'est bien d'avoir des "event" qui explosent de tous les côtés, mais votre boîte de dialogue est "modale". L'utilisateur ne peut rien faire d'autre que saisir des valeurs et cliquer sur Ok, Cancel pendant que l'appelant attend que .exec_() se termine.

Code:

1
2
3
4
5
6
7
    def openIntervalleForm(self):
        if self.chk_intervention.isChecked() :
            Intervalle_intervention_form = IntervalleIntervention()
            Intervalle_intervention_form.donnees.connect(self.recupinfos)
            if Intervalle_intervention_form.exec_():
                # je récupère et je stocke les valeurs.
            Intervalle_intervention_form.close()

Et un exemple de cette mécanique:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
from PyQt5.QtWidgets import *
 
class Dialog(QDialog):
    value = None
 
    def __init__(self, parent=None):
 
        super().__init__(parent)
        bb = self.bb = QDialogButtonBox(self)
        bb.setStandardButtons(QDialogButtonBox.Ok |
                             QDialogButtonBox.Cancel)
        bb.accepted.connect(self.accept)
        bb.rejected.connect(self.reject)
 
        self.spinbox = QSpinBox(self)
 
        layout = QVBoxLayout(self)
        self.setLayout(layout)
        for w in [self.spinbox, bb]:
            layout.addWidget(w)
 
 
    def accept(self):
        self.value = self.spinbox.value()
        super().accept()
 
 
class Widget(QWidget):
 
    def __init__(self, parent=None):
        super().__init__(parent)
        self.resize(300,100)
        self.bouton = QPushButton("Saisie", self)
        self.bouton.clicked.connect(self.get_data)
 
        layout = QHBoxLayout()
        self.setLayout(layout)
        layout.addWidget(self.bouton)
 
    def get_data(self):
        dialog = Dialog(self)
        z = dialog.exec_()
        print (z, dialog.value)
        dialog.close()
 
if __name__ == "__main__":
    app = QApplication([])
    w = Widget()
    w.show()
    exit(app.exec_())

vous montre qu'utiliser cela est bien plus compact (et simple).

- W

24/07/2019, 21h35
GATINEAU

Merci beaucoup pour vos conseils.

J'ai bien retenu vos remarques, et les ai appliqué à mon programme.

Merci encore.
A bientôt.