---
# System prepended metadata

title: POO/UML

---

# POO/UML

CLASSES
(https://docs.google.com/presentation/d/1d60uRZ-uLRREVtZXxEzmOrytvx-yksdhXx6IjVnGgmo/edit#slide=id.g15221e14806_0_291)

```type=python
class Point:
    #constructeur
    def __init__(self, x, y):
        self.x=x
        self.y=y

#instanciation de deux objets de type Point

point1=Point(10,6)
point2=Point(2,4)

print(point1) #affiche l'emplacement en mémoire vive
print(type(point1)) #référence à la classe Point
```

1/ À quelle adresse est stockée Point2 ?
Point2 est stocké en adresse mémoire vive (RAM)

2/ Qu'en concluez vous ?
Que les deux objets (Point1 et Point2) sont stockées à des adresses mémoires différentes

3/ Schématisez le stockage en mémoire de ces deux instances



| Adresse            | Stockage |
| -                  | -        |
| 0x000001FF177A9348 | Point1   |
| 0x000001FF177A9D88 | Point2   |

# TP1
## Définir et schématiser le fonctionnement des listes chaînées

**Question 1**
Une liste chaînée est une structure de données dynamique, on accède aux éléments en traversant la liste.

**Question 2**
![](https://i.imgur.com/NIs5QQ8.png)

Supprimer élément :
![](https://i.imgur.com/mJSWzOM.png)

Ajouter élément : 
![](https://i.imgur.com/OzHD4yu.png)

**Question 3**
Deux classes : Element et ListeChainee

-> "Element" = deux attributs : "valeur" (élément courant) et "suivant" (élément suivant)
-> "ListeChainee" = premier élément liste, ou None si vide

| Element          | ListeChainee |
| -                | -        |
| valeur : entier  | sommet : element   |
| suivant : element |   |

En dessous des classes, ce sont les **attributs**

## Implémenter une liste chaînée

**Question 1**

```type=python
class Element:
    #constructeur
    def __init__(self, valeur, suivant=None):
        self.valeur=valeur
        self.suivant=suivant

class ListeChainee:
    #constucteur
    def __init__(self, sommet):
        self.sommet=sommet
    #est_vide : retourne Vrai si liste chaînée est vide
    def est_vide(self):
        if self.sommet is None:
            return True
        else:
            return False
    #insererElement : insere un nouvel élément en tête de liste
    def insererElement(self, elmt):
        elmt.suivant=self.sommet
        self.sommet=elmt
    #insererEntier : insère entier en tête de liste
    def insererEntier(self, entier):
        nouveau_sommet=Element(17)
        self.insererElement(nouveau_sommet)
    #tete : retourne la valeur de l’élément en tête de liste, si elle n’est pas vide
    def afficheTete(self, sommet):
        if self.sommet is False:
            return False
        else:
            return self.sommet
    #affiche_elements : qui affiche le contenu de la liste chaînée
    #queue : retourne la liste privée de son premier élément si elle n’est pas vide
    #elements : retourne un tableau contenant les valeurs des éléments de la liste

#programme principal:

#instanciation
elt=Element(7)
print(elt.valeur)#7
print(elt.suivant)#None

lst=ListeChainee(elt)
print(lst.sommet.valeur)

#est_vide
print(lst.est_vide())

#inserer
elt2=Element(3)
lst.insererElement(elt2)
print(lst.sommet.valeur)

#inserer_entier
ent2=17
lst.insererEntier(ent2)
print(lst.sommet.valeur)

#afficheTete
print(lst.afficheTete)
```

**Question 2**

Un type abstrait en POO

**Exercice pratique**
Diagramme des classes :

| Segment          | ListeChainee |
| -                | -        |
| Extremité  | sommet : element   |
| suivant : element |   |

## POO : Application du cours

**Exo 1**
![](https://i.imgur.com/usaRSVu.png)
a/
```type=python
#tuples : (x,y)
def deplacerTuples(point, dx,dy):
    nx = point[0]+dx
    ny = point[1]+dy
    return nx, ny

#dictionnaire : {"abs" : x, "ord" : y}
def deplacerDico(point, dx, dy):
    nx = point["abs"]+dx
    ny = point["ord"]+dy
    return {"abs": nx, "ord" : ny}

#programme principal

#test tuple
p_tuple = (5,2)
deltaX = 8
deltaY = 10
a = deplacerTuples(p_tuple,deltaX,deltaY)
print(a)

#test dico
p_dico = [
    {"abs":5,"ord":2}
]
nX=8
nY=10
b = deplacerDico(p_dico,nX,nY)
print(b)
#ERREUR :  nx = point[int("abs")]+dx
#ValueError: invalid literal for int() with base 10: 'abs'
```

**Exo 2**
![](https://i.imgur.com/8Nkze5T.png)

```type=python
import random
couleurs = [None, 'trèfle', 'carreau', 'cœur', 'pique']
valeurs = [None, 'as', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'valet', 'dame', 'roi']
class Carte:
    """Représente une carte à jouer standard."""
    def __init__(self,couleur,valeur):
        self.couleur = couleur
        self.valeur = valeur

    def __str__(self):
        return '%s de %s' % (Carte.noms_valeurs[self.valeur], Carte.noms_couleurs[self.couleur])

class Paquet:
    """contient les 52 cartes d'un paquet"""
    def __init__(self):
        self.cartes=[]
        for couleur in range(4):#4 couleurs
            for valeur in range(1,14):#4 valeurs
                carte=Carte(couleur,valeur)#on attribue à la variable carte, la classe Carte
                self.cartes.append(carte)
    def __str__(self):
        res=[]
        for carte in self.cartes:
            res.append(str(carte))
        return '\n'.join(res)
    def tirer(self):
        randomC=couleur.random.randint
        randomV=valeur.random.randint
        carteRandom=Carte(randomC,randomV)
        pint(carteRandom)

carte1 = Carte(2, 11)
print(carte1)
carte2=Carte(4,5)
print(carte2)

paquet=Paquet()
print(paquet)
```

**Exo 3** Théo CORDIER / Serge POKROVSKIY
![](https://i.imgur.com/rhYxPN5.png)

```type=python
## A
T=[1,2,3,4,5,6,7,8,9,10]
class Tranche:
    #constructeur
    def __init__(self,premier_ele,dernier_ele,tranche):
        self.premier_ele=premier_ele
        self.dernier_ele=dernier_ele
        for i in range(premier_ele,dernier_ele):
            self.tranche=T[premier_ele:dernier_ele]
    def len(self):
        return len(self.tranche)
    def getitem(self,item):
        return self.tranche[item]
    def setitem(self,item,nv_valeur):
        self.tranche[item]=nv_valeur
        print(T)
        return T,self.tranche

#programme principal
s=Tranche(3,8,T)
print(s.tranche)
print(s.getitem(3))
print(s.setitem(3,10))

## B
T=[1,2,3,4,5,6,7,8,9,10]
class Tranche:
    #constructeur
    def __init__(self,premier_ele,dernier_ele,tranche):
        self.premier_ele=premier_ele
        self.dernier_ele=dernier_ele
        for i in range(premier_ele,dernier_ele):
            self.tranche=T[premier_ele:dernier_ele]
    def __len__(self):
        return len(self.tranche)
    def __getitem__(self,item):
        return self.tranche[item]
    def __setitem__(self,item,nv_valeur):
        self.tranche[item]=nv_valeur
        print(T)
        return T,self.tranche

s=Tranche(3,8,T)
print(s.tranche)
print(len(s))
print(s[3])
s[3]=10
print(s.tranche)

## C
T=[1,2,3,4,5,6,7,8,9,10]
class Tranche:
    #constructeur
    def __init__(self,premier_ele,dernier_ele,tranche):
        if isinstance(t,T):
            self.premier_ele=premier_ele
            self.dernier_ele=dernier_ele
            for i in range(premier_ele,dernier_ele):
                self.tranche=T[premier_ele:dernier_ele]
        else:
            self.tranche2=tranche
            return tranche2
    def __len__(self):
        return len(self.tranche)
    def __getitem__(self,item):
        return self.tranche[item]
    def __setitem__(self,item,nv_valeur):
        self.tranche[item]=nv_valeur
        print(T)
        return T,self.tranche

s=Tranche(3,8,T)
print(s.tranche)
print(len(s))
print(s[3])
s[3]=10
print(s.tranche)```

## TP2

![](https://i.imgur.com/cxnsOJD.png)
