N’oubliez pas de rendre le TP sur Moodle pour la seconde chance.

Exercice 1. Écriture de classes

Proposer une classe Annuaire qui comprends des champs nom, prenom et numéro et historique.

Faites en sorte:

1. Proposer une initialisation. Le code suivant doit marcher:

A = Annuaire("Charles", "Paperman", "0342424242")
print(A.historique) # devrait retourner []

2. Que vos champs ne soient pas éditable. Le code suivant doit déclencher une erreur:

A.nom = "xxxx"

3. Construire une classe Appel qui modélise un appel téléphonique et qui s’initialise avec deux champs: horaire et durée

4. Ajouter à votre classe Annuaire une méthode nouvel_appel(date, duree) qui ajoute un appel à l’historique.

5. Ajouter les propriétés suivantes à Annuaire:

• dernier_appel
• duree_moyenne
• nombre_appel

6. Nous allons permettre de trier les entrées dans l’annuaire. Pour ça, on va implémenter une méthode qui permet d’ordonner deux entrées.

• Lire la documentation et trouver comment surcharger l’opération <.
• Surcharger cette opération pour qu’une entrée dans l’annuaire soit plus grande qu’une autre si le nombre d’appel est plus grand, et en cas d’égalité la durée moyenne est plus grande et en cas d’égalité le dernier appel est plus rapproché.

7. Donnez une fonction qui prends en entrée une collection d’instances d’Annuaire et retourne les 5 plus importantes.

Correction exercice 1

Exercice 2. Voici quelques classes qui modélisent des relations humaines

Voici une classe qui modélise une personne:

class Person:
    def __init__(self, nom):
        self._nom = nom
        self._relations = []

    @property
    def nom(self):
        return self._nom

    def __repr__(self):
        return f"Je suis: {self.nom} (id={id(self)})"
    
    def __eq__(self, other):
        return self.nom == other.nom

    @property
    def relations(self):
        return self._relations

1. En lisant la documentation, indiquer à quoi sert la méthode __repr__ et la methode __eq__.

2. Expliquez le résultat de ce script:

P  = Person("Charles Paperman")
P2 = Person("Charles Paperman")
P3 = Person("Claude Shannon")
print(f"P == P ({P=})",  P == P)
print(f"P == P2 ({P=}, {P2=})", P == P2)
print(f"P == P3 ({P=}, {P3=})",  P == P3)

P == P (P=Je suis: Charles Paperman (id=139897522031824)) True
P == P2 (P=Je suis: Charles Paperman (id=139897522031824), P2=Je suis: Charles Paperman (id=139897535095568)) True
P == P3 (P=Je suis: Charles Paperman (id=139897522031824), P3=Je suis: Claude Shannon (id=139897535095824)) False

3. Proposez un code joli qui prend une liste de personne et élimine les duplicats. Indiquez sa complexité.

4. On ajoute quelques nouvelles classes avec un peu d’héritage

class Relation:
    def __init__(self):
        self.persons = list()

    def ajout_personne(self, person):
        if person not in self.persons:
            self.persons.append(person)
            person._relations.append(self)

    def __repr__(self):
        return f'{type(self).__name__}({",".join(map(str, self.persons))})'

class Amis(Relation):
    pass

class Famille(Relation):
    pass

5. Expliquez le résultat de ce script:

A = Amis()
A.ajout_personne(P)
A.ajout_personne(P)
A.ajout_personne(P2)
print(A)

Amis(Je suis: Charles Paperman (id=139897522031824))

6. Proposez un script qui:

Crée les personnes:

• Derrick Howell
• Tammy Garrett
• Eric Edwards
• Lisa Kim
• David Parker
• Nicole Wood
• April Joseph
• Brian Medina
• Christian Holmes
• Gregory Molina

Fait en sorte que:

• Derrick et Tammy soit de la même famille,
• Tammy est amie avec Eric et Lisa et David,
• Nicole est amie avec Derrick et April
• April, Brial et CHristian sont de la même Famille
• Christian et Gregory sont amis

7. Écrire une fonction en_relation qui prends deux personnes et vérifie qu’elles ont une relation commune.

Deux personnes \(P_1\), \(P_2\) sont connectées s’il existe une suite de \((K_i)\) de taille \(n\in \mathbb{N}\) tel que:

• \(P_1=K_1\)
• \(P_2=K_n\)
• \(P_i\) et \(P_{i+1}\) sont en relations

8. Écrire une fonction connecté qui prends deux personnes et vérifie qu’elles sont connectées.

Des objets pour les Polynômes

Écrire une classe polynomes qui permet de représenter un polynôme abstrait de \(\mathbb{R}[X]\). Faites en sorte que vos polynômes puissent être additionnés, soustraits et multipliés.

Il faudra aussi:

• Une propriété qui donne le degré
• Une méthode qui évalue le polynôme en un point
• Un joli __repr__
• Une méthode qui dérive le polynôme.
• Une méthode qui calcule une racine approchée via la méthode de Newton

Compiled the: mar. 26 nov. 2024 11:44:02 CET