---
# System prepended metadata

title: 'CP Python: Séance 10'

---

# CP Python: Séance 10


### Récapitulatif Séance 9
* [Jamboard](https://jamboard.google.com/d/1aFvwODprFQCEX3NHs_ED-KziqmVNLzSjGpvzOi-8gPk/edit?usp=sharing)
* [Guide de séance 9](https://hackmd.io/@Tb5Z2PdeRLSnkxJEsjcLXg/Skl9OE82v)
* Théorie
    * Vidéo YouTube: https://youtu.be/apACNr7DC_s
    - Syllabus [1 - Classes and objects - Basics
](https://syllabus-interactif.info.ucl.ac.be/syllabus/info1-theory/PART_III/classes_and_objects_I)
    - Syllabus [2 - Classes and objects - Advanced](https://syllabus-interactif.info.ucl.ac.be/syllabus/info1-theory/PART_III/classes_and_objects_II)

### Remarques
- Pourriez-vous ajouter les slides du cours dans [ce dossier Drive](https://drive.google.com/drive/folders/1ADF6uYE0ksbcb2YoYDU4D_Cn1SQfGX0u?usp=sharing) ?
- Planning Blocus ? 
- Séance 11: Héritage et Polymorphisme. Jeudi PM ?
- Séance 12: Listes Chaînées. Lundi prochain ?
- Séance 13: Examen blanc. Mercredi ou jeudi prochain ? 

## A préparer pour mardi 22/12, 10h30

### 1. Remédiation: Fonctions et paramètres
- [ ] Visionner [Function Parameters](https://www.youtube.com/watch?v=CGRKqnoQGgM)
- [ ] Visionner [Parameters vs Arguments](https://www.youtube.com/watch?v=98zIkpDy9kA)
- [ ] Visionner [Functions Calling Functions](https://www.youtube.com/watch?v=hu1Q2Uw2muE)
- [ ] NEW: Visionner [Dictionaries](https://www.youtube.com/watch?v=XCcpzWs-CI4)



### 2. Classes et objets 


>  - Repartez de ce [REPL](https://repl.it/join/sqscldet-guillaumegst) et en particulier, utilisez/modifiez le fichier `objets.py`
> -  Pour les représentations graphiques, utilisez ce [Jamboard](https://jamboard.google.com/d/1aP26MJL3nEnuKxnpn1CZ9NroOzLzno2YLgEjvXnCvyQ/edit?usp=sharing) 
__NB__ N'hésitez pas à repartir du fichier `objets.py` dans le REPL pour modifier/expérimenter les classes `Pair` et `Student`. De même, *Python Tutor Visualize* peut vous être utile pour représenter graphiquement les objets.


#### 1. Résoudre *Exercice 4: Une classe simple* [20m]
```python=
class Pair:
    """
    Une paire d'entiers
    """

    def __init__(self, x=None, y=None):
        """
        @pre -
        @post crée une paire (a,b) composée de x et y,
              ou une paire non-initialisée si aucune valeur
              de x et de y n'est donné lors de l'appel au constructeur
        """
        self.a = x   # le premier élément de la paire
        self.b = y   # le second élément de la paire

    def __str__(self):
        return str(self.a) + ", " + str(self.b)
```
Considérons le code Python ci-dessous illustrant une utilisation de la classe Pair:
```python=
p0 = Pair()      ##1##
p1 = Pair(0,0)   ##2##
p2 = Pair(1,1)   ##3##
p0.b = 3         ##4##
p1.a = 10        ##5##
p2.a = p1.a      ##6##
p2 = p1          
```

- Expliquez les opérations effectuées par chacune de ces lignes. Pensez à utiliser une représentation graphique des différents objets telle que celle utilisée dans le syllabus ou les transparents en indiquant les valeurs des différentes variables d'instance.
- Inspirez-vous de l'exemple du cours:
> <img src="https://i.imgur.com/Y9nWTnD.png" width=600>
- Après la ligne 7, qu'est-ce qui s'affiche si on exécute:
```python
print(p0)
print(p1)
print(p2)
```
?

---
#### 2A. Visionner la vidéo [`__eq__ vs ==`](https://www.youtube.com/watch?v=4ethYataA2o)
#### 2B. Visionne la vidéo sur les ["Méthodes magiques"](https://www.youtube.com/watch?v=3ohzBxoFHAY)
#### 2C. Exercice 7: Egalité 
Considérez les instructions suivantes qui utilisent la classe Pair vue précédemment:

```python=
p1 = Pair(9, 42)
p2 = Pair(9, 42)
if (p1 == p2):
    print("Egaux en 1")   ##1##
p2 = p1
if (p1 == p2):
    print("Egaux en 2")   ##2##
```

- Lesquelles des lignes ##1## et/ou ##2## produiront-elles un message?
- Ajoutez une méthode `__eq__(self, p)` à la classe Pair qui compare la valeur de deux paires, de manière à ce que p1 == p2 retournera True à la ligne ##1##. Pensez à gérer également le cas où p == None.

```python=
class Pair:

    def __init__(self, x, y):
        self.a = x
        self.b = y

    def __eq__ (self, p):
        """
        @pre    -
        @post   Retourne true si la paire p est égale à l'objet.
                Retourne false sinon
        """
        # À implémenter
```
:::info
###  Reminder: private attributes
|  | | 
| -------- | -------- | 
| ![](https://i.imgur.com/qQd0nQd.png)     | ![](https://i.imgur.com/oF9zd9Q.png)  
| 



#### 

:::
#### 3. Résoudre le début de la QBF

__A.__
Dans un fichier `employee.py` écrivez une classe complète `Employee` dont les instances représentent un employé d’entreprise. 

Un employé est caractérisé par son nom (un string) et son salaire (un entier positif). Il doit être possible de créer un nouvel employé avec un nom et un salaire et d’effectuer les opérations suivantes sur un objet `Employe`:
— Obtenir le nom de l’employé
— Obtenir le salaire de l’employé
— Obtenir un texte descriptif représentant l’employé sous la formen `nom : salaire`
— Augmenter le salaire de l’employé d’un certain pourcentage.

Après avoir défini cette classe `Employe` correctement, le code suivant devrait imprimer `Charles : 2750.0`.

```python
charles = Employe("Charles", 2500)
charles.augmente(10)
print(charles)
```
__B.__

Maintenant, supposez qu’on ajoute la méthode d’instance suivante à la définition de la classe `Employe`. Le but de cette méthode est d’ajouter le nom de famille au nom de l’employé.

```python
def add_lastname(lastname):
    name += " " + lastname
```

Avec cette définition, le code suivant 
```python
charles.add_lastname("Pecheur")
print(charles)
```
produirait une erreur plutôt que d’imprimer `"Charles Pecheur: 2750.0"`. Expliquez quelle erreur serait produit et corrigez la méthode ci-dessus afin d'avoir le résultat escompté. __NB__: Il y a 2 erreurs!

Maintenant considérez l’instruction suivante. On s’attend à ce que le string `"Kim Mens : 2640.0"` soit imprimé à l’écran. Est-ce que ce serait le cas pour votre code ? Est-ce que votre code supporte des appels chaînés comme dansl’instruction suivante ? Sinon, corrigez vos méthodes précédentes afin que cette instruction ait le comportement voulu.
```python
print(Employe("Kim", 2400).augmente(10).add_lastname("Mens"))
# doit imprimer "Kim Mens : 2640.0"
```
__C__
Écrivez ensuite quelques instructions Python qui effectuent ces différentes opérations:

- créer deux objets `Employe` représentant les frères Pierre et Nicolas ayant le même salaire de $2410$ euros ;
- applique une augmentation de salaire de $3\%$ à Pierre ;
- affiche les descriptifs de Pierre et Nicolas à l'écran.


Représentez graphiquement les instances créées avant et après l'augmentation du salaire de Pierre.


#### 4. Examen blanc

#### To Do

- https://www.youtube.com/watch?v=fW4818AS88I 
