---
# System prepended metadata

title: Application de cours

---

# Application de cours


```python=
#a)
class Tranche_a:
    #constructeur:
    def __init__(self,t,debut,fin):
        self.t=t
        self.debut=debut
        self.fin=fin
        self.tranche_a=[]
        for i in range(debut,fin):
            self.tranche_a+=[t[i]]

    #méthodes:
    def longueur(self): # retourne la longueur de la liste
        return self.fin-self.debut+1

    def getitem(self,position): # retourne la valeur du n-ième élément
        return self.tranche_a[position]

    def setitem(self,position,val): # changer la valeur du n-ième élément
        self.tranche_a[position]=val


#b) et c)
class Tranche_b:
    #constructeur:
    def __init__(self,t,debut,fin):
        self.t=t
        self.debut=debut
        self.fin=fin
        self.tranche_b=[]
        for i in range(debut,fin):
            self.tranche_b+=[t[i]]

    #méthodes:
    def __len__(self): # retourne la longueur de la liste
        return self.fin-self.debut+1

    def __getitem__(self,position): # retourne la valeur du n-ième élément
        return self.tranche_b[position]

    def __setitem__(self,position,val): # changer la valeur du n-ième élément
        self.tranche_b[position]=val


#programme principal
#a)
print("question a")
a=Tranche_a([1,2,3,4,5],2,4)
print(a.longueur())
print(a.getitem(1))
a.setitem(1,7)
print(a.getitem(1))

#b)
print("-----")
print("question b")
print("-----")
b=Tranche_b([1,2,3,4,5],2,4)
print(len(b))
print(b[1])
b[1]=7
print(b[1])

#c)
print("-----")
print("question c")
print("-----")
print(isinstance(b,list)) #on teste pour voir si b est un tableau, ce n'est pas le cas
u=Tranche_b(b,0,1) #on crée une tranche à partir de la tranche b
print(len(u))
print(b[0])
print(b[1])
print(isinstance(u,list)) #on teste pour voir si u est un tableau, ce n'est pas le cas

```

1) Qu’est-ce que l’héritage en POO ,
L’héritage est un concept important de la programmation orientée objet (POO). Il permet de créer une nouvelle classe (classe Enfant) à partir d’une classe préexistante (classe Parent).

2) Comment représente-t-on l’héritage en UML ?
L’héritage est une association entre deux classes, indiquant que l’une est plus générale que l’autre. L’héritage implique le transfert automatique de propriétés (attributs et méthodes) de la première classe vers la seconde classe. Dire que la seconde classe hérite de la première revient à dire que la seconde classe est une sous-classe de la première classe.

3) Schématiser les liens d’hérédité relatifs aux classes décrites dans les lignes suivantes :

![](https://i.imgur.com/ENNQmEg.png)
La classe Chat hérite des attributs race et couleur et des méthodes manger et boire de la classe Animal.
La classe Tigre hérite des attributs race et couleur et des méthodes manger et boire de la classe Animal.

Comment déclarer l’héritage en Python :
Pour déclarer l’hérédité en Python, il faut créer que la classe Enfant prenne en paramètre la classe Parent.

En utilisant les informations recueillies précédemment, implémenter votre diagramme d’objet.
```python= 
class Animal: 
    #constructeur
    def __init__(self, race):
        self.race=race
    #methodes 
    def manger(self):
        pass
    def boire(self):
        pass 

class Chat(Animal):
    #constructeur
    def __init__(self, race, taille, poids):
        self.race=race
        self.taille=taille
        self.poids=poids
    #methodes
    def manger(self):
        pass
    def boire(self):
        pass 
    def dormir(self):
        pass 

class Tigre(Animal):
    #constructeur
    def __init__(self, race, taille, poids):
        self.race=race
        self.taille=taille
        self.poids=poids
    #methodes
    def manger(self):
        pass
    def boire(self):
        pass 
    def rugir(self):
        pass 
    
```
Qu’est ce qu’un mutateur ?
Mutateur (mutator): modifie l’état d’un objet et donc les valeurs de certains de ses attributs.

Qu’est ce qu’un accesseur ?
Accesseur (accessor): permet à l’utilisateur d’interroger l’objet sur son état (obtenir des informations relatives à l’état d’un objet), c’est_à-dire accéder à ses valeurs.

Quelle est la convention d’écriture utilisée pour définir les accesseurs ?
Par convention d’écriture, les accesseurs sont définis par getattr().

Quelle est la convention d’écriture utilisée pour définir les mutateurs ?
Par convention d’écriture, les mutateurs sont définis par setattr() (remplacer) ou delattr() (supprimer).

Au sein des classes implémentées précédemment, mettez en place les accesseurs et les mutateurs ?
