variables locales ou pas

Version imprimable

Bonjour,
j'ai quelques difficultées à traiter les valeurs de différentes variables entre mes fonctions...
ci dessous, le code... simplifié "au max" pour pouvoir le lire rapidement...

Dans la fonction "initialisation" j'aimerais pouvoir assigner des valeurs à mes variables x,y et theta (via les valeurs issues des spin boutons... jusque là pas de souci)... mais ensuite, j'aimerais les réutiliser dans mes foncitons "dessin_graphique" et "représentation_table".

malgré mes recherches, je n'arrive pas à utiliser mes variables x,y et theta à l'intérieur des fonctions "dessin_graphique" et "représentation_table"....

ou est-ce que je m'y prend mal?
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
40
41
42
43
44
45
46
47
48
49
50
from PyQt5 import QtCore
from PyQt5.QtWidgets import *
from PyQt5.QtCore import *
from PyQt5.QtGui import *
import os,sys
import numpy as np
from pylab import *
 
 
class fenPrincipale(QMainWindow):
    def __init__(self):
        QMainWindow.__init__(self)
        fenetre_widget = QWidget()
 
        self.table_considere=QSpinBox()
        self.table_considere.setRange(2,50)
        self.nb_points=QSpinBox()
        self.nb_points.setRange(3, 350)
 
        LayoutV=QVBoxLayout()
        LayoutV.addWidget(self.table_considere)
        LayoutV.addWidget(self.nb_points)
 
        fenetre_widget.setLayout(LayoutV)
        self.setCentralWidget(fenetre_widget)
 
        self.nb_points.valueChanged.connect(self.dessin_graphique)
        self.table_considere.valueChanged.connect(self.representation_table)
 
    def dessin_graphique(self,theta,y):
        self.initialisation
        print(theta*x*y)
 
    def representation_table(self,theta):
        self.initialisation
        print((theta*x)/y)
    def initialisation(self,x,y):
        theta = 10
        x = 3
        y = 2
 
def main(args):
    appli=QApplication(args)
    fenetre=fenPrincipale()
    fenetre.show()
    r=appli.exec_()
    return r
 
if __name__=="__main__":
    main(sys.argv)

Salut,

Quel est le but poursuivit ?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 def dessin_graphique(self,theta,y): self.initialisation print(theta*x*y) def representation_table(self,theta): self.initialisation print((theta*x)/y) def initialisation(self,x,y): theta = 10 x = 3 y = 2
Si tu veux appeler la méthode initialisation il faut mettre des parenthèses et de plus elle prend deux arguments dont on se demande à quoi ils servent puisque tu fixes les valeurs de x et y dans cette méthode.

D'où ma question, que veux-tu faire exactement ?

10/11/2015, 17h19
fred1599
Si tu veux les réutiliser, tu dois exprimer clairement que ces variables appartiennent à l'objet créé (instance)
Code:

1 2 3 4 5 def initialisation(self,x,y): self.theta = 10 self.x = 3 self.y = 2
En admettant que tes fonctions dessin_graphique et représentation_table soient des fonctions utilisées après la méthode initialisation, ce qui me semble d'après le nom de cette méthode (initialisation) cohérent.
10/11/2015, 19h01
Invité

variable locales ou pas

Bonjour,
oui c'est vrai que dans "initialisation" les variables sont fixée (dans les lignes que j'ai collé) mais dans l'application finale, les valeur x, y et theta sont des valeurs traitées en fonction de deux valeurs renseignées dans des spinbox (dans l'exemple que j'ai collé je les ai fixé pour me simplifier la tache et voir si j'arrive à les faire passer à travers différents appel de fonctions).

Au final, j'aimerais que lors du changement de valeurs des spinbox il y ait automatiquement une mise à jour du traitement de ces valeurs via "dessin graphique" ou "représentation table" qui sont, en fait, liées (chacune) à une des deux spinbox de ma fenetre principale...

la ou je bloque c'est que j'arrive pas à faire suivre les valeurs de mes spinbox dans mes fonction de traitement...

j'avais fais une version du programme qui marchait mais je le trouvais un peu répétitif... en fait, le traitement de toutes les variables était refait à l'identique dans chacune des fonctions... et le traitment était lourd.. (c'est pour ça que je l'ai viré avant de le proposer en exemple). J'ai voulu sortir ces répétitions un peu lourdes en les remplaçant par un appel de traitement (que j'ai appelé initialisation)... mais j'arrive pas à faire les liens entre les variables...

je sais pas si j'ai été clair...

en tout cas merci pour vos réponses!
10/11/2015, 19h40
VinsS
Tout d'abord, tu dois avoir une erreur ici:
Code:

1 2 def dessin_graphique(self,theta,y):
le signal de la spinBox ne contient qu'une valeur, pas deux.

Pour le passage des valeurs, tu fais comme fred1599 t'a dit, tu en fait des attributs d'instance avec self.
11/11/2015, 11h22
Invité

variables

bonjour,
merci pour vos réponses et votre aide!
j'arrive à me dépatouiller dans mes variables!
merci encore:D

variables et fonciton

Bonjour,
je pensais avoir pigé... en fait non...

voici mon code, il me permet de tracer un cercle avec plus ou moins de points (le nombre de points étant lié au spin bouton) de la fenetre principale. Tel quel il est le programme tourne plutôt bien (à mes yeux) mais il me reste encore un détail.

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
from PyQt5 import QtCore
from PyQt5.QtWidgets import *
from PyQt5.QtCore import *
from PyQt5.QtGui import *
import os,sys
import numpy as np
from pylab import *
 
 
class fenPrincipale(QMainWindow):
    def __init__(self):
        global theta, x, y, nb_points
        QMainWindow.__init__(self)
        fenetre_widget = QWidget()
        self.pen=QPen()
        self.nb_points=QSpinBox()
        self.nb_points.setRange(3, 350)
 
        self.scene=QGraphicsScene()
        self.scene.setSceneRect(0,0,0,0)
 
        LayoutV=QVBoxLayout()
        LayoutV.addWidget(self.nb_points)
        self.view =QGraphicsView(self.scene)
        LayoutV.addWidget(self.view)
 
        fenetre_widget.setLayout(LayoutV)
        self.setCentralWidget(fenetre_widget)
 
        nb_points=self.nb_points.value()
        theta = np.linspace(0, 2*np.pi, nb_points+1)
        x = np.cos(theta)
        y = np.sin(theta)
 
        self.nb_points.valueChanged.connect(self.dessin_graphique)      
 
    def dessin_graphique(self):
        self.scene.clear()
        nb_points=self.nb_points.value()
        theta = np.linspace(0, 2*np.pi, nb_points+1)
        x = np.cos(theta)
        y = np.sin(theta)
        for i in range(0, nb_points):
            self.scene.addLine(x[i]*100,y[i]*100,x[i+1]*100,y[i+1]*100,self.pen)
 
    #def representation_table(self):
    #    self.scene.clear()
    #    nb_points=self.nb_points.value()
    #    theta = np.linspace(0, 2*np.pi, nb_points+1)
    #    x = np.cos(theta)
    #    y = np.sin(theta)
    #    for i in range(0, nb_points):
    #        self.scene.addLine(x[i]*100,y[i]*100,x[i+1]*100,y[i+1]*100,self.pen)
 
    def initialisation(self):
        nb_points=self.nb_points.value()
        theta = np.linspace(0, 2*np.pi, nb_points+1)
        x = np.cos(theta)
        y = np.sin(theta)
 
 
 
def main(args):
    appli=QApplication(args)
    fenetre=fenPrincipale()
    fenetre.show()
    r=appli.exec_()
    return r
 
if __name__=="__main__":
    main(sys.argv)

j'aimerais utiliser la fonction "initialisation" pour assigner les valeurs des variables x, y, theta et nb_points au sein d'une seule procédure... là actuellement ma fonction "dessin graphique" gère directement ces variables en interne mais j'aimerais traiter ça dans une autre fonction. En effet j'aurais plein d'autre fonctions (similaires à "dessin graphique") à ajouter et qui feraient appel à ces même assignation de variables... Et je trouve dommage de répéter dans chacune de mes futures fonctions des lignes de code identiques...

donc en gros j'aimerais pouvoir supprimer ces lignes:

Code:

1
2
3
4
        nb_points=self.nb_points.value()
        theta = np.linspace(0, 2*np.pi, nb_points+1)
        x = np.cos(theta)
        y = np.sin(theta)

par un appel ver "initialisation".... et que celle ci me renvoie l'équivlent (en informations) des 4ligne de code ci dessus...

est-ce qu'il y a une solution simple?
merci

Salut,

"Il suffit" d'écrire une fonction:

Code:

1
2
3
4
5
def foo(nb_points):
        theta = np.linspace(0, 2*np.pi, nb_points+1)
        x = np.cos(theta)
        y = np.sin(theta)
        return x, y

Puis de corriger "dessin_graphique"

Code:

1
2
3
4
5
    def dessin_graphique(self, nb_points):
        self.scene.clear()
        x, y = foo(nb_points)
        for i in range(0, nb_points):
            self.scene.addLine(x[i]*100,y[i]*100,x[i+1]*100,y[i+1]*100,self.pen)

- W