# Créé par B.BERTRAND, le 17/10/2022 en Python 3.7
#question a :
class Tranche:
    #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]]

    #methodes:
    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,valeur): # changer la valeur du n-ième élément
        self.tranche_a[position]=valeur

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

    #methodes:
    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_2[position]

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

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

#question b :
print("////////////////////")
print("question b :")
test2=Tranche2([1,2,3,4,5],2,4)
print(len(test2))
print(test2[1])
test2[1]=7
print(test2[1])

#question c :
print("////////////////////")
print("question c :")
print(isinstance(test2,list)) #on verifie si b est un tableau
tranche_test=Tranche2(test2,0,1) #on crée une tranche à partir de la tranche b
print(len(tranche_test))
print(test2[0])
print(test2[1])
print(isinstance(tranche_test,list)) #on verifie si u est un tableau, ce n'est pas le cas

**travail de recherches :**

**1) Qu’est-ce que l’héritage en POO ?**
En programmation orientée objet, “hériter” signifie “avoir également accès à”. Lorsqu’on dit qu’un objet “hérite” des méthodes de la classe qui l’a défini, cela signifie que l’objet peut utiliser ces méthodes; qu’il y a accès.

La notion d’héritage va être particulièrement intéressante lorsqu’on va l’implémenter entre deux classes. En Python, nous allons en effet pouvoir créer des “sous-classes” ou des classes “enfants” à partir de classes de base ou classes “parentes”.

**2) Comment représente-t-on l’héritage en UML ?**

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

**Comment déclarer l’héritage en Python :**
Python définit deux fonctions primitives pour gérer l'héritage :

utilisez isinstance() pour tester le type d'une instance : isinstance(obj, int) renvoie True seulement si obj.__class__ est égal à int ou à une autre classe dérivée de int ;

utilisez issubclass() pour tester l'héritage d'une classe : issubclass(bool, int) renvoie True car la classe bool est une sous-classe de int. Cependant, issubclass(float, int) renvoie False car float n'est pas une sous-classe de int.

**En utilisant les informations recueillies précédemment, implémenter votre diagramme d’objet.**

**Qu’est ce qu’un mutateur ?**
les mutateurs (en anglais mutator) qui modifient l’état d’un objet, donc les valeurs de certains de ses attributs.

**Qu’est ce qu’un accesseur ?**
Les accesseurs sont des méthodes qui permettent de retourner la valeur d’un attribut.

**Quelle est la convention d’écriture utilisée pour définir les accesseurs ?**

**Quelle est la convention d’écriture utilisée pour définir les mutateurs ?**

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