PyQt5 et thread

Version imprimable

PyQt5 et thread

Bonsoir, j'ai une interface PyQt5 avec un afficheur lcd. J'arrive à modifier sa valeur à partir d'un thread. Je souhaiterai créer un autre thread pour récupérer cette valeur depuis l'interface graphique. Pour d'autres widgets, ce sera , je pense le même principe. Merci d'avance. Voici le code:

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.QtGui import *
from PyQt5.QtCore import *
from PyQt5.QtWidgets import *
import os,sys
 
 
# --- importation du fichier de description GUI ---
from ui_testLcd import *
 
# classe principale contenant le code actif
 
class myApp(QWidget, Ui_Form1): # la classe reçoit le Qwidget principal
# Note : ici self représente la classe
    def __init__(self, parent=None):
        QWidget.__init__(self) # initialise le Qwidget principal
        self.setupUi(parent) # Obligatoire
        self.Thread = ThreadAfficher(self)
        self.Thread.jobDone.connect(self.afficherDonnee)
        self.Thread.start()
 
 
    def afficherDonnee(self,regime):
            """Affichage de la valeur regime dans le l'afficheur"""
            self.lcdNumbe1r.display(regime)
 
class ThreadAfficher(QtCore.QThread):
        """objet thread gérant l'envoi de la valeur regime"""
        jobDone = pyqtSignal(int)
        def __init__(self,parent=None):
                super(ThreadAfficher,self).__init__(parent)
 
        def run(self):
                while 1:
                    self.jobDone.emit(3200) #envoi d'une valeur à afficher
 
 
 
# fonction principale exécutant l'application Qt
def main(args):
    a=QApplication(args) # crée l'objet application
    f=QWidget() # crée le QWidget racine
    c=myApp(f) # appelle la classe contenant le code de l'application
    f.show() # affiche la fenêtre QWidget
    r=a.exec_() # lance l'exécution de l'application
    return r
 
 
# pour rendre le fichier *.py exécutable
if __name__=="__main__": # pour rendre le code exécutable
    main(sys.argv) # appelle la fonction main

26/10/2013, 13h40
VinsS
Et bien voila, tu as trouvé la balise code, et en plus tu as simplifié ton code.

Maintenant tu ne nous dis pas ce qui t'empêche d'y ajouter le second thread, tu l'avais fait dans la première version.

Une remarque:
Code:

1 2 3 4 def run(self): while 1: self.jobDone.emit(3200)
Je suppose que ton thread est censé faire autre chose que cela. et que tu as prévu un moyen de sortir de la boucle while. Sinon faudra y penser.
26/10/2013, 14h25
moumoute77

PyQt Thread

Bonjour, merci pour votre réponse. Le 2ème Thread est un souci car maintenant je souhaite récupérer la valeur affichée par le lcd (ici 3200). En fait au final, je lirai toutes les 10 secondes cette valeur. Donc j'ai vu la méthode lcdNumber.value() qui permet de le faire . La différence avec le 1er Thread, c'est que je dois recevoir la valeur et non l'envoyer à un slot (self.lcdNumbe1r.display). J'ai longuement cherché en vain. Merci .

PyQt et thread

J'ai ben essayé ceci mais ça me paraît trop simple et il y a une erreur.

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
class myApp(QWidget, Ui_Form1): # la classe reçoit le Qwidget principal
# Note : ici self représente la classe
    def __init__(self, parent=None):
        QWidget.__init__(self) # initialise le Qwidget principal
        self.setupUi(parent) # Obligatoire
        self.Thread = ThreadAfficher(self)
        self.Thread.jobDone.connect(self.lcdNumbe1r.display)
        self.Thread.start()
        self.Thread2 = ThreadRecup(self)
        self.Thread2.start()
 
    def recup(self):
        return self.lcdNumbe1r.value()
 
 
class ThreadAfficher(QtCore.QThread):
        """objet thread """
        jobDone = pyqtSignal(int)
        def __init__(self,parent=None):
                super(ThreadAfficher,self).__init__(parent)
 
        def run(self):
                while 1:
                    self.jobDone.emit(3200) #envoi d'une valeur à afficher
 
 
class ThreadRecup(QtCore.QThread):
        """objet thread """
 
        def __init__(self,parent=None):
                super(ThreadRecup,self).__init__(parent)
 
        def run(self):
                val=myApp.recup(self)
                print(val)

26/10/2013, 15h24
VinsS
Code:

1 2 val=myApp.recup(self)
Pourquoi met-tu self en argument ? Il n'y a aucune raison.

Si tu as une erreur, il faut copier ici le traceback complet qu'on puisse comprendre.

PyQt et thread

Voici le traceback:
Code:

1 2 3 4 5 6 Traceback (most recent call last): File "C:\Python33\ui_testLcdMain.py", line 48, in run val=myApp.recup(self) File "C:\Python33\ui_testLcdMain.py", line 26, in recup return self.lcdNumber1r.value() AttributeError: 'ThreadRecup' object has no attribute 'lcdNumber1r'
Je sais, c pas très normal de mettre self, mais si je ne mets rien, je ne mets rien non plus dans ma méthode recup() et ce n'est pas logique.

26/10/2013, 20h12
VinsS

Non, aucun argument à val=myApp.recup() et tu laisses le self à recup(self).

Cette incompréhension du fonctionnement de Python me laisse à penser que tu as du sauter quelques chapitres dans ton apprentissage du langage.

Possible, en tout cas, ça ne fonctionne pas. Voici le traceback quand j'enlève l'argument.
Code:

1 2 3 4 Traceback (most recent call last): File "C:\Python33\ui_testLcdMain.py", line 48, in run val=myApp.recup() TypeError: recup() missing 1 required positional argument: 'self'

C'est la façon dont tu utilises cette méthode de classe.

Code:

1
2
 
    val=myApp.recup()

myApp est la classe elle-même et non pas l'instance que tu as créée.

Exemple:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
class Foo(object):
    def __init__(self):
        pass
 
    def baz(self):
        print 'baz'
 
f = Foo()
f.baz()
Foo().baz()
Foo.baz()

ce qui donne:

Code:

1
2
3
4
5
6
7
 
baz
baz
Traceback (most recent call last):
  File "cls.py", line 13, in <module>
    Foo.baz()
TypeError: unbound method baz() must be called with Foo instance as first argument (got nothing instead)

Alors que pourtant tu donnes une référence à l'instance de ta classe lorsque tu crées tes threads

Code:

1
2
3
4
5
...
        self.Thread = ThreadAfficher(self)
        ...
        self.Thread2 = ThreadRecup(self)

il faut donc l'utiliser.

Code:

1
2
3
4
5
6
7
8
9
10
11
 
class ThreadRecup(QtCore.QThread):
        """objet thread """
 
        def __init__(self,main, parent=None):
                super(ThreadRecup,self).__init__(parent)
                self.main = main
 
        def run(self):
                val = self.main.recup(self)
                print(val)

27/10/2013, 14h17
moumoute77

PyQt et thread

Bonjour et merci beaucoup. Ca fonctionne en enlevant maintenant l'argument self de ma méthode recup(), ce qui est effectivement plus normal. J'ai encore pas mal de boulot de compréhension de la programmation objet, mais je m'accroche et grâce à vous et au forum.

J'ai testé avec un comboBox aussi, je récupère bien le texte sélectionnée courant. SUPER!

J'aurai sûrement encore besoin de votre aide. Merci !:ccool: