Liste à nom variable

bonjour,

Tu pars dans une mauvaise direction en voulant ainsi "nommer" une liste.  Ce que tu souhaites faire, c'est, pour chaque cours, mémoriser deux éléments, un texte, et une liste de leçons.

La liste ne "porte" pas le nom du cours, tu crées une structure pour mémoriser un texte et une liste.

Puisque tu fais un exercice avec des listes, tu peux donc décider qu'un cours est une liste de deux éléments, le premier étant un texte, le second étant une liste, la liste des noms des leçons.

cours1=("nomdupremiercour",("nom d'une leçon", "nom d'une autre leçon"))
cours2=("nomdusecondcour",("nom d'une leçon du 2", "nom d'une autre leçon du 2"))
ecole=(cours1,cours2)
for c in ecole:
    nomducours,listelecons = c
    print("cours:", nomducours)
    for lecon in listelecons:
        print("    leçon:",lecon)

Bonjour,

Avant de plonger dans le code, je t'invite à d'abord réfléchir à la conception de ton programme.

1) Quelle est la la nature des données (ce qui correspond aux objets en programmation orientée objet) que doit manipuler le programme ?

• Qu'est-ce qui caractérise un cours ? Un nom et un liste de leçons ?
• Qu'est-ce qui caractérise un leçon ? Un nom et un nombre de révision ?

2) Quelles sont les fonctionnalités (ce qui correspond aux méthodes en programmation orientée objet) que doit réaliser le programme ?

• Création, liste, modification et suppression de cours ? Lister les leçons d'un cours ? Autre chose concernant les cours ? Quels sont les paramètres de chacune de ces fonctionnalités ? Par exemple, est-ce que lorsque tu listes les leçons d'un cours, l'énoncé attend de toi que tu puisses spécifier dans quel ordre dans lesquels les retourner ? Si oui, quels sont ces ordres ?
• Même questions pour les leçons.

3) Quelles sont les contraintes de programmation imposées par l'énoncé (ou tes connaissances). Connais-tu les classes et as-tu le droit de les utiliser ? Dois-tu te limiter au listes ?

Ce que je peux dire vu le message #4 :

• Tous les menus ne sont que de l'interface. En vrai c'est assez secondaire et tu peux tout à fait tester les différentes primitives que tu auras choisi d'implémenter dans ton programme principale en reproduisant les choix qu'auraient pu faire un utilisateur. Cela t'évitera de faire une saisie à chaque fois que tu veux traiter ton programme. Il sera toujours temps de l'exécuter au travers de ces menus par la suite.
• Tu devrais éviter d'employer des caractères accentués ou des cédilles dans tes noms de fonctions, car il y a de fortes chances pour que ton interpréteur python n'apprécie pas.
• Tu devrais nommer tes fonctions de sorte à les organiser par leur nom pour améliorer la lisibilité de ton programme. Par exemple toutes les fonctions en rapport avec un menu devraient sans doute avoir un nom qui commence par "menu_...". Car a terme j'imagine que tu auras des fonctions comme supprimer_cours ou supprimer_lecon et il ne faudrait pas qu'elles s'appellent toutes suppression :-)
• Quel est le rôle des leçons temporaire ? Ce n'est pas précisé dans l'énoncé que tu nous as transmis ?
• Ta fonction ajout_cours mélange des fonctionnalités a priori indépendantes les unes des autres.Pourquoi supprimer un cours temporaire ? Ce devrait être le rôle de l'appel supprimer_cours(cours, "temporaire") ? Pourquoi initialises-tu nouveau_cours à 0. En python ce serait plutôt None, et surtout, cette variable sera initialisée quoi qu'il arrive une fois que l'input correspondant aura été exécuté. L'initialisation à 0 (ou None) est donc superflue.

Bonne chance

As-tu essayé le code que tu nous présentes?
Tu parles de liste de listes, ce n'est pas ce que je trouve ici. Ça ressemble à une liste de chaînes.
Pourquoi créer une liste avec un nouveau nom? Tu fournis le nom de la liste dans le code.
Tu appelles ta fonction sans paramètre. Donc, la liste n'est pas fournie et non initialisée.

 Bonjour,

Étant donnée la réponse #6, la manière la plus naturelle d'aborder ton problème est d'écrire comme je le suggérais dans le message #4 d'écrire deux classes (respectivement Cours et Lecon). Bon si comme tu trouves ça moche par ce que ça fait "le con", tu peux rédiger ton programme en anglais (donc Lesson et Course), c'est plutôt une bonne habitude d'ailleurs dans l'absolu. Mais bref, je vais garder les mots français.

La classe Lecon est caractérisée par un nom et un nombre de revision donc elle ressemblerait à :

class Lecon:
    def __init__(self, nom: str, num_revisions: int = 0):
        self.nom = nom
        self.num_revisions = num_revisions
    def __repr__(self) -> str:
        return f"<self.__class_.__name__>({repr(self.nom)}, {self.num_revisions})"

Pour l'utiliser on peut par exemple écrire :

lecon = Lecon("ma leçon", num_revisions = 10)
print(lecon)
# Affiche <Lecon>('ma leçon', 10)

La classe Cours est caractérisée par un nom et un itérable (une liste par exemple) de Lecons. Vu qu'un cours est composé de 0 ou plusieurs leçons, il serait assez naturel de faire hériter la classe Cours de la classe list ce qui permettrait de bénéficier directement de ses méthodes sans avoir à les réimplémenter, en particulier son nombre d'élément, la possibilité d'itérer dessus, etc.

class Cours(list):
    def __init__(self, nom = "", *cls, **kwargs):
        kwargs.pop("nom", None)
        super().__init__(*cls, **kwargs)
        self.nom = nom
    def __repr__(self) -> str:
        return f"{self.__class__.__name__}<{self.nom}, {super().__repr__()}>"

Pour l'utiliser, on peut par exemple faire ceci : 

cours_maths = Cours("Maths", [Lecon(f"Leçon {i}", i * 2) for i in range(5)])
for lecon in cours_maths:
    print(lecon)
# Affiche :
# <Lecon>('Leçon 0', 0)
# <Lecon>('Leçon 1', 2)
# <Lecon>('Leçon 2', 4)
# <Lecon>('Leçon 3', 6)
# <Lecon>('Leçon 4', 8)

Ensuite, vu qu'il s'agit d'une liste, tu peux parfaitement utiliser la fonction sorted pour réordonner les éléments comme bon te semble (en particulier, avec une callback qui regarde le nombre de révisions de chacune des Lecons stockées dans le Cours).

print(sorted(cours_maths, key=lambda lecon: lecon.num_revisions))
#[<Lecon>('Leçon 0', 0),
# <Lecon>('Leçon 1', 2),
# <Lecon>('Leçon 2', 4),
# <Lecon>('Leçon 3', 6),
# <Lecon>('Leçon 4', 8)]

print(sorted(cours_maths, key=lambda lecon: lecon.num_revisions, reverse=True))
#[<Lecon>('Leçon 4', 8),
# <Lecon>('Leçon 3', 6),
# <Lecon>('Leçon 2', 4),
# <Lecon>('Leçon 1', 2),
# <Lecon>('Leçon 0', 0)]

Libre à toi de définir une méthode dans Cours, par exemple afficherLecons, qui itère sur le résultat de sorted pour faire l'affichage de ton choix.

Je te laisse également consulter les méthodes de liste pour voir comment les utiliser (suppression, mise à jour, etc.) et éventuellement les surcharger si le besoin s'en fait sentir.

Bonne chance