portée des objets

Version imprimable

11/05/2019, 14h46
Invité

portée des objets

Bonjour,
je suis en train d'apprendre à écrire "proprement"... enfin je crois...
jusqu'à maintenant j'écrivais tout dans un même fichier *.py

Le problème, c'est que ces fichiers deviennent vite grands et selon les programmes, je me rend compte qu'il y a des fonctions que je répète.
du coup, je pense que j'aurais tout intérêt à sortir ces fonctions dans un autre fichier *.py et d'y faire appel via (from monfichier import mafonction).

Quand il s'agit d'opérations mathématique, j'arrive à gérer les paramètres/portées des variables pour me faire des fonctions "clé en main".
Mais lorsqu'il s'agit d'objet PyQt j'arrive pas à m'en sortir.

Exemple:
j'aimerais faire afficher une boite de dialogue lorsque je clique sur un bouton.

Initialement j'utilisais simplement la ligne suivante (ligne positionnée dans une méthode de mon unique classe principale ou sont déclarés tous mes objets graphiques):

Code:

repertoire = str(QFileDialog.getExistingDirectory(self,"Choisissez le dossier où enregistrer les photos",self.adresse_reseau))

pour ce qui est des champs texte ça va j'arrive à transférer les données entre mes deux fichiers .py
mais le "self", je le gère comment? Une fois que ma fonction est "sortie" de ma classe principale... et qu'elle se retrouve seule dans un fichier... je fais comment le lien avec la fenetre principale?

merci!
11/05/2019, 15h06
wiztricks
Salut,

Citation:

Envoyé par dd-64

pour ce qui est des champs texte ça va j'arrive à transférer les données entre mes deux fichiers .py
mais le "self", je le gère comment? Une fois que ma fonction est "sortie" de ma classe principale... et qu'elle se retrouve seule dans un fichier... je fais comment le lien avec la fenetre principale?

Déjà, la "fenetre principale" est la chose qui apparaît sur l'écran. Ce qui s'y affiche est réalisé par une ou plusieurs instances de widgets/classes.
Ensuite, il n'y a pas de transfert de données entre fichiers .py: ils s'appellent "modules" et pour l'utilisateur écrire:

Code:

import toto

ou
Code:

1 2 3 4 class A: .... toto = A()
fabriquera un "toto" qui s'utilisera de la même façon côté syntaxe
- toto.function: la fonction du module toto
- toto.méthode: la méthode de l'instance toto.
Et si vous sortez une méthode de la définition de sa classe (ou du module), ben, vous ne pourrez pas la remettre dedans (simplement).

Donc il vous faut travailler 2 choses: la POO et les modules et tant que vous n'aurez pas essayé de comprendre ces choses là par vous même, il sera difficile de vous aider.

- W

merci pour la réponse!
En effet, la POO et les histoires de modules classes... je m'y perds assez vite! mais je fais au mieux pour avancer!

ci dessous, un code qui marche à moitié, la ligne 39 ne marche pas.
je n'arrive déjà pas à modifier des objets (labels ou boutons) en passant par une classe autre que celle où ils sont déclarés.

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
from PyQt5.QtWidgets import QMainWindow,QWidget,QPushButton,QLabel,QVBoxLayout,QHBoxLayout,QApplication
import sys
 
class B(QMainWindow):
    def __init__(self):
        QMainWindow.__init__(self)
        fenetre_widget = QWidget()
 
        #Boutons
        self.bouton_play = QPushButton("Play")
        self.bouton_play.setFixedWidth(70)
        self.bouton_stop = QPushButton("Stop")
        self.bouton_stop.setFixedWidth(70)
 
        #Labels
        self.label_1 = QLabel()
        self.label_1.setStyleSheet("QLabel {background: black}")
 
        #Layout
        layoutverticalglobal=QVBoxLayout()       
        layoutverticalglobal.addWidget(self.bouton_play)
        layoutverticalglobal.addWidget(self.bouton_stop)   
        layoutverticalglobal.addWidget(self.label_1)
        #Intégration    
        fenetre_widget.setLayout(layoutverticalglobal)        
        self.setCentralWidget(fenetre_widget)
 
        #Fonctions Connect
        self.bouton_play.clicked.connect(A.play)
        self.bouton_stop.clicked.connect(A.stop)
 
class A:
    def __init__(self, ui):
        self.ui=ui
        print("test")
 
    def play(a):
        print("play")
        self.ui.label_1.setStyleSheet("QLabel {background: pink}")
    def stop(a):
        print("stop")
 
def main(args):
    appli=QApplication(args)
    fenetre=B()
    fenetre.show()
    r=appli.exec_()
    return r
 
if __name__=="__main__":
    main(sys.argv)

11/05/2019, 19h53
wiztricks
Salut,

Relisez votre code:
Code:

1 2 3 def play(a): print("play") self.ui.label_1.setStyleSheet("QLabel {background: pink}")
self.ui n'existe que dans une instance de A (c'est l'__init__ qui le fabrique).
Or dans self.bouton_play.clicked.connect(A.play), A.play est juste une fonction pas une instance.

Citation:

En effet, la POO et les histoires de modules classes... je m'y perds assez vite! mais je fais au mieux pour avancer!

C'est vous qui voyez mais si vous n'y comprenez rien, il faut retourner bosser dans les tutos. et apprendre - ce qu'on ne peut pas faire à votre place.

- W

Bonjour,
je me suis penché sur quelques tutos et j'ai finalement réussi (semble-t-il) à faire ce que je voulais.
même si mon exemple ci dessous marche, j'aimerais être sure d'avoir compris ce qui se passe.

donc pour communiquer entre deux classes concernant un objet (un Qlabel dans l'exemple ci dessous):
Il faut créer une instance de la fenetreprincipale au Qlabel pour qu'il puisse communiquer avec elle.
cela se traduit en code par la ligne ci dessous au sein de ma classe "fenetreprincipale":

Code:

self.label_1 = A(self)

par la suite, dans la classe A, pour permettre au Label de référer à la fenetreprincipale, il faut utiliser un parametre (ui).
En code ça donne:
Code:

1 2 3 4 def __init__(self,ui): QLabel.__init__(self) self.ui=ui self.ui.setStyleSheet("QLabel {background: pink}")
Pour lier une fonction afin de modifier un label depuis la classe A, il suffit alors d'écrire:

Code:

self.bouton_play.clicked.connect(self.label_1.play)

cela signifierait que le bouton "self.bouton_play" est lié au clic par la méthode play de l'objet self.label_1 issu de l'instanciation de la classe A.

au final, il apparait possible de "séparer" un code en différents fichiers gérant des fonctions différentes (placement/layout, mise en forme, assignation de variables) mais sur les mêmes objets (manipuler un label depuis différentes classes).

merci :-)
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 from PyQt5.QtWidgets import QMainWindow,QWidget,QPushButton,QLabel,QVBoxLayout,QHBoxLayout,QApplication import sys class Fenetre_Principale(QMainWindow): def __init__(self): QMainWindow.__init__(self) fenetre_widget = QWidget() #Boutons self.bouton_play = QPushButton("Play") self.bouton_play.setFixedWidth(70) #Labels self.label_1 = A(self) #Layout layoutverticalglobal=QVBoxLayout() layoutverticalglobal.addWidget(self.bouton_play) layoutverticalglobal.addWidget(self.label_1) #Intégration fenetre_widget.setLayout(layoutverticalglobal) self.setCentralWidget(fenetre_widget) #Fonctions Connect self.bouton_play.clicked.connect(self.label_1.play) class A(QLabel): def __init__(self,ui): QLabel.__init__(self) self.ui=ui self.ui.setStyleSheet("QLabel {background: pink}") def play(self, ui): self.ui.setStyleSheet("QLabel {background: black}") def main(args): appli=QApplication(args) fenetre=Fenetre_Principale() fenetre.show() r=appli.exec_() return r if __name__=="__main__": main(sys.argv)