Problème de bugs en Python.

Version imprimable

20/03/2012, 14h47
cocoricoco

Problème de bugs en Python.
Bonjour à tous. J'ai des problèmes de bugage en python, je sollicite donc votre aide afin d'arriver à avoir mon algorithme de juste. en vous remerciant par avance.
Code:

1 2 3 4 5 class unite_enseignement(object): def__init__(self): self.code_numerique=0 self.nom="" self.coefficient=0.0
lorsque je lance F5, j'ai un message d'erreur qui surligne le ":" après def__init__(self):

Comment y remédier ?
20/03/2012, 15h32
VinsS

L'espace entre 'def' et '__init__' ?

P.S. et tant que tu as le doigt sur la barre d'espace, ajoutes en de part et d'autre de chaque symbole égal, sera plus joli.

Merci Vinss.

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
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
 
class unite_enseignement(object):
    def init__(self):
        self.code_numerique=0
        self.nom=""
        self.coefficient=0.0
 
class note_unite_enseignement (object):
    def init__(self):
        self.code_numerique=0
        self.note_controle_continu=0.0
        self.note_examen=0.0
        self.moyenne=0.0
        self.valide=True
 
class etudiant (object):
    def init__(self):
        self.numero=0
        self.nom=""
        self.prenom=""
        self.tab_note_UE=[note_UE() for p in range (6)]
        self.moyenne_semestre=0.0
        self.semestre_valide=True
 
#--------------------------------------------------------------------------------
import io        
def lire_ligne(fichier) :
    """ retourne une ligne lue dans un fichier texte en la débarrassant des
        caractères spéciaux """
    assert isinstance(fichier, io.TextIOBase), "Type fichier incorrect"
 
    #begin
    return fichier.readline().strip()
    #end
#--------------------------------------------------------------------------------
 
def separe_ligne (ligne):
    assert isinstance (ligne, str), "type incorrect pour ligne"
    #var
    j=0 #int
    mot="" #str
    t=["" for p in range (30)] 
    lettre = "" #str
 
    #begin
    mot=""
    j=1
    for lettre in ligne:
        #begin
        if (lettre != ";"):
            mot=mot+lettre
        else :
            #begin
            t[j]=mot
            mot=""
            j=j+1
            #end
        #end
    return(t)
    #end
 
#-----------------------------------------------------------------------------
 
def charge_UE (nom_fichier):
    assert isinstance (nom_fichier, str) , "type incorrect pour nom_fichier"
    #var
    les_UE={}
    ligne="" #str
    t=["" for p in range (30)]
    f= io.TextIOBase()
 
    #begin
    f=open(nom_fichier,'r')
    ligne=lire_ligne(f)
    while (ligne != "") :
        #begin
        ue=unite_enseignement()
        t=separe_ligne(ligne)
        cle=t[1]
        ue.nom=t[2]
        ue.coefficient=t[3]
        ue.code_numerique=cle
        les_UE[cle]=ue
        ligne=lire_ligne(f)
        #end
    f.close()
    return(les_UE)
    #end
 
#-----------------------------------------------------------------------------
 
def charge_note (nom_fichier):
    assert isinstance (nom_fichier,str) ;  "type incorrect pour nom_fichier"
    #var
    i=0 #int
    j=0 #int
    t1=["" for p in range(30)]
    ligne="" #str
    t2=[etudiant() for p in range (200)]
    etud=etudiant()
    note_UE=note_unite_enseignement()
    f= io.TextIOBase()
 
    #begin
    j=0
    f=open(nom_fichier,'r')
    lire=lire_ligne(f)
    while (ligne != ""):
        #begin
        t1=separe_ligne(ligne)
        etud.numero=t1[1]
        etud.nom=t1[2]
        etud.prenom=t1[3]
        i=4
        for note_UE in etud.tab_note_UE :
            if i<21:
                #begin
                note_UE.code_numerique=t[i]
                note_UE.note_controle_continu=t[i+1]
                note_UE.note_examen=t[i+2]
                #end
        t2[j]=etudiant()
        j=j+1
        ligne=lire_ligne(nom_fichier)
        #end
    f.close()
    return(t2)
    #end
 
#----------------------------------------------------------------------------
 
def calcul_note_UE (note_UE, les_UE):
    assert isinstance (note_UE, note_unite_enseignement) ; "type incorrect pour nom_fichier"
    assert isinstance (les_UE,dict) ; "type incorrect pour nom_fichier"
 
    #begin
    note_UE.moyenne=(1-unite_enseignement.coefficient_examen)*note_UE.note_controle_continu+note_UE.note_examen *unite_enseignement.coefficient_examen
    if note_UE.moyenne<10:
        note_UE.valide=False
    else:
        note_UE.valide=True
    #end
 
#--------------------------------------------------------------------------------------
 
def calcul_etudiant (etud, les_UE):
    assert isinstance (etud, etudiant()) ; " type incorrect pour etud "
    assert isinstance (les_UE, dict) ; " type incorrect pour les UE "
    #var
    i=0 #int
    somme_moyenne=0.0 #float
 
    #begin
    i=1
    somme_moyenne=0.0
    for i in ["" for p in range(6)]:
        #begin
        read(etud.tab_note_UE[i])
        somme_moyenne=somme_moyenne+note_UE.moyenne
        #end
    etud.moyenne_semestre=somme_moyenne/6
    if etud.moyenne_semestre<10:
        etud.semestre_valide=False
    else :
        #begin
        etud.semestre_valide=True
        for note_UE in tab_note_UE:
            note_UE.valide=True
        #end
    #end
 
#--------------------------------------------------------------------------------
 
def main ():
    #var
    t= [etudiant() for p in range (200)]
    etud = etudiant()
    les_UE = {}
 
    #begin
    t=charge_note("note_etudiant.csv")
    les_UE=charge_UE("unite_enseignement.csv")
    for etud in t :
        #begin
        for i in range(6):
            calcul_note_UE(etud.tab_note_UE[i],les_UE)
        calcul_etudiant(etud,les_UE)
        #end
    print(affiche_etudiant)
    #end
#--------------------------------------------------------------------------------
if __name__ == "__main__" :
    main()

Code:

1
2
3
4
5
6
7
8
 
 
Traceback (most recent call last):
  File "\\fs1pedago.pedago.cri.u-bordeaux2.fr\Comptes_LDAP\rlagar910e\Documents\asd\projet\PYTHOOOON.py", line 193, in <module>
    main()
  File "\\fs1pedago.pedago.cri.u-bordeaux2.fr\Comptes_LDAP\rlagar910e\Documents\asd\projet\PYTHOOOON.py", line 184, in main
    print(etud.tab_note_UE)
AttributeError: 'etudiant' object has no attribute 'tab_note_UE'

Savez vous à quoi ça correspond ou pas ? Je n'arrive vraiment pas à le débuguer...

21/03/2012, 17h18
VinsS

cocoricoco, il faut absolument que tu mettes ton code entre deux balises code

Là, ton code n'est pas lisible.

Edit: Par contre, je peu déjà te dire que 'print(etud.tab_note_UE)' n'est pas dans le code que tu donnes et que tes classes ne sont jamais instanciées, il faut absolument utiliser '__init__()' et tu as ommis les deux tirets de début dans la plupart de tes classes.

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
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
class unite_enseignement(object):
    def init__(self):
        self.code_numerique=0
        self.nom=""
        self.coefficient=0.0
 
class note_unite_enseignement (object):
    def init__(self):
        self.code_numerique=0
        self.note_controle_continu=0.0
        self.note_examen=0.0
        self.moyenne=0.0
        self.valide=True
 
class etudiant (object):
    def init__(self):
        self.numero=0
        self.nom=""
        self.prenom=""
        self.tab_note_UE=[note_UE() for p in range (6)]
        self.moyenne_semestre=0.0
        self.semestre_valide=True
 
#--------------------------------------------------------------------------------
import io        
def lire_ligne(fichier) :
    """ retourne une ligne lue dans un fichier texte en la débarrassant des
        caractères spéciaux """
    assert isinstance(fichier, io.TextIOBase), "Type fichier incorrect"
 
    #begin
    return fichier.readline().strip()
    #end
#--------------------------------------------------------------------------------
 
def separe_ligne (ligne):
    assert isinstance (ligne, str), "type incorrect pour ligne"
    #var
    j=0 #int
    mot="" #str
    t=["" for p in range (30)] 
    lettre = "" #str
 
    #begin
    mot=""
    j=1
    for lettre in ligne:
        #begin
        if (lettre != ";"):
            mot=mot+lettre
        else :
            #begin
            t[j]=mot
            mot=""
            j=j+1
            #end
        #end
    return(t)
    #end
 
#-----------------------------------------------------------------------------
 
def charge_UE (nom_fichier):
    assert isinstance (nom_fichier, str) , "type incorrect pour nom_fichier"
    #var
    les_UE={}
    ligne="" #str
    t=["" for p in range (30)]
    f= io.TextIOBase()
 
    #begin
    f=open(nom_fichier,'r')
    ligne=lire_ligne(f)
    while (ligne != "") :
        #begin
        ue=unite_enseignement()
        t=separe_ligne(ligne)
        cle=t[1]
        ue.nom=t[2]
        ue.coefficient=t[3]
        ue.code_numerique=cle
        les_UE[cle]=ue
        ligne=lire_ligne(f)
        #end
    f.close()
    return(les_UE)
    #end
 
#-----------------------------------------------------------------------------
 
def charge_note (nom_fichier):
    assert isinstance (nom_fichier,str) ;  "type incorrect pour nom_fichier"
    #var
    i=0 #int
    j=0 #int
    t1=["" for p in range(30)]
    ligne="" #str
    t2=[etudiant() for p in range (200)]
    etud=etudiant()
    note_UE=note_unite_enseignement()
    f= io.TextIOBase()
 
    #begin
    j=0
    f=open(nom_fichier,'r')
    lire=lire_ligne(f)
    while (ligne != ""):
        #begin
        t1=separe_ligne(ligne)
        etud.numero=t1[1]
        etud.nom=t1[2]
        etud.prenom=t1[3]
        i=4
        for note_UE in etud.tab_note_UE :
            if i<21:
                #begin
                note_UE.code_numerique=t[i]
                note_UE.note_controle_continu=t[i+1]
                note_UE.note_examen=t[i+2]
                #end
        t2[j]=etudiant()
        j=j+1
        ligne=lire_ligne(nom_fichier)
        #end
    f.close()
    return(t2)
    #end
 
#----------------------------------------------------------------------------
 
def calcul_note_UE (note_UE, les_UE):
    assert isinstance (note_UE, note_unite_enseignement) ; "type incorrect pour nom_fichier"
    assert isinstance (les_UE,dict) ; "type incorrect pour nom_fichier"
 
    #begin
    note_UE.moyenne=(1-unite_enseignement.coefficient_examen)*note_UE.note_controle_continu+note_UE.note_examen *unite_enseignement.coefficient_examen
    if note_UE.moyenne<10:
        note_UE.valide=False
    else:
        note_UE.valide=True
    #end
 
#--------------------------------------------------------------------------------------
 
def calcul_etudiant (etud, les_UE):
    assert isinstance (etud, etudiant()) ; " type incorrect pour etud "
    assert isinstance (les_UE, dict) ; " type incorrect pour les UE "
    #var
    i=0 #int
    somme_moyenne=0.0 #float
 
    #begin
    i=1
    somme_moyenne=0.0
    for i in ["" for p in range(6)]:
        #begin
        read(etud.tab_note_UE[i])
        somme_moyenne=somme_moyenne+note_UE.moyenne
        #end
    etud.moyenne_semestre=somme_moyenne/6
    if etud.moyenne_semestre<10:
        etud.semestre_valide=False
    else :
        #begin
        etud.semestre_valide=True
        for note_UE in tab_note_UE:
            note_UE.valide=True
        #end
    #end
 
#--------------------------------------------------------------------------------
 
def main ():
    #var
    t= [etudiant() for p in range (200)]
    etud = etudiant()
    les_UE = {}
 
    #begin
    t=charge_note("note_etudiant.csv")
    les_UE=charge_UE("unite_enseignement.csv")
    for etud in t :
        #begin
        for i in range(6):
            calcul_note_UE(etud.tab_note_UE[i],les_UE)
        calcul_etudiant(etud,les_UE)
        #end
    print(affiche_etudiant)
    #end
#--------------------------------------------------------------------------------
if __name__ == "__main__" :
    main()

21/03/2012, 17h44
VinsS

Je confirme mon édit du message précédent, tes classes ne sont pas instanciées.
21/03/2012, 17h48
cocoricoco

Je ne comprends pas du tout ce que tu dis. Ca signifie quoi que mes classes sont pas instanciées ? Je ne comprends pas non plus pour le print (etud.tab_note) c'est quoi les 2 tirets de début ? et c'est quoi '__init__' ? Je suis désolé, mais je suis une bille
21/03/2012, 18h47
VinsS
C'est simple, pour instancier tes classes tu dois utiliser:
Code:

1 2 def __init__(self):
et non pas:
Code:

1 2 def init__(self):
et pour 'print (etud.tab_note)', c'était le message d'erreur indiqué dans ton deuxième post.
21/03/2012, 19h04
cocoricoco

c'est quoi alors qui cloche, comment le corriger ?
22/03/2012, 07h36
Sve@r

Citation:

Envoyé par cocoricoco

c'est quoi alors qui cloche, comment le corriger ?

Ben en commençant au-moins par lire un livre Python et en étudiant le chapitre où ça parle de classes. Ce code ne peut pas être de toi car sinon tu saurais ce qu'est __init__().

Déjà petite optimisation: ta ligne ["" for x in range(30)] peut se simplifier en ["",] * 30. Idem pour ton t=[etudiant() for p in range (200)] qui peut s'écrire t= [etudiant(),]*200.

Ensuite ta fonction lire_ligne est un peu inutile. Oui je sais que c'est plus évolutif car peut-être que demain la structure du fichier peut changer et donc qu'il sera plus facile d'adapter ce changement si la lecture du fichier passe par une fonction centralisée mais Python possède déjà pas mal de fonctions dédiées à la manipulation des chaines et facilement utilisables donc il y a peu de risque que ta fonction "lire_ligne" contienne quelque chose de plus complexe qu'un readline().strip().

Donc pour ton pb tu regardes l'enchainement des erreurs qui te donne tout l'historique des appels (ligne X appelle telle fonction qui amène à ligne Y qui appelle telle fonction qui appelle ligne Z etc etc. Tu prends la dernière ligne de cet enchainement, tu regardes le code source et tu vérifies que l'instruction est correcte avec les bons paramètres et que leur valeur est bonne. Si c'est bon tu remontes un cran avant etc etc etc.

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
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
class unite_enseignement(object):
    def __init__(self):
        self.code_numerique=0
        self.nom=""
        self.coefficient=0.0
 
class note_unite_enseignement (object):
    def __init__(self):
        self.code_numerique=0
        self.note_controle_continu=0.0
        self.note_examen=0.0
        self.moyenne=0.0
        self.valide=True
 
class etudiant (object):
    def __init__(self):
        self.numero=0
        self.nom=""
        self.prenom=""
        self.tab_note_UE=[note_unite_enseignement() for p in range (6)]
        self.moyenne_semestre=0.0
        self.semestre_valide=True
 
#--------------------------------------------------------------------------------
import io        
def lire_ligne(fichier) :
    """ retourne une ligne lue dans un fichier texte en la débarrassant des
        caractères spéciaux """
    assert isinstance(fichier, io.TextIOBase), "Type fichier incorrect"
 
    #begin
    return fichier.readline().strip()
    #end
#--------------------------------------------------------------------------------
 
def separe_ligne (ligne):
    assert isinstance (ligne, str), "type incorrect pour ligne"
    #var
    j=0 #int
    mot="" #str
    t=["" for p in range (30)] 
    lettre = "" #str
 
    #begin
    mot=""
    j=1
    for lettre in ligne:
        #begin
        if (lettre != ";"):
            mot=mot+lettre
        else :
            #begin
            t[j]=mot
            mot=""
            j=j+1
            #end
        #end
    t[j]=mot
    return(t)
    #end
 
#-----------------------------------------------------------------------------
 
def charge_UE (nom_fichier):
    assert isinstance (nom_fichier, str) , "type incorrect pour nom_fichier"
    #var
    les_UE={}
    ligne="" #str
    t=["" for p in range (30)]
    f= io.TextIOBase()
 
    #begin
    f=open(nom_fichier,'r')
    ligne=lire_ligne(f)
    while (ligne != "") :
        #begin
        ue=unite_enseignement()
        t=separe_ligne(ligne)
        cle=t[1]
        ue.nom=t[2]
        ue.coefficient=float(t[3])
        ue.code_numerique=int(cle)
        les_UE[int(cle)]=ue
        ligne=lire_ligne(f)
        #end
    f.close()
    for cle in les_UE :
        print(les_UE[cle].code_numerique, les_UE[cle].nom)
    return(les_UE)
    #end
 
#-----------------------------------------------------------------------------
 
def charge_note (nom_fichier):
    assert isinstance (nom_fichier,str) ;  "type incorrect pour nom_fichier"
    #var
    i=0 #int
    j=0 #int
    t1=["" for p in range(30)]
    ligne="" #str
    t2=[etudiant() for p in range (17)]
    etud=etudiant()
    note_UE=note_unite_enseignement()
    f= io.TextIOBase()
 
    #begin
    j=0
    f=open(nom_fichier,'r')
    ligne=lire_ligne(f)
    while (ligne != ""):
        #begin
        t1=separe_ligne(ligne)
        etud = etudiant()
        etud.numero=t1[1]
        etud.nom=t1[2]
        etud.prenom=t1[3]
        print(etud.numero,etud.nom) 
        i=4
        for note_UE in etud.tab_note_UE :
            if i<21:
                #begin
                note_UE.code_numerique=int(t1[i])
                note_UE.note_controle_continu=float(t1[i+1])
                note_UE.note_examen=float(t1[i+2])
                #end
        t2[j]=etud
        j=j+1
        ligne=lire_ligne(f)
        #end
    f.close()
    print(t2[0].nom)
    return(t2)
    #end
 
#----------------------------------------------------------------------------
 
def calcul_note_UE (note_UE, les_UE):
    assert isinstance (note_UE, note_unite_enseignement) ; "type incorrect pour nom_fichier"
    assert isinstance (les_UE,dict) ; "type incorrect pour nom_fichier"
 
    #var
 
    #begin
    # print(note_UE.code_numerique)
    coef = les_UE[note_UE.code_numerique].coefficient
    note_UE.moyenne=(1-coef)*note_UE.note_controle_continu+note_UE.note_examen *coef
    if note_UE.moyenne<10:
        note_UE.valide=False
    else:
        note_UE.valide=True
    #end
 
#--------------------------------------------------------------------------------------
 
def calcul_etudiant (etud, les_UE):
    assert isinstance (etud, etudiant) ; " type incorrect pour etud "
    assert isinstance (les_UE, dict) ; " type incorrect pour les_UE "
    #var
    i=0 #int
    somme_moyenne=0.0 #float
 
    #begin
    i=1
    somme_moyenne=0.0
    for i in range(6):
        #begin
        print(etud.tab_note_UE[i].code_numerique)
        somme_moyenne=somme_moyenne+etud.tab_note_UE[i].moyenne
        #end
    etud.moyenne_semestre=somme_moyenne/6.0
    if etud.moyenne_semestre<10:
        etud.semestre_valide=False
    else :
        #begin
        etud.semestre_valide=True
        for note_UE in etud.tab_note_UE:
            note_UE.valide=True
        #end
    #end
#--------------------------------------------------------------------------------
 
def affiche_etudiant(etud, les_UE):
    assert isinstance (etud,etudiant) ; "type incorrect pour etud"
    assert isinstance (les_UE,dict) ; "type incorrect pour les_UE"
    #var
    note_UE=note_unite_enseignement
    UE=unite_enseignement
 
    #begin
    print("***********************")
    print("Numéro étudiant:" , etud.numero)
    print("Nom étudiant:" , etud.nom)
    print("prenom étudiant:" , etud.prenom)
    if etud.semestre_valide==True:
        print("Semestre:validé")
    else:
        print("Semestre:non validé")
    for note_UE in etud.tab_note_UE:
        #begin
        if note_UE.valide==True:
            print("UE" , UE.nom,"validé")
        else:
            print("UE", UE.nom, "non validé")
        #end
    print("***********************")
    #end
 
#--------------------------------------------------------------------------------
 
def main ():
    #var
    t= [etudiant() for p in range (17)]
    etud = etudiant()
    les_UE = {}
 
    #begin
    t=charge_note("note_etudiant.csv")
    les_UE=charge_UE("unite_enseignement.csv")
    for etud in t :
        #begin
        print(etud.nom)
        for i in range(6):
            print(etud.tab_note_UE[i].code_numerique)
            calcul_note_UE(etud.tab_note_UE[i],les_UE)
        calcul_etudiant(etud,les_UE)
        #end
        affiche_etudiant(etud, les_UE)
    #end
#--------------------------------------------------------------------------------
if __name__ == "__main__" :
    main()

Voilà où j'en suis, maintenant voilà le bug :

Traceback (most recent call last):
File "\\fs1pedago.pedago.cri.u-bordeaux2.fr\Comptes_LDAP\rlagar910e\Documents\asd\projet\PYTHOOOON.py", line 231, in <module>
main()
File "\\fs1pedago.pedago.cri.u-bordeaux2.fr\Comptes_LDAP\rlagar910e\Documents\asd\projet\PYTHOOOON.py", line 227, in main
affiche_etudiant(etud, les_UE)
File "\\fs1pedago.pedago.cri.u-bordeaux2.fr\Comptes_LDAP\rlagar910e\Documents\asd\projet\PYTHOOOON.py", line 203, in affiche_etudiant
print("UE", UE.nom, "non validé")
AttributeError: type object 'unite_enseignement' has no attribute 'nom'

Dans ce que tu me dis, je ne fais que suivre les instructions de mon prof. Donc tout ce qui est syntaxe des tableaux, je garde comme ça. Comment débuguer le reste ?

On ne sais pas tester ton code, vu les fichiers csv nécessaires.

Mais ici:

Code:

1
2
3
4
5
6
7
 
def affiche_etudiant(etud, les_UE):
    assert isinstance (etud,etudiant) ; "type incorrect pour etud"
    assert isinstance (les_UE,dict) ; "type incorrect pour les_UE"
    #var
    note_UE=note_unite_enseignement
    UE=unite_enseignement

Je pense que ce doit être:

Code:

1
2
3
 
    note_UE=note_unite_enseignement()
    UE=unite_enseignement()

Sans les parenthèses, ça ne marche pas.

Le dernier bug et après j'ai fini mon projet. J'ai ma fonction bonus qui enregistre sous .txt le résultat. Seul hic : quand j'exécute, elle ne met dans le fichier que le dernier étudiant et pas tous comme elle est censée le faire (dans affiche etudiant, ca marche) :/
Savez vous comment faire ? (Tout le reste marche etje vous en remercie encore !)

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
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
class unite_enseignement(object):
    def __init__(self):
        self.code_numerique=0
        self.nom=""
        self.coefficient=0.0
 
class note_unite_enseignement (object):
    def __init__(self):
        self.code_numerique=0
        self.note_controle_continu=0.0
        self.note_examen=0.0
        self.moyenne=0.0
        self.valide=True
 
class etudiant (object):
    def __init__(self):
        self.numero=0
        self.nom=""
        self.prenom=""
        self.tab_note_UE=[note_unite_enseignement() for p in range (6)]
        self.moyenne_semestre=0.0
        self.semestre_valide=True
 
#--------------------------------------------------------------------------------
import io        
def lire_ligne(fichier) :
    """ retourne une ligne lue dans un fichier texte en la débarrassant des
        caractères spéciaux """
    assert isinstance(fichier, io.TextIOBase), "Type fichier incorrect"
 
    #begin
    return fichier.readline().strip()
    #end
#--------------------------------------------------------------------------------
 
def separe_ligne (ligne):
    assert isinstance (ligne, str), "type incorrect pour ligne"
    #var
    j=0 #int
    mot="" #str
    t=["" for p in range (30)] 
    lettre = "" #str
 
    #begin
    mot=""
    j=1
    for lettre in ligne:
        #begin
        if (lettre != ";"):
            mot=mot+lettre
        else :
            #begin
            t[j]=mot
            mot=""
            j=j+1
            #end
        #end
    t[j]=mot
    return(t)
    #end
 
#-----------------------------------------------------------------------------
 
def charge_UE (nom_fichier):
    assert isinstance (nom_fichier, str) , "type incorrect pour nom_fichier"
    #var
    les_UE={}
    ligne="" #str
    t=["" for p in range (30)]
    f= io.TextIOBase()
 
    #begin
    f=open(nom_fichier,'r')
    ligne=lire_ligne(f)
    while (ligne != "") :
        #begin
        ue=unite_enseignement()
        t=separe_ligne(ligne)
        cle=t[1]
        ue.nom=t[2]
        ue.coefficient=float(t[3])
        ue.code_numerique=int(cle)
        les_UE[int(cle)]=ue
        ligne=lire_ligne(f)
        #end
    f.close()
    return(les_UE)
    #end
 
#-----------------------------------------------------------------------------
 
def charge_note (nom_fichier):
    assert isinstance (nom_fichier,str) ;  "type incorrect pour nom_fichier"
    #var
    i=0 #int
    j=0 #int
    t1=["" for p in range(30)]
    ligne="" #str
    t2=[etudiant() for p in range (17)]
    etud=etudiant()
    note_UE=note_unite_enseignement()
    f= io.TextIOBase()
 
    #begin
    j=0
    f=open(nom_fichier,'r')
    ligne=lire_ligne(f)
    while (ligne != ""):
        #begin
        etud=etudiant()
        t1=separe_ligne(ligne)
        etud = etudiant()
        etud.numero=t1[1]
        etud.nom=t1[2]
        etud.prenom=t1[3]
        i=4
        for note_UE in etud.tab_note_UE :
            if i<21:
                #begin
                note_UE.code_numerique=int(t1[i])
                note_UE.note_controle_continu=float(t1[i+1])
                note_UE.note_examen=float(t1[i+2])
                i=i+3
                #end
        t2[j]=etud
        j=j+1
        ligne=lire_ligne(f)
        #end
    f.close()
    return(t2)
    #end
 
#----------------------------------------------------------------------------
 
def calcul_note_UE (note_UE, les_UE):
    assert isinstance (note_UE, note_unite_enseignement) ; "type incorrect pour nom_fichier"
    assert isinstance (les_UE,dict) ; "type incorrect pour nom_fichier"
 
    #var
 
    #begin
    coef = les_UE[note_UE.code_numerique].coefficient
    note_UE.moyenne=(1-coef)*note_UE.note_controle_continu+note_UE.note_examen *coef
    if note_UE.moyenne<10:
        note_UE.valide=False
    else:
        note_UE.valide=True
    #end
 
#--------------------------------------------------------------------------------------
 
def calcul_etudiant (etud, les_UE):
    assert isinstance (etud, etudiant) ; " type incorrect pour etud "
    assert isinstance (les_UE, dict) ; " type incorrect pour les_UE "
    #var
    i=0 #int
    somme_moyenne=0.0 #float
 
    #begin
    i=1
    somme_moyenne=0.0
    for i in range(6):
        #begin
        somme_moyenne=somme_moyenne+etud.tab_note_UE[i].moyenne
        #end
    etud.moyenne_semestre=somme_moyenne/6.0
    if etud.moyenne_semestre<10:
        etud.semestre_valide=False
    else :
        #begin
        etud.semestre_valide=True
        for note_UE in etud.tab_note_UE:
            note_UE.valide=True
        #end
    #end
#--------------------------------------------------------------------------------
 
def affiche_etudiant(etud, les_UE):
    assert isinstance (etud,etudiant) ; "type incorrect pour etud"
    assert isinstance (les_UE,dict) ; "type incorrect pour les_UE"
    #var
    note_UE=note_unite_enseignement
    UE=unite_enseignement
 
    #begin
    print("***********************")
    print("Numéro étudiant:" , etud.numero)
    print("Nom étudiant:" , etud.nom)
    print("Prénom étudiant:" , etud.prenom)
    if etud.semestre_valide==True:
        print("Semestre:validé")
    else:
        print("Semestre:non validé")
 
 
    for note_UE in etud.tab_note_UE:
        #begin
        if note_UE.valide==True:
            print("UE" , les_UE[note_UE.code_numerique].nom ,"validé")
        else:
            print("UE", les_UE[note_UE.code_numerique].nom , "non validé")
        #end
    print("***********************")
    #end
 
#--------------------------------------------------------------------------------
 
def bonus (etud,les_UE) :
    assert isinstance (etud,etudiant) ; "type incorrect pour etud"
    assert isinstance (les_UE,dict) ; "type incorrect pour les_UE"
 
 
 
    #begin
    fichier=open("Bonus.txt", 'w')
    fichier.write("***********************")
    fichier.write ('\n')
    fichier.write("Numéro étudiant: " + etud.numero)
    fichier.write ('\n')
    fichier.write("Nom étudiant: " + etud.nom)
    fichier.write ('\n')
    fichier.write("Prénom étudiant: " + etud.prenom)
    fichier.write ('\n')
    if etud.semestre_valide==True:
        fichier.write("Semestre : validé")
        fichier.write ('\n')
    else:
        fichier.write("Semestre : non validé")
        fichier.write ('\n')        
    for note_UE in etud.tab_note_UE:
        #begin
        if note_UE.valide==True:
            fichier.write("UE " + les_UE[note_UE.code_numerique].nom + " validé")
            fichier.write ('\n')
        else:
            fichier.write("UE " + les_UE[note_UE.code_numerique].nom + " non validé")
            fichier.write ('\n')
        #end
    fichier.write("***********************")
#---------------------------------------------------------------------------------
 
def main ():
    #var
    t= [etudiant() for p in range (17)]
    etud = etudiant()
    les_UE = {}
 
    #begin
    t=charge_note("note_etudiant.csv")
    les_UE=charge_UE("unite_enseignement.csv")
    for etud in t :
        #begin
        for i in range(6):
            calcul_note_UE(etud.tab_note_UE[i],les_UE)
        calcul_etudiant(etud,les_UE)
        affiche_etudiant(etud, les_UE)
        fichier=open("Bonus.txt", 'w')
        bonus(etud, les_UE)
        #end
    fichier.close()
 
    #end
 
#--------------------------------------------------------------------------------
 
if __name__ == "__main__" :
    main()

Citation:

Envoyé par cocoricoco

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
 
def bonus (etud,les_UE) :
    assert isinstance (etud,etudiant) ; "type incorrect pour etud"
    assert isinstance (les_UE,dict) ; "type incorrect pour les_UE"
 
    #begin
    fichier=open("Bonus.txt", 'w')
    fichier.write("***********************")
    fichier.write ('\n')
    fichier.write("Numéro étudiant: " + etud.numero)
    fichier.write ('\n')
    fichier.write("Nom étudiant: " + etud.nom)
    fichier.write ('\n')
    fichier.write("Prénom étudiant: " + etud.prenom)
    fichier.write ('\n')
    if etud.semestre_valide==True:
        fichier.write("Semestre : validé")
        fichier.write ('\n')
    else:
        fichier.write("Semestre : non validé")
        fichier.write ('\n')        
    for note_UE in etud.tab_note_UE:
        #begin
        if note_UE.valide==True:
            fichier.write("UE " + les_UE[note_UE.code_numerique].nom + " validé")
            fichier.write ('\n')
        else:
            fichier.write("UE " + les_UE[note_UE.code_numerique].nom + " non validé")
            fichier.write ('\n')
        #end
    fichier.write("***********************")
#---------------------------------------------------------------------------------
 
def main ():
    #var
    t= [etudiant() for p in range (17)]
    etud = etudiant()
    les_UE = {}
 
    #begin
    t=charge_note("note_etudiant.csv")
    les_UE=charge_UE("unite_enseignement.csv")
    for etud in t :
        #begin
        for i in range(6):
            calcul_note_UE(etud.tab_note_UE[i],les_UE)
        calcul_etudiant(etud,les_UE)
        affiche_etudiant(etud, les_UE)
        fichier=open("Bonus.txt", 'w')
        bonus(etud, les_UE)
        #end
    fichier.close()
 
    #end
 
#--------------------------------------------------------------------------------
 
if __name__ == "__main__" :
    main()

Renseigne-toi sur la signification du caractère "w" dans open() (on se demande d'ailleurs pourquoi tu fais 2 open pour écrire dans un fichier)

Accessoirement c'est dommage d'écrire 2 fonctions distinctes pour faire quasiment la même chose (à savoir afficher les étudiants dans un fichier et afficher les étudiants à l'écran). Si t'es malin tu écriras une fonction unique qui n'affiche rien mais qui renvoie la chaine à afficher et cette chaine c'est l'appelant qui l'affiche à l'écran ou dans un fichier selon le cas...