Exercices non graphique

Nous allons utiliser le fichier ex1.zip, le dézipper et ouvrir le fichier exercice.py dans votre éditeur python.

Deux classes sont définies, la classe Eleve dont les méthodes sont les suivantes :

• __init__(self,nom,prenom) : Le constructeur, nom et prenom sont des chaînes de caractères(string).
• donne_nom(self) : Retourne le nom de l'élève sous forme d'une chaîne de caractères.
• donne_prenom(self) : Retourne le prénom de l'élève sous forme d'une chaîne de caractères.
• affiche_nom(self) : Affiche le nom de l’élève et ne retourne rien.
• affiche_prenom(self) : Affiche le nom de l’élève et ne retourne rien.
• donne_notes(self) : Retourne la liste des notes de l’élève.
• donne_moyenne(self) : Donne la moyenne de l'élève.
• ajoute_note(self, note) : Ajoute une note à l'élève.

La classe Classe, elle a pour but de réunir des élèves :

• __init__(self) : Constructeur de la classe.
• nb_eleves(self) : Donne le nombre d'élèves de la classe.
• ajoute_eleve(self, eleve) : Ajoute un élève (instance de la classe Eleve).
• donne_eleve(self, nom, prenom) : Retourne l'eleve de nom et prenom donné, si l'eleve n'est pas dans la classe retourne None.
• donne_liste_eleve(self) : Retourne une liste contenant les élèves de la classe.

Les variables Anne, Benoit, Claire, Dennis, Mystere, Fabrice contiennent des instances d’Eleve.

1. Donner le nom d'Anne.
2. Donner le nom et le prénom de Mystere.
3. Donner la moyenner de Fabrice.
4. Ajouter un 0 à Fabrice, et donner sa nouvelle moyenne.
5. Donner les notes d'Anne.
6. Créer un élève Messiaen Hector, et donner lui deux notes un 8 et un 4.

classeA et classeB sont deux instances de Classe.

1. Anne est dans quelle classe ?
2. Ajouter Messiaen à la classe b.
3. Donner le nom des élèves de la classe b.
4. Faire une fonction qui va donner la moyenne d'une classe.

Un professeur de mathématique veut représenter un élève, il veut retenir le nom, le prenom et ses notes.

1. Créer une classe Eleve et son constructeur (les notes seront stockées, par exemple, dans un tableau qui au début est vide). Les attributs sont privés.
2. Créer une méthode nom qui affiche le nom de l'élève.
3. Créer une méthode prenom qui affiche le prenom de l'élève.
4. Créer une méthode note qui affiche les notes de l'élève.
5. Surcharger __str__ pour qu'il donne "Benoit Chirac : 12 - 2 - 20"
6. Créer une méthode modifie_nom(nouveau_nom) qui modifie le nom de l'élève.
7. Créer une méthode modifie_prenom(nouveau_prenom) qui modifie le prenom de l'élève.
8. Créer une méthode ajout(note) qui va ajouter une note à l'élève.
9. Créer une méthode nb_notes() qui va retourner le nombre de notes.
10. Créer une méthode moyenne() qui va retourner la moyenne des notes.

1. Coder l'algorithme d'Euclide qui permet d'avoir le PGCD de deux nombres.

1. Combien d’attributs sont nécessaires pour stocker une fraction a/b ?
2. Coder les méthodes suivantes :
   1. Le constructeur.
   2. L'affichage (par exemple 2/3).
   3. Les comparaisons <, == et >.
   4. Les opérations +,*,-,/ (il faut retourner une instance nouvelle de la classe).
   5. La conversion en double.

1. Proposer une façons de stocker numériquement un point dans le plan cartésien (plan muni d'un repère). Il faut combien d’attributs ?
2. Coder les méthodes suivantes :
   1. Le constructeur.
   2. L'affichage des coordonnées cartésiennes.
   3. Une méthode qui donne l'abscisse, une méthode qui donne l'ordonnée.
   4. Surcharger l'opérateur d'égalité et de différence.
   5. Surcharger __getitem__(self,i) qui permettra de récupérer l'abscisse d'un point A en faisant A[0] et l'ordonnée en faisant A[1].
   6. Surcharger __setitem__(self,i,valeur) qui permettra de changer l'absisse et l'ordonnée d'un point. (Ce n'est donc pas de la programmation fonctionnelle.
   7. Faire une fonction auxiliaire distance(point1,point2) qui donne la distance entre point1 et point2 (la formule est vue en seconde pas d'excuses).
   8. Faire une fonction auxiliaire milieu(point1,point2) qui retourne le point milieu entre point1 et point2 (la formule est vue en seconde là aussi, pas d'excuses !).

On va représenter un polynôme à l'aide de ses coefficients, le constructeur est donné ci-dessous :

p = Polynome(1,-2,0,4) représente x^3 - 2x^2 + 4 par exemple.

1. Faire une méthode degre qui donne le degré du polynôme (le degré est l'exposant du plus haut degré (pour l'exemple précédent p.degre() = 3).
2. Faire une méthode image qui donne l'image d'un nombre par un polynôme. (exemple p.image(2) = 2^3 - 2*2^2 + 4 = 4).
3. Faire une méthode derivee qui va retourner la dérivée d'un polynôme (attention la fonction doit retourner une nouvelle instance de Polynome) p.derivee() = Polynome(3,-4,0).
4. Surcharger la méthode __str__ pour afficher un polynôme, print(p) = "x^3 - 2x^2 + 4" (malheureusement il n'est pas simple d'afficher des exposants et on doit utiliser le ^).
5. Faire une méthode derivee_nieme(n) qui va retourner la derivée nieme d'un polynôme (Pensez à la récursion !).
6. Surcharger l'opérateur d'égalité et de non égalité.
7. Surcharger l'opérateur d'addition (attention il faut retourner une nouvelle instance) Polynome(1,-2,0,4) + Polynome(1,2,3) = Polynome(1,-1,2,7).
8. (dur) Surcharger l'opérateur de multiplication, Polynome(1,-2,0,4) * Polynome(1,2,3) = Polynome(1,0,-1,-2,8,12).

1. Coder une classe Nsociale qui a pour but de stocker un numéro de sécurité sociale.
   Les méthodes d'interface de la classe seront :
   1. Le constructeur (attention le constructeur doit vérifier la validité du numéro (on vérifira la clef, le sexe et le mois, de 01 à 12. L'utilisateur donnera le numéro entier au constructeur.
   2. Surcharger l'opérateur __str__ qui permet d'afficher le numéro, à l'affichage on utilisera les même séparations que sur une carte vitale.

   3. Surcharger l'opérateur d'égalité.
   4. mois(self) qui donne le mois de naissance.
   5. annee(self) qui donne les deux derniers mois de l'année de naissance.
   6. sexe(self) qui donne le sexe de associé au numéro (par exemple la méthode retourne 0 ou 1 ou "homme" "femme).

1. Coder une classe Patient qui permet de stocker ses données, à vous de choisir les attributs.
   Les méthodes d'interfaces sont :
   1. Le constructeur (qui doit vérifier si le numéro de sécurité sociale est compatible avec la date de naissance.
   2. ajout(self,date) ajoute une date de visite au patient, elle doit effacer la précédente date de rendez vous.
   3. vérifie(self,date) doit retourner un bool, si le patient à rendez vous à cette date alors il doit indiquer true (et false dans le cas contraire).
   4. effectue(self,date) doit conserver la date donné, de plus si la date correspond à la date du rendez vous alors il faut passer celle ci à None.
   5. retard(self) indique si le rendez vous du patient est passé.
   6. Surcharger __str__ pour afficher toutes les informations du patient.

1. Coder une classe Patients (notez le s) qui permet de stocker ses données, à vous de choisir les attributs.
   Les méthodes d'interfaces sont :
   1. Le constructeur __init__(self,liste_patients) qui prend en paramètre une liste d'instances de Patient (éventuellement vide).
   2. ajout(self,patient) ajoute un patient à la liste (sauf si le patient existe déjà, il doit l'indiquer dans ce cas).
   3. donne_rendez_vous(self) doit afficher tous les patients qui ont rendez vous à la date donnée.
   4. Surcharger __len__ pour qu'il indique le nombre de patient.
   5. donne_patient(self,numero) doit retourner le patient qui a pour numéro de sécurité le numéro donné en paramètre (numero est de type entier).