x object has no attribute y (PyQ4t et QLineEdit)

Version imprimable

Bonjour à tous,

Pourriez-vous m'aider car, là je bloque sérieusement 8O
Merçi d'avance,

Message d'erreur:

Citation:

AttributeError: 'Ui_FenPrincipale' object has no attribute 'm_call_input'

J'ai une classe

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def existCall(self):
        """ vérifie dans la liste si l'indicatif a déjà été contacté"""
        # BUG BUG BUG
        # je voudrais récupérer le contenu du QLineEdit (qui se nomme bien
        # m_call_input ) qui se trouve dans le fichier Fenetre.py et qui 
        # se trouve dans la classe Ui_FenPrincipale()
        obj_fen = Fenetre.Ui_FenPrincipale() 
        indicatif = obj_fen.m_call_input.text()
 
        # le code ci-dessous doit être faux aussi mais l'erreur ci-dessus 
        # m'empêche de continuer
        if indicatif in self.list_call:
            # il est déjà contacté        
            self.textEdit.setText("DUPE - DUPE - DUPE")
        else:
            self.textEdit.setText("NEW ONE - NEW ONE - NEW ONE ")

Cette méthode fait appel à un (attribut) QLineEdit nommé m_call_input qui appartient à une autre classe

Code:

class Ui_FenPrincipale(object):

voici la déclaration de cet attribut:

Code:

1
2
3
4
5
6
7
8
self.m_call_input = QtGui.QLineEdit(self.centralwidget)
 
        font = QtGui.QFont()
        font.setPointSize(12)
        self.m_call_input.setFont(font)
        self.m_call_input.setObjectName("m_call_input")
        self.hboxlayout.addWidget(self.m_call_input)
        self.vboxlayout.addLayout(self.hboxlayout)

Je ne comprend pas comment il faut que j'appelle cet attribut (en fait, je crois que j'ai tout essayé :oops: )

Voici le code complet:

Qt_Dupe_Call.py

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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
# !/usr/bin/python
# -*-coding: utf-8-*-
from Fenetre import *
from PyQt4.QtGui import *
from PyQt4.QtCore import *
 
import sys
import os
 
 
class app(object):
    """Affiche la fenêtre et crée les slots"""
 
    def __init__(self,args):
        self.qtapp = QtGui.QApplication(sys.argv)
 
        # pour que le contenu des boites de dialogues par défaut
        # soient dans la langue de l'OS */
        locale = QtCore.QLocale.system().name()
        qtTranslator = QtCore.QTranslator()
        qtTranslator.load("qt_" + locale),
        QLibraryInfo.location(QLibraryInfo.TranslationsPath)
        self.qtapp.installTranslator(qtTranslator)
 
        self.FenPrincipale = QtGui.QMainWindow()
        self.ui = Ui_FenPrincipale()
        self.ui.setupUi(self.FenPrincipale)
        self.FenPrincipale.show()
        # lecture du fichier au lancement du prg
        self.dc=dupe_call()
        self.dc.lecture_Call()
        # les slots
        # boutons
        self.qtapp.connect(self.ui.btn_quitter, QtCore.SIGNAL('clicked()'), 
        self.qtapp, QtCore.SLOT('quit()'))
        # menus
        self.qtapp.connect(self.ui.action_Quitter_2, QtCore.SIGNAL('triggered()'), 
        self.qtapp, QtCore.SLOT('quit()'))
        self.qtapp.connect(self.ui.actionA_Propos, QtCore.SIGNAL('triggered()'), 
        self.qtapp, QtCore.SLOT('aboutQt()'))
        #
        #autres
        self.qtapp.connect(self.ui.m_call_input, QtCore.SIGNAL('editingFinished()'), 
        self.ui.textEdit, dupe_call().existCall() )
 
 
        sys.exit(self.qtapp.exec_())
        self.dc.ecriture_Call()
 
class dupe_call(object):
    "vérifie si l'indicatif est déjà contacté (donc repris dans lae)" 
    def __init__(self):
        #self.ftexte = "call.txt"     # fichier contenant les indicatifs
        self.ftexte = "test.txt"      # fichier test pour les essais
        self.list_call = []  # creation d'une liste vide
 
    def lecture_Call(self):
        """ au lancement du programme, le fichier call.txt est lu et
        les indicatifs sont ajoutés à la liste """
 
        rep = os.getcwd() #renvoie le nom du répertoire courant
 
        #ouverture du fichier
        try:
            objFichier = open(rep+'/' + self.ftexte)
        except:
            # si le fichier n'existe pas encore il faut le créer
            # et l'ouvrir !!
 
            if QMessageBox.critical(None, "Fichier inexistant",(u"Le fichier "+ self.ftexte +u" est créé pour la première fois")):
                objFichier = open(self.ftexte, 'w') # si call.txt n'existe pas encore on le crée
                objFichier = open(rep+'/'+ self.ftexte) # on n'oublie pas d'ouvrir le fichier nouvellement créer
 
        # il faut lire le fichier call.txt et envoyer les indicatifs
        # vers la liste list_call
        try:
            for ligne in open(rep+'/'+ self.ftexte):
                for mot in ligne.split():
                    self.list_call.append(mot)
        except:
            QMessageBox.critical(None, u"Erreur de lecture",u"Il y a un problème de lecture du fichier "+ self.ftexte)
        finally:
            objFichier.close()
 
    def ecriture_Call(self):
        """
        sauvegarde dans un fichier des indicatifs contenu dans la liste
        pour une remise à jour de la dite liste au 
        prochain lancement du programme        
        """
 
        #ouverture du fichier
        objFichier = open(self.ftexte, 'w')
        try:
            x = 0
            while x < len(self.list_call):
                objFichier.write(upper(self.list_call[x]+' ') )
                x += 1
        except:
            QMessageBox.critical(None, "Erreur d'écriture","Il y a un problème d'écriture du fichier "+ self.ftexte)
        finally:
            objFichier.close()        
 
    def existCall(self):
        """ vérifie dans la liste si l'indicatif a déjà été contacté"""
        obj_fen = Ui_FenPrincipale() 
        indicatif = Ui_FenPrincipale().m_call_input.text()
 
        if indicatif in self.list_call:
            # il est déjà contacté        
            self.textEdit.setText("DUPE - DUPE - DUPE")
        else:
            self.textEdit.setText("NEW ONE - NEW ONE - NEW ONE ") 
 
def main(args):
    mapp = app(args)
 
 
if __name__=="__main__":
        main(sys.argv)

et la fenetre, Fenetre.py

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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
# -*- coding: utf-8 -*-
 
# Form implementation generated from reading ui file 'Qt_dupe_call.ui'
#
# Created: Wed Oct 15 19:55:17 2008
#      by: PyQt4 UI code generator 4.3.3
#
# WARNING! All changes made in this file will be lost!
 
from PyQt4 import QtCore, QtGui
 
class Ui_FenPrincipale(object):
    def setupUi(self, FenPrincipale):
        FenPrincipale.setObjectName("FenPrincipale")
        FenPrincipale.resize(QtCore.QSize(QtCore.QRect(0,0,414,314).size()).expandedTo(FenPrincipale.minimumSizeHint()))
 
        self.centralwidget = QtGui.QWidget(FenPrincipale)
        self.centralwidget.setGeometry(QtCore.QRect(0,24,414,266))
        self.centralwidget.setObjectName("centralwidget")
 
        self.vboxlayout = QtGui.QVBoxLayout(self.centralwidget)
        self.vboxlayout.setObjectName("vboxlayout")
 
        self.hboxlayout = QtGui.QHBoxLayout()
        self.hboxlayout.setObjectName("hboxlayout")
 
        self.label = QtGui.QLabel(self.centralwidget)
 
        font = QtGui.QFont()
        font.setFamily("Arial Black")
        font.setPointSize(12)
        self.label.setFont(font)
        self.label.setObjectName("label")
        self.hboxlayout.addWidget(self.label)
 
        self.m_call_input = QtGui.QLineEdit(self.centralwidget)
 
        font = QtGui.QFont()
        font.setPointSize(12)
        self.m_call_input.setFont(font)
        self.m_call_input.setObjectName("m_call_input")
        self.hboxlayout.addWidget(self.m_call_input)
        self.vboxlayout.addLayout(self.hboxlayout)
 
        self.vboxlayout1 = QtGui.QVBoxLayout()
        self.vboxlayout1.setObjectName("vboxlayout1")
 
        self.textEdit = QtGui.QTextEdit(self.centralwidget)
        self.textEdit.setObjectName("textEdit")
        self.vboxlayout1.addWidget(self.textEdit)
        self.vboxlayout.addLayout(self.vboxlayout1)
 
        self.hboxlayout1 = QtGui.QHBoxLayout()
        self.hboxlayout1.setObjectName("hboxlayout1")
 
        self.label_2 = QtGui.QLabel(self.centralwidget)
 
        font = QtGui.QFont()
        font.setFamily("Arial Black")
        font.setPointSize(12)
        self.label_2.setFont(font)
        self.label_2.setObjectName("label_2")
        self.hboxlayout1.addWidget(self.label_2)
 
        self.m_nbre_indicatifs = QtGui.QLabel(self.centralwidget)
 
        font = QtGui.QFont()
        font.setFamily("Arial Black")
        font.setPointSize(12)
        self.m_nbre_indicatifs.setFont(font)
        self.m_nbre_indicatifs.setAlignment(QtCore.Qt.AlignCenter)
        self.m_nbre_indicatifs.setObjectName("m_nbre_indicatifs")
        self.hboxlayout1.addWidget(self.m_nbre_indicatifs)
        self.vboxlayout.addLayout(self.hboxlayout1)
 
        self.hboxlayout2 = QtGui.QHBoxLayout()
        self.hboxlayout2.setObjectName("hboxlayout2")
 
        self.btn_ajouter = QtGui.QPushButton(self.centralwidget)
        self.btn_ajouter.setObjectName("btn_ajouter")
        self.hboxlayout2.addWidget(self.btn_ajouter)
 
        spacerItem = QtGui.QSpacerItem(40,20,QtGui.QSizePolicy.Expanding,QtGui.QSizePolicy.Minimum)
        self.hboxlayout2.addItem(spacerItem)
 
        self.btn_supprimer = QtGui.QPushButton(self.centralwidget)
        self.btn_supprimer.setObjectName("btn_supprimer")
        self.hboxlayout2.addWidget(self.btn_supprimer)
 
        spacerItem1 = QtGui.QSpacerItem(40,20,QtGui.QSizePolicy.Expanding,QtGui.QSizePolicy.Minimum)
        self.hboxlayout2.addItem(spacerItem1)
 
        self.btn_quitter = QtGui.QPushButton(self.centralwidget)
        self.btn_quitter.setObjectName("btn_quitter")
        self.hboxlayout2.addWidget(self.btn_quitter)
        self.vboxlayout.addLayout(self.hboxlayout2)
        FenPrincipale.setCentralWidget(self.centralwidget)
 
        self.menubar = QtGui.QMenuBar(FenPrincipale)
        self.menubar.setGeometry(QtCore.QRect(0,0,414,24))
        self.menubar.setObjectName("menubar")
 
        self.menu_Fichier = QtGui.QMenu(self.menubar)
        self.menu_Fichier.setObjectName("menu_Fichier")
 
        self.menu_Aide = QtGui.QMenu(self.menubar)
        self.menu_Aide.setObjectName("menu_Aide")
        FenPrincipale.setMenuBar(self.menubar)
 
        self.statusbar = QtGui.QStatusBar(FenPrincipale)
        self.statusbar.setGeometry(QtCore.QRect(0,290,414,24))
        self.statusbar.setObjectName("statusbar")
        FenPrincipale.setStatusBar(self.statusbar)
 
        self.actionAide = QtGui.QAction(FenPrincipale)
        self.actionAide.setObjectName("actionAide")
 
        self.actionA_Propos = QtGui.QAction(FenPrincipale)
        self.actionA_Propos.setObjectName("actionA_Propos")
 
        self.actionSupprimer_dernier = QtGui.QAction(FenPrincipale)
        self.actionSupprimer_dernier.setObjectName("actionSupprimer_dernier")
 
        self.action_Quitter = QtGui.QAction(FenPrincipale)
        self.action_Quitter.setObjectName("action_Quitter")
 
        self.actionSupprimer_indicatif = QtGui.QAction(FenPrincipale)
        self.actionSupprimer_indicatif.setObjectName("actionSupprimer_indicatif")
 
        self.action_Quitter_2 = QtGui.QAction(FenPrincipale)
        self.action_Quitter_2.setObjectName("action_Quitter_2")
        self.menu_Fichier.addAction(self.actionSupprimer_dernier)
        self.menu_Fichier.addAction(self.actionSupprimer_indicatif)
        self.menu_Fichier.addSeparator()
        self.menu_Fichier.addAction(self.action_Quitter_2)
        self.menu_Aide.addAction(self.actionAide)
        self.menu_Aide.addSeparator()
        self.menu_Aide.addAction(self.actionA_Propos)
        self.menubar.addAction(self.menu_Fichier.menuAction())
        self.menubar.addAction(self.menu_Aide.menuAction())
 
        self.retranslateUi(FenPrincipale)
        QtCore.QMetaObject.connectSlotsByName(FenPrincipale)
 
    def retranslateUi(self, FenPrincipale):
        FenPrincipale.setWindowTitle(QtGui.QApplication.translate("FenPrincipale", "PyQt Dupe call by ON4MIC", None, QtGui.QApplication.UnicodeUTF8))
        self.label.setText(QtGui.QApplication.translate("FenPrincipale", "Indicatif à vérifier", None, QtGui.QApplication.UnicodeUTF8))
        self.label_2.setText(QtGui.QApplication.translate("FenPrincipale", "Nombre d\'indicatifs", None, QtGui.QApplication.UnicodeUTF8))
        self.m_nbre_indicatifs.setText(QtGui.QApplication.translate("FenPrincipale", "0", None, QtGui.QApplication.UnicodeUTF8))
        self.btn_ajouter.setText(QtGui.QApplication.translate("FenPrincipale", "&Ajouter", None, QtGui.QApplication.UnicodeUTF8))
        self.btn_supprimer.setText(QtGui.QApplication.translate("FenPrincipale", "&Supprimer dernier", None, QtGui.QApplication.UnicodeUTF8))
        self.btn_quitter.setText(QtGui.QApplication.translate("FenPrincipale", "&Quitter", None, QtGui.QApplication.UnicodeUTF8))
        self.menu_Fichier.setTitle(QtGui.QApplication.translate("FenPrincipale", "&Fichier", None, QtGui.QApplication.UnicodeUTF8))
        self.menu_Aide.setTitle(QtGui.QApplication.translate("FenPrincipale", "&Aide", None, QtGui.QApplication.UnicodeUTF8))
        self.actionAide.setText(QtGui.QApplication.translate("FenPrincipale", "Aide", None, QtGui.QApplication.UnicodeUTF8))
        self.actionA_Propos.setText(QtGui.QApplication.translate("FenPrincipale", "A Propos", None, QtGui.QApplication.UnicodeUTF8))
        self.actionSupprimer_dernier.setText(QtGui.QApplication.translate("FenPrincipale", "Ajouter indicatif", None, QtGui.QApplication.UnicodeUTF8))
        self.action_Quitter.setText(QtGui.QApplication.translate("FenPrincipale", "&Quitter", None, QtGui.QApplication.UnicodeUTF8))
        self.actionSupprimer_indicatif.setText(QtGui.QApplication.translate("FenPrincipale", "Supprimer indicatif", None, QtGui.QApplication.UnicodeUTF8))
        self.action_Quitter_2.setText(QtGui.QApplication.translate("FenPrincipale", "&Quitter", None, QtGui.QApplication.UnicodeUTF8))
 
 
 
if __name__ == "__main__":
    import sys
    app = QtGui.QApplication(sys.argv)
    FenPrincipale = QtGui.QMainWindow()
    ui = Ui_FenPrincipale()
    ui.setupUi(FenPrincipale)
    FenPrincipale.show()
    sys.exit(app.exec_())

a+
EricStib

19/10/2008, 13h11
nyko77
ça ne viendrai pas du fait que ta classe Ui_FenPrincipale ne contient de méthode __init__?
Je ne connais pas QT mais Je vois que ta classe hérite de la classe objet, et je pense qu'il faut appeler la méthode __init__ de la classe objet.
Code:

1 2 3 4 class Ui_FenPrincipale(object): def _init__(self): objet.__init__(self)
19/10/2008, 16h21
EricStib

Bonjour et merçi,

Malheureusement, cela n'arrange rien à mon problème.

Mais je ne sais vraiment pas comment arranger cela.

Je pourrais remettre tout dans la classe App mais cela ne répondrait pas à la question : Qu'est-ce qui se passe dans ce foutu code :?

En tout cas, un grand merçi d'y avoir jeté un coup d'oeil.
Au plaisir,
EricStib
19/10/2008, 17h02
nyko77
Tu as bien mis le
Code:

1 2 self.m_call_input = QtGui.QLineEdit(self.centralwidget)
dans le __init__.

Dans le code que tu donnes self.m_call_input est initialisé seulement quand tu appels setupUi.
ça expliquerai le AttributeError: 'Ui_FenPrincipale' object has no attribute 'm_call_input'
19/10/2008, 18h45
EricStib
Re-bonjour,

J'appelle

Code:

self.ui.setupUi(self.FenPrincipale)

dans l'init de la classe App
Code:

1 2 3 4 class App(object): """Affiche la fenêtre et crée les slots""" def __init__(self,args): object.__init__(self)
Donc l'initialisation de

Code:

self.m_call_input = QtGui.QLineEdit(self.centralwidget)

devrait bien se faire dès que j'appelle
Code:

1 2 3 4 5 6 def main(args): mapp = App(args) if __name__=="__main__": main(sys.argv)
Car j'appelle la Fenetre.py par l'intermédiaire de Qt_Dupe_Call.py

En fait, je ne suis plus sûr de rien, je viens de passer tout le we à essayer de trouver... c'est sûrement une erreur de débutant (que je suis !) mais je n'arrive pas à mettre le doigt dessus.

Je crois que je vais revoir mes bases 8O

Encore merci pour ton aide,
Amicalement,
EricStib

Je pense que la notion d'objet n'est pas encore très clair pour toi.
Tu as 2 instance différente de Ui_FenPrincipale. La 1ere dans la classe app (self.ui) et la 2de dans la classe dupe_call (self.obj_fen).
Les instances fonctionnent séparément. Tu appels bien self.ui.setupUi dans la classe app, mais pas dans la classe dupe_call.
Je pense que ton erreur se trouve ici:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 def existCall(self): """ vérifie dans la liste si l'indicatif a déjà été contacté""" #ici tu créés une nouvelle instance de Ui_FenPrincipale obj_fen = Ui_FenPrincipale() #ici m_call_input n'existe pas car tu n'as pas encore appelé setupUi #d'où le message d'erreur qui t'indique que m_call_input n'existe pas indicatif = Ui_FenPrincipale().m_call_input.text() if indicatif in self.list_call: # il est déjà contacté self.textEdit.setText("DUPE - DUPE - DUPE") else: self.textEdit.setText("NEW ONE - NEW ONE - NEW ONE ")
Je pas vraiment regardé à quoi ton code sert, mais si tu veux utilisé l'instance qui se trouve dans la classe app, dans la classe dupe_call, il faut la passer en argument.

19/10/2008, 20h15
EricStib

Citation:

Je pense que la notion d'objet n'est pas encore très clair pour toi.

C'est un euphémisme :cry: Je vais revoir toutes mes bases car j'oublie trop de choses :oops:

Merçi pour tes explications qui m'ont ouvert les yeux !!

MAIS, je n'ai pas encore compris comment allez rechercher l'info de mon edit pour la passer en paramètre à ma fonction...

En tout cas, un grand merci, car maintenant je sais au moins où chercher.
a+
EricStib

Demi résolution

Bonjour à tous,

Suite aux remarques de

Citation:

nyko77

... et l'achat du livre sur Qt4 mais pour C++ :cry: je crois avoir trouvé comment résoudre mon problème mais je suis confronté à un "simple" problème de POO maintenant :oops:

En fait, je devrais faire "hériter" ma classe

Code:

def existCall(self):

de la classe

Code:

class App(object):

puisque, dans celle-çi se trouve

Code:

self.ui = Fenetre.Ui_FenPrincipale()

MAIS maintenant, j'ai ce message d'erreur suivant:

Citation:

File "/home/eric/Py_sources2/Qt_Dupe_Call/Qt_Dupe_Call.py", line 53, in __init__
App.__init__(self)
TypeError: __init__() takes exactly 2 arguments (1 given)

... et je ne sais pas quoi ajouter à part self... :oops:

Ici, c'est vraiment un petit problème de POO .. mais je suis vraiment trop débutant :aie:

Si vous pouviez jeter un coup d'oeil à la classe

Code:

1
2
3
4
5
6
7
class Dupe_call(App):
    "vérifie si l'indicatif est déjà contacté (donc repris dans lae)" 
    def __init__(self):
        App.__init__(self)
        #self.ftexte = "call.txt"     # fichier contenant les indicatifs
        self.ftexte = "test.txt"      # fichier test pour les essais
        self.list_call = []  # creation d'une liste vide

J'ai mis le code complet ici (sans le fenetre qui est déjà plus haut dans ce message.

Un grand merci pour votre attention et pour votre aide !!! :)

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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
# !/usr/bin/python
# -*-coding: utf-8-*-
#from Fenetre import *
#from PyQt4.QtGui import *
#from PyQt4.QtCore import *
from PyQt4 import QtCore, QtGui
 
import Fenetre
import sys
import os
 
 
class App(object):
    """Affiche la fenêtre et crée les slots"""
    def __init__(self,args):
        self.qtapp = QtGui.QApplication(sys.argv)
 
        # pour que le contenu des boites de dialogues par défaut
        # soient dans la langue de l'OS */
        locale = QtCore.QLocale.system().name()
        qtTranslator = QtCore.QTranslator()
        qtTranslator.load("qt_" + locale),
        QtCore.QLibraryInfo.location(QtCore.QLibraryInfo.TranslationsPath)
        self.qtapp.installTranslator(qtTranslator)
 
        self.FenPrincipale = QtGui.QMainWindow()
        self.ui = Fenetre.Ui_FenPrincipale()
        self.ui.setupUi(self.FenPrincipale)
        self.FenPrincipale.show()
        # lecture du fichier au lancement du prg
        self.dc=Dupe_call()
        self.dc.lecture_Call()
        # les slots
        # boutons
        self.qtapp.connect(self.ui.btn_quitter, QtCore.SIGNAL('clicked()'), 
        self.qtapp, QtCore.SLOT('quit()'))
        # menus
        self.qtapp.connect(self.ui.action_Quitter_2, QtCore.SIGNAL('triggered()'), 
        self.qtapp, QtCore.SLOT('quit()'))
        self.qtapp.connect(self.ui.actionA_Propos, QtCore.SIGNAL('triggered()'), 
        self.qtapp, QtCore.SLOT('aboutQt()'))
        #
        #autres
        self.qtapp.connect(self.ui.m_call_input, QtCore.SIGNAL('editingFinished()'), 
        self.ui.textEdit, Dupe_call().existCall() )
 
        sys.exit(self.qtapp.exec_())
        self.dc.ecriture_Call()
 
class Dupe_call(App):
    "vérifie si l'indicatif est déjà contacté (donc repris dans lae)" 
    def __init__(self):
        App.__init__(self)
        #self.ftexte = "call.txt"     # fichier contenant les indicatifs
        self.ftexte = "test.txt"      # fichier test pour les essais
        self.list_call = []  # creation d'une liste vide
 
    def lecture_Call(self):
        """ au lancement du programme, le fichier call.txt est lu et
        les indicatifs sont ajoutés à la liste """
        rep = os.getcwd() #renvoie le nom du répertoire courant
        #ouverture du fichier
        try:
            objFichier = open(rep+'/' + self.ftexte)
        except:
            # si le fichier n'existe pas encore il faut le créer
            # et l'ouvrir !!
            if QtCore.QMessageBox.critical(None, "Fichier inexistant",(u"Le fichier "+ self.ftexte +u" est créé pour la première fois")):
                objFichier = open(self.ftexte, 'w') # si call.txt n'existe pas encore on le crée
                objFichier = open(rep+'/'+ self.ftexte) # on n'oublie pas d'ouvrir le fichier nouvellement créer
        # il faut lire le fichier call.txt et envoyer les indicatifs
        # vers la liste list_call
        try:
            for ligne in open(rep+'/'+ self.ftexte):
                for mot in ligne.split():
                    self.list_call.append(mot)
        except:
            QtCore.QMessageBox.critical(None, u"Erreur de lecture",u"Il y a un problème de lecture du fichier "+ self.ftexte)
        finally:
            objFichier.close()
 
    def ecriture_Call(self):
        """
        sauvegarde dans un fichier des indicatifs contenu dans la liste
        pour une remise à jour de la dite liste au 
        prochain lancement du programme        
        """
        #ouverture du fichier
        objFichier = open(self.ftexte, 'w')
        try:
            x = 0
            while x < len(self.list_call):
                objFichier.write(self.list_call[x]+' ').upper()
                x += 1
        except:
            QtCore.QMessageBox.critical(None, "Erreur d'écriture","Il y a un problème d'écriture du fichier "+ self.ftexte)
        finally:
            objFichier.close()        
 
    def existCall(self):
        """ vérifie dans la liste si l'indicatif a déjà été contacté"""
        indicatif = self.ui.m_call_input.text()
 
        # le code ci-dessous doit être faux aussi mais l'erreur ci-dessus 
        # m'empêche de continuer
        if indicatif in self.list_call:
            # il est déjà contacté        
            self.textEdit.setText("DUPE - DUPE - DUPE")
        else:
            self.textEdit.setText("NEW ONE - NEW ONE - NEW ONE ") 
 
def main(args):
    mapp = App(args)
 
 
if __name__=="__main__":
    main(sys.argv)

Ta classe App attent un argument args.
Code:

1 2 3 4 class App(object): """Affiche la fenêtre et crée les slots""" def __init__(self,args):
Donc pour créer une instance de App il faut faire:
Code:

1 2 monApp = App(monArgument)
Si tu n'as besoin de args tu peux tout simplement l'enlever, et ça supprimera ton message d'erreur. Mais un nouveau va certainement apparaître.:(
Tes réflèxions ci-dessus n'ont aucun sens, tu n'as pas bien compris ce qu'était l'héritage. Je te conseil de lire (et comprendre) ça:
http://python.developpez.com/cours/TutoSwinnen/.
Il aborde la bibliothèque graphique Tkinter, ça me semble plus judicieux de commencer par là.

Je ne suis pas sur d'avoir compris ce que tu voulais faire mais si tu veux manipuler une fenêtre à partir de 2 classe il faut la passer en argument.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 Class Fenetre: def __init__(self): #création de la fenêtre Class A: def __init__(self): #on créé l'objet fenêtre self.objetFenetre = Fenetre() #on passe en argument l'instance de la fenêtre. objetB = B(self.objetFenetre) Class B: def __init__(self, objetFenetre): #on récupère l'instance de la fenêtre self.objetFenetre = objetFenetre monA = A()

23/10/2008, 23h00
EricStib

oui, bon, j'ai compris, je reprend mon étude de Python et je reviendrai dans quelques mois :oops: