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

**GATINEAU** · 22/07/2019, 12h02

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

**tyrtamos** · 23/07/2019, 07h50

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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_())

**wiztricks** · 23/07/2019, 10h48

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

**GATINEAU** · 23/07/2019, 11h05

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.

**GATINEAU** · 23/07/2019, 16h32

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

**tyrtamos** · 24/07/2019, 06h36

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

**wiztricks** · 24/07/2019, 09h27

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

**GATINEAU** · 24/07/2019, 21h35

Merci beaucoup pour vos conseils.

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

Merci encore.
A bientôt.

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

PyQt Python

Discussions similaires

Partager

Partager