Projet informatique liste

**Clems33440** · 07/01/2018, 12h27

Bonjour,
J'aurai besoin d'aider pour mon projet, j'ai plusieurs question dont je vais lister :

1) Je n'arrive pas a faire fonctionner mes fonctions je sais pas si c'est a cause de mes parametres ou pas ?
2) Je dois utiliser la fonction str_liste pour faire afficher les liste correctement sauf que je ne vois pas ou le placer?
3) Mon fichier csv fonctionne mais je ne sais pas comment je dois faire pour sauvegarder les donnée si par exemple j'ajoute un cours
4) Pour l'interface de l'utilisateur, je voulais que l'utilisateur choisisse sauf que j'ai peur que ca sois trop long

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
# ==============================================================================
# GESTION PLANNING : 
# ==============================================================================
from liste import *
 
class Cours(object):
    def __init__ (self, date_creneau =201712200 ,dic_prof=" ",dic_salle=" ",
                  dic_groupe=" "):
        self.date_creneau = date_creneau 
        self.dic_prof = dic_prof
        self.dic_salle = dic_salle
        self.dic_groupe = dic_groupe
 
    def __lt__(self, cours):
        return self.date_creneau < cours.date_creneau
    def __eq__(self, cours):
        return self.date_creneau == cours.date_creneau
 
# ==============================================================================
def lecture_csv(nom):
    "Lit le fichier csv"
    assert isinstance (nom, str), "Type nom incorrect, il faut un nom"
 
    # var
    n = 0                       # int
    # begin
    # creation de dictionnaire libre
    dictionnaire_prof = {}
    dictionnaire_salle = {}
    dictionnaire_groupe = {}
    fichier = open(nom, "r")    # ouvre le csv
    l = fichier.readlines ()
    fichier.close ()            # ferme le fichier 
    n = len(l)-1
    while n != -1 :             # part a la fin puis on remonte 
        # begin
        a = l[n]
        a = a[:len(a)-1]
        s = a.split(",")
        c = Cours (int(s[0]),s[1],s[2],s[3]) #fichier excel coder date pour que ca le donne en nombre
        # Associer les element de la classe "cours"
 
        if c.dic_prof not in dictionnaire_prof :             # la clé n'existe pas 
            dictionnaire_prof[c.dic_prof] = liste()          # crée une clé qui devient une liste
        dictionnaire_prof[c.dic_prof].insere_en_tete(c)      # ajouter le cours dans le planning
 
        if c.dic_salle not in dictionnaire_salle :           # la clé n'existe pas
            dictionnaire_salle[c.dic_salle] = liste()        # crée une clé qui devient une liste
        dictionnaire_salle[c.dic_salle].insere_en_tete(c)    # ajouter le cours dans le planning
 
        if c.dic_groupe not in dictionnaire_groupe :         # la clé n'existe pas 
            dictionnaire_groupe[c.dic_groupe] = liste()      # crée une clé qui devient une liste
        dictionnaire_groupe[c.dic_groupe].insere_en_tete(c)  # ajouter le cours dans le planning
        n = n-1
        # end
    return (dictionnaire_prof, dictionnaire_salle, dictionnaire_groupe)
    # end
 
# ==============================================================================
def conv_dc(date_creneau):
    "Convertis la date_creneau en str"
    assert isinstance (date_creneau, int), "Type date_creneau incorrect, il faut un int"
 
    # var
    date_creneau_str = ""       # str
    date_creneau_creneau = ""   # str
    date_creneau_annee = ""     # str
    date_creneau_mois = ""      # str
    date_creneau_jour = ""      # str
 
    # begin
    date_creneau_str = str(date_creneau)            # convertie en str
    date_creneau_creneau = date_creneau_str [8:]    # prend le dernier element
    date_creneau_jour = date_creneau_str [6:]       # prend les trois dernier
    date_creneau_jour = date_creneau_jour[:2]       # garde les deux premier
    date_creneau_mois = date_creneau_str [4:]       # prend les cinq dernier
    date_creneau_mois = date_creneau_mois [:2]      # garde les deux premier
    date_creneau_annee = date_creneau_str[:4]       # prend les quatre premier
 
    # cree une chaine de caractere qui forme la date et le creneau a la suite
    return str(date_creneau_jour) + '/' + str(date_creneau_mois) + '/' + str(date_creneau_annee) + ' ' + str(date_creneau_creneau)
 
# ==============================================================================
def bisextile(date_creneau) :
    """ Renvoie True, si l'année est bisextile, False sinon"""
    assert isinstance(date_creneau, int), "Type annee incorrect, il faut un int"
 
    # begin
    date_creneau_str = str(date_creneau)                # convertis en str pour recuperer l'année 
    date_creneau_annee = date_creneau_str[:4]           # on recupere juste l'année (donc les 4 premiers
    date_creneau_annee_int = int(date_creneau_annee)    # convertis en int pour l'utiliser
 
    return (date_creneau_annee_int % 4 == 0 and date_creneau_annee_int % 100 != 0) or (date_creneau_annee_int % 400 == 0)
 
    # end
 
# ==============================================================================
def jours_apres (date_creneau):
    """Permet de connaitre le jour d'apres"""
    assert isinstance (date_creneau,int), "Type date_creneau est incorrecte"
 
    # var
    date_creneau_str = ""           # str
    date_creneau_creneau = ""       # str
    date_creneau_annee = ""         # str
    date_creneau_mois = ""          # str
    date_creneau_jour = ""          # str
    date_creneau_apres = ""         # str
    date_creneau_creneau_int = 0    # int
    date_creneau_annee_int = 0      # int
    date_creneau_mois_int = 0       # int
    date_creneau_jour_int = 0       # int
 
 
    # begin
    date_creneau_str = str(date_creneau)                # convertis date_creneau en str
    date_creneau_creneau = date_creneau_str [8:]        # prend le dernier
    date_creneau_jour = date_creneau_str [6:]           # prend les 3 derniers 
    date_creneau_jour = date_creneau_jour[:2]           # garde les deux premiers
    date_creneau_jour_int = int(date_creneau_jour)      # convertis en int
    date_creneau_mois = date_creneau_str [4:]           # prend les 5 dernier
    date_creneau_mois = date_creneau_mois [:2]          # garde les 2 premier
    date_creneau_mois_int = int(date_creneau_mois)      # convertis en int
    date_creneau_annee = date_creneau_str[:4]           # prend les 4 premier
    date_creneau_annee_int = int(date_creneau_annee)    # convertis en int
 
    # cas ou le creneau correspond au dernier entier
    if date_creneau_creneau == "4" :
 
        # cas pour les mois avec 31 jours
        if (date_creneau_mois == "01" or date_creneau_mois == "03" or date_creneau_mois == "05" or date_creneau_mois == "07" or
            date_creneau_mois == "08" or date_creneau_mois == "10") and date_creneau_jour == "31":
            # begin
            date_creneau_mois = str(date_creneau_mois_int + 1)  # ajoute un mois en plus 
 
            if len(date_creneau_mois) == 1 :                    # le chiffre est plus petit que 10
                date_creneau_mois = "0" + date_creneau_mois     # rajoute un 0 pour que le str soit composer de deux chiffres
            else :                                              
                date_creneau_mois                               # sinon on renvoie le mois
 
            date_creneau_jour = "01"                            # le jour repasse au premier
            date_creneau_creneau = "0"                          # le creneau redevient le premier
            # end
 
        # cas pour les mois avec 30 jours
        elif (date_creneau_mois == "04" or date_creneau_mois == "06" or date_creneau_mois == "09" or
              date_creneau_mois == "11") and date_creneau_jour == "30":
            # begin
            date_creneau_mois = str(date_creneau_mois_int + 1)  # ajoute un mois en plus
 
            if len(date_creneau_mois) == 1 :                    # chiffre est plus petit que 10
                date_creneau_mois = "0" + date_creneau_mois     # rajoute un 0 pour que le str soit composer de deux chiffres
            else :
                date_creneau_mois                               # sinon on renvoie le mois
 
            date_creneau_jour = "01"                            # le jour repasse au premier
            date_creneau_creneau = "0"                          # le creneau redevient le premier
            # end
 
        # cas bisextile et fevrier
        elif bisextile (date_creneau) == True and date_creneau_mois == "02" and date_creneau_jour == "29":
            # begin
            date_creneau_mois = "03"        # le mois passe au prochaine c'est-a-dire mars (03)
            date_creneau_jour = "01"        # le jour repasse au premier
            date_creneau_creneau = "0"      # le creneau redevient le premier
            # end
 
        # cas non bisextile et fevrier
        elif bisextile (date_creneau) == False and date_creneau_mois == "02" and date_creneau_jour == "28":
            # begin
            date_creneau_mois = "03"        # le mois passe au prochaine c'est-a-dire mars (03)
            date_creneau_jour = "01"        # le jour repasse au premier
            date_creneau_creneau = "0"      # le creneau redeviens le premier
            # end
 
        # cas dernier jour de l'année
        elif date_creneau_mois == "12" and date_creneau_jour == "31" :
            # begin
            date_creneau_mois = "01"                                # le mois repasse au premier
            date_creneau_jour = "01"                                # le jour repasse au premier
            date_creneau_annee = str(date_creneau_annee_int + 1)    # ajoute un an en plus
            date_creneau_creneau = "0"                              # le creneau redeviens le premier
            # end
 
        # sinon on ajoute un jour
        else :
            # begin
            date_creneau_jour = str(date_creneau_jour_int + 1)      # ajoute un jour en plus
            if len(date_creneau_jour) == 1 :                        # chiffre est plus petit que 10
                date_creneau_jour = "0" + date_creneau_jour         # rajoute un 0 pour que le str soit composer de deux chiffres
            else :
                date_creneau_jour                                   # sinon on renvoie le jour
            date_creneau_creneau = "0"                              # le creneau redeviens le premier
            # end
 
    # on ajoute un creneau tant que on est pas a 4
    else :
        # begin
        date_creneau_creneau = str(date_creneau_creneau_int + 1)    # ajoute un creneau en plus
        # end
 
    # creation de la nouvelle date 
    date_creneau_apres = date_creneau_annee + date_creneau_mois + date_creneau_jour + date_creneau_creneau
 
    # convertis la date en int et aussi grâcea a la fonction au-dessus
    return conv_dc(int(date_creneau_apres))
    # end
 
# ==============================================================================
def verifier_1 (dic,date_creneau) :
    """ fonction qui verifie si la date_creneau  est libre dans le planning donné"""
    assert isinstance (dic, liste), "Type dic incorrect, il faut une liste"
    assert isinstance (date_creneau, int), "Type date_creneau incorrect, il faut un int"
 
    # var
    ptr = None      # on utilise un pointeur pour parcourir la liste
 
    # begin
    ptr = dic.debut # on place le pointeur au debut de la liste
 
    while ptr != None and ptr.valeur < date_creneau :  # on arrete quand on est arriver a la fin ou que l'on a trouve la valeur
        # begin
        if ptr.valeur == date_creneau :
            return False
        ptr = ptr.suivant
        # end
    return True
    # end
 
# ==============================================================================
def verifier_2 (dic1,dic2, date_creneau):
    """ fonction qui verifie si la date_creneau  est libre dans les deux planning donné"""
    assert isinstance (dic1, liste), "Type dic1 incorrect, il faut une liste"
    assert isinstance (dic2, liste), "Type dic2 incorrect, il faut une liste"
    assert isinstance (date_creneau, int), "Type date_creneau incorrect, il faut un int"
 
    # il faut que les deux planning sois libre pour que ca soit vrai 
    if verifier_1(dic1,date_creneau)== True and verifier_1(dic2,date_creneau) == True :
        return True
    return False
 
# ==============================================================================
def verifier_3 (dic1,dic2,dic3, date_creneau):
    """ fonction qui verifie si la date_creneau  est libre dans les trois planning donné"""
    assert isinstance (dic1, liste), "Type dic1 incorrect, il faut une liste"
    assert isinstance (dic2, liste), "Type dic2 incorrect, il faut une liste"
    assert isinstance (dic3, liste), "Type dic3 incorrect, il faut une liste"
    assert isinstance (date_creneau, int), "Type date_creneau incorrect, il faut un int"
 
    # il faut que les trois planning sois libre pour que ca soit vrai 
    if verifier_2(dic1,dic2,date_creneau)== True and verifier_1(dic3,date_creneau) == True :
        return True
    return False
 
# ==============================================================================
def ajoute_cours(date_creneau,dic_prof,dic_salle,dic_groupe):
    """ Ajouter un cours dans les planning respectifs, seulement si c’est possible"""
    assert isinstance (dic_prof, liste), "Type dic1 incorrect, il faut une liste"
    assert isinstance (dic_salle, liste), "Type dic2 incorrect, il faut une liste"
    assert isinstance (dic_groupe, liste), "Type dic3 incorrect, il faut une liste"
    assert isinstance (date_creneau, int), "Type date_creneau incorrect, il faut un int"
 
    #var
    c = Cours()
    #begin
    c = Cours(date_creneau,dic_prof,dic_salle,dic_groupe)
    # on verifie si les planning sont disponible 
    if verifier_3 (dic_prof,dic_salle,dic_groupe,date_creneau) == True :
        # begin
        dictionnaire_prof[dic_prof].insere_triee(c)
        dictionnaire_salle[dic_salle].insere_triee(c)
        dictionnaire_groupe[dic_groupe].insere_triee(c)
        # end
    else:
        ("Ce n'est pas possible!")
    # end
 
# ==============================================================================
def supprime_cours(date_creneau,dic,dic_prof,dic_salle,dic_groupe):
    "Supprimer un cours d’un des planning"
    assert isinstance (dic, liste), "Type dic1 incorrect, il faut une liste"
    assert isinstance (date_creneau, int), "Type date_creneau incorrect, il faut un int"
    assert isinstance (dic_salle, liste), "Type dic_salle incorrect, il faut une liste"
    assert isinstance (dic_groupe, liste), "Type dic_groupe incorrect, il faut une liste"
    assert isinstance (dic_prof, liste), "Type dic_prof incorrect, il faut une liste"
 
    # var
    ptr_dic = None #on utilise un pointeur pour se deplacer dans le dic
    c = cours()
    # begin
    c = cours(date_creneau,dic_prof,dic_salle,dic_groupe)
    # avant on verifie si le cours que l'on veut supprimer existe
    if verifier_1(dic,date_creneau.c)== False :
        return ("On peut supprimer")
 
    # On place le pointeur au debut de liste
    ptr_dic = dic.debut
 
    if ptr_dic.valeur == c :
        supprime_en_tete(dic)
    else :
        # begin
        while ptr_dic != None and ptr_dic.valeur < c :
            ptr_dic = ptr_dic.suivant
        ptr.suivant = ptr.suivant.suivant
        # end
    # end
    return dic
 
# ==============================================================================
def mise_a_jour (date_creneau,dic1,dic2,dic_prof, dic_salle, dic_groupe):
    """ mise a jour des autres dictionnaire apres suppression d'un cours"""
    assert isinstance (dic1, liste), "Type dic1 incorrect, il faut une liste"
    assert isinstance (dic2, liste), "Type dic2 incorrect, il faut une liste"
    assert isinstance (date_creneau, int), "Type date_creneau incorrect, il faut un int"
    assert isinstance (dic_salle, liste), "Type dic_salle incorrect, il faut une liste"
    assert isinstance (dic_groupe, liste), "Type dic_groupe incorrect, il faut une liste"
    assert isinstance (dic_prof, liste), "Type dic_prof incorrect, il faut une liste"
 
    supprime_cours (date_creneau, dic1, dic_prof, dic_salle, dic_groupe)
    supprime_cours (date_creneau, dic2, dic_prof, dic_salle, dic_groupe)   
 
# ==============================================================================   
def liste_couples_libres (dic, date_creneau_1, date_creneau_2):
    """Entre deux dates données génére la liste des couples libres pour un planning"""
    assert isinstance (dic,liste), "Type dic incorrect, il faut une liste"
    assert isinstance (date_creneau_1, int), "Type date_creneau_1 incorrect, il faut un int"
    assert isinstance (date_creneau_2, int), "Type date_creneau_2 incorrect, il faut un int"
 
    # var
    liste_dates = liste()   # liste
 
    # begin
    liste_date = liste()    # crée une liste vide
 
    while date_creneau_1 != date_creneau_2:
        # begin
        if verifie1(dic,date_creneau_1) == True :    # on regarde si la date_creneau exite
            liste_dates.insere_triee(date_creneau_1)
        date_creneau_1 = jours_apres(date_creneau_1)  #on passe au prochain, creneau ou jour
        # end
    return liste_dates
    # end
 
# ==============================================================================
def liste_couples_libres_2( dic1, dic2, date_creneau_1, date_creneau_2):
    """Entre deux dates données génére la liste des couples libres pour deux planning"""
    assert isinstance (dic1,liste), "Type dic1 incorrect, il faut une liste"
    assert isinstance (dic2,liste), "Type dic2 incorrect, il faut une liste"
    assert isinstance (date_creneau_1, int), "Type date_creneau_1 incorrect, il faut un int"
    assert isinstance (date_creneau_2, int), "Type date_creneau_2 incorrect, il faut un int"
 
    # var
    liste_dates = liste()               # liste
    date_creneau_liste_dic1 = liste()   # liste
    date_creneau_liste_dic2 = liste()   # liste
    ptr1 = None                         # pointeur
    ptr2 = None                         # pointeur
 
    # begin
    date_creneau_liste_dic1= liste()    # creation d'une liste vide
    date_creneau_liste_dic2 = liste()   # creation d'une liste vide
    liste_dates = liste ()              # cree une liste vide
 
    # Recupere les date_creneau libres pour le premier dic et le deuxieme dic
    date_creneau_liste_dic1 = liste_couples_libres(dic1, date_creneau_1, date_creneau_2)
    date_creneau_liste_dic2 = liste_couples_libres(dic2, date_creneau_1, date_creneau_2)
 
    #On place les pointeur au debut des listes
    ptr1 = date_creneau_liste_dic1.debut
    ptr2 = date_creneau_liste_dic2.debut
 
    while ptr2 != None :
        # begin
        while ptr1 != None and ptr1.valeur < ptr2.valeur :
            # begin
            if ptr1.valeur == ptr2.valeur :
                liste_dates.insere_triee(ptr1.valeur)
            ptr1 = ptr1.suivant
            # end
        ptr2 = ptr2.suivant
        # end
    return liste_dates
    # end
 
# ==============================================================================
def salles_disponibles (date_creneau_1,date_creneau_2, dic_prof, dic_groupe, dic_salle, dictionnaire_salle):
    """Générer la liste des salles disponibles"""
    assert isinstance (date_creneau_1, int), "Type date_creneau_1 incorrect, il faut un int"
    assert isinstance (date_creneau_2, int), "Type date_creneau_2 incorrect, il faut un int"
    assert isinstance (dic_prof, liste), "Type dic_prof incorrect, il faut une liste"
    assert isinstance (dic_groupe, liste), "Type dic_groupe incorrect, il faut une liste"
    assert isinstance (dic_salle, liste), "Type dic_salle incorrect, il faut une liste"
    assert isinstance (dictionnaire_salle, dict), "Type dico incorrect, il faut un dictionnaire"
 
    # var
    liste_dates = liste ()          # liste
    nom_des_salles = liste ()       # liste
    liste_salles = liste()          # liste
    liste_salles_dispo = liste()    # liste
    ptr_liste_dates = None          # Pointeur
    ptr_nom_des_salles = None       # Pointeur
    ptr_liste_salles = None         # Pointeur
 
    # begin
    nom_des_salles = liste()        # création d'une liste vide
    liste_dates = liste()           # création d'une liste vide
    liste_salles = liste()          # création d'une liste vide
    liste_salles_dispo = liste()    # création d'une liste vide
 
    # Recupérer les noms des salles à l'aide des clé du dictionnaire
    for cle in dictionnire_salle.keys():
        nom_des_salles.insere_en_tete(cle)
 
    # Permet d'avoir les date disponibles entre le planning des prof et celle des groupe
    liste_dates = liste_couples_2(dic_prof,dic_groupe,date_creneau_1,date_creneau_2)
    # Permet d'avoir les date disponibles pour le planning des salles
    liste_salles = liste_couples_1(dic_salle,date_creneau_1,date_creneau_2)
 
    #On place les pointeur aux debut des liste
    ptr_liste_dates = liste_dates.debut
    ptr_nom_des_salles = nom_des_salles.debut
    ptr_liste_salles = liste_salles.debut
 
    while ptr_liste_dates != None :
        # begin
        while ptr_nom_des_salles != None :
            while ptr_liste_salles != None and ptr_liste_salles.valeur < ptr_liste_dates.valeur :
                # begin
                if ptr_liste_salles.valeur == ptr_liste_dates.valeur :
                    liste_salles_dispo.insere_triee((ptr_listes_dates.valeur,ptr_nom_des_salles))
                ptr_liste_salles = ptr_liste_salles.suivant
                # end
            ptr_nom_des_salles = ptr_nom_des_salles.suivant
        # end
        ptr_liste_dates = ptr_liste_dates.suivant
 
    return liste_salles_dispo
    # end
 
# ==============================================================================
 
def main() :
    """ Explication de ce que fait le programme """
    cours = [Cours(*ligne) for ligne in lecture_csv("gestion_planning.csv")]
 
 
    #end
 
#-----------------------------------------------------------------------------------
if __name__ == "__main__" :
    main()

et voici le fichier que je doit me servir pour les liste parce que je ne peux pas utiliser les liste classique de python

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
class cellule(object):
    def __init__(self,valeur=0,suivant=None):
        #begin
        self.valeur = valeur
        self.suivant = suivant
        #end
 
class liste(object):
    def __init__(self,cell=None):
        #begin
        self.debut = cell
        #end
 
    def liste_vide(self):
        #begin
        return self.debut == None
        #end
 
    def tete(self):
        #begin
        return self.debut.valeur
        #end
 
    def corps(self):
        #begin
        return liste(self.debut.suivant)
        #end
 
    def insere_en_tete(self,valeur):
        #begin
        self.debut = cellule(valeur,self.debut)
        #end
 
    def construit_liste(self,valeur):
        #begin
        return liste(cellule(valeur,self.debut))
        #end
 
    def supprime_en_tete(self):
        #begin
        self.debut= self.debut.suivant
        #end
 
    def str_liste(self):
        #var
        ptr = None # on utilise un pointure sur les cellules
        resultat = " " #str
 
        #begin
        ptr = self.debut()
        # on parcourt les éléments pour arriver a la fin
        while ptr != None : # tant qu'on est pas arriver a la fin
            #begin
            resultat = resultat + str(ptr.valeur) + "->"
            ptr = ptr.suivant
            #end
        return resultat
        #end
 
    def insere_en_position (self, pos, valeur):
        #var
        ptr = None #on utilise un pointeur sur les cellules
        cpt = 0 #int
        cell = cellule() # on déclare une cellule
 
        #begin
        if pos == 0 : # cas particulier insere en premier
            cell.suivant = self.debut
            self.debut = cell
        else : # on parcours tous les element pour arriver a la position
            #begin
            ptr = self.debut
            cpt = 0
            while cpt < pos-1 :
                #begin
                cpt = cpt + 1
                ptr = ptr.suivant
                #end
            cell.suivant = ptr.suivant
            ptr.suivant = cell
            #end
        #end
 
    def insere_triee (self, valeur):
        #var
        cell = cellule ()
 
        #begin
        cell.valeur = valeur
        #cas 0 : la liste est vide, on insere en tete
        #cas 1 : la valeur est inferieur a la valeur de la premier case
        if self.debut == None or valeur <= l.debut.valeur :
            #begin
            cell.suivant = self.debut
            self.debut = cell
            #end
        #cas 2 : on parcours la liste pour trouver la bonne position
        #on a deux sous cas : la valeur peut etre au mieux ou en fin de liste
        # il faut deux pointeur : ptr et ptr_prec
        else :
            #begin
            ptr =self.debut.suivant #met le pointeur sur la 2ème cellule
            ptr_prec = self.debut  #met le ptr_prec sur la 1ère cellule
            # on arrete quand on est arrivée a la fin ou a la bonne valeur
            while ptr != None and ptr.valeur < valeur :
                #begin
                ptr_prec = ptr
                ptr = ptr.suivant
                #end
            cell.suivant = ptr_prec.suivant
            ptr_prec.suivant = cell
            #end
        #end

**VinsS** · 07/01/2018, 14h49

Salut,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
def main() :
    """ Explication de ce que fait le programme """
    cours = [Cours(*ligne) for ligne in lecture_csv("gestion_planning.csv")]

Tu ne fais que créer une liste de trois instances de Cours avec les trois dictionnaires retournés par lecture_csv("gestion_planning.csv").

Et puis ton programme s'arrête là.

J'ai tout de même parcouru ton code, si vous devez créer vous-même un type liste, ok mais est-ce pareil pour datetime ?

**Clems33440** · 07/01/2018, 15h29

Je viens de me rendre compte que cette ligne de coder n'est pas a etre dans mon programme .
Oui nous créons nous meme les liste a l'aide du module qui est donne en dessous du code

**Clems33440** · 07/01/2018, 15h30

Pour datetime je ne sais pas ce que c'est

**VinsS** · 07/01/2018, 16h45

Ben, si la fonction main() n'a rien à faire dans ton code, alors comment s'exécute ce code ?

Peut-être prévoit-tu une interface mais en attendant ?

Le module datetime va te faire économiser les deux tiers de ton code.
https://docs.python.org/3/library/datetime.html

À utiliser absolument, plus de risque d'erreur.

**Clems33440** · 07/01/2018, 20h25

mais j'ai essayé de tester mes fonction avec les paramètre que j'ai mais ca me met qu'elles sont pas defini alors que je l'es aies dans mon fichier csv

**wiztricks** · 07/01/2018, 20h55

Envoyé par Clems33440

mais j'ai essayé de tester mes fonction avec les paramètre que j'ai mais ca me met qu'elles sont pas defini alors que je l'es aies dans mon fichier csv

Un fichier CSV ne contient pas de fonctions!
Montrer ce que vous avez essayé, expliquer le résultat que vous cherchiez à obtenir et poster les erreurs retournées serait un bon début.

- W

**Clems33440** · 07/01/2018, 21h11

dans les fonction par exemple la premier qui consiste a verifier un date est disponible ou non
j'ai fait verifier_1(201801180, dictionnaire_prof["nom du prof"])
ca m'affiche que dictionnaire_prof n'existe par alors que je l'ai cree dans le csv
sauf que mes dictionnaire sont compose de liste et je ne sais pas comment je peut les recupere ses liste

**Clems33440** · 07/01/2018, 21h43

De toute facon c'est trop tard j'ai du rendre mon projet

Projet informatique liste

Python

Discussions similaires

Partager

Partager