Florian/TermNSI
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

renommage enoncé

Browse Source
This commit is contained in:
Florian Mathieu
2024-11-18 09:00:50 +01:00
parent 3c1159db71
commit 42acf69034
2 changed files with 406 additions and 600 deletions
Download Patch File Download Diff File Expand all files Collapse all files

406
Projets/wator/Enoncé.md
View File

@@ -1,406 +0,0 @@
# TP Python
### Le Wator
Durée : Le temps pour les requins de manger tous les thons ?
## Principe
Il s'agit d'un TP qui vous permettra de générer votre propre simulation "proie - prédateur".
--------------------
## Contexte
- TP à faire en solo ou en binôme, une machine par binôme.
- 2 Séances de 2H pour en arriver au bout.
- Support en markdown avec du python intégré pour fournir aux élèves certaines fonctions et d'afficher le résultat / courbe.
----------------
## Table des matières
1. [Introduction](#Introduction)
2. [Fonctionnement](###Fonctionnement)
3. [Algorithme](###Algorithme)
4. [Programmation](#Programmation)
### Introduction et règles de jeu
Le Wator se présente comme un jeu proie - prédateur, sur une grille qui comportera trois types de cases :
* Des cases vides
* Des cases contenant des prédateurs (Requins)
* Des cases contenant des proies (Thons)
### **Les poissons**
Les prédateurs mangent dès qu'ils entrent sur une case contenant une proie, qui, elle, disparait donc.
Pour survivre, un requin doit manger un thon de manière régulière. En revanche, le thon ne disparait que s'il est mangé.
Les deux espèces sont caractérisées par des variables qui sont communes à tous les individus de l'espèce en question :
Les thons ont un temps de gestation : On utilisera une variable appelée *durée de gestation des thons* pour la représenter.
Chez les requins, le temps de gestation est également présent mais de plus, ici, on devra gérer une energie. Ces deux valeurs seront initialisées à une valeur commune à tous les requins, appelées respectivement *durée de gestation des requins* et *énergie des requins*.
-----------------------
### Fonctionnement
Lors de chaque étape de la simulation, nous allons répéter plusieurs étapes :
Pour les **_thons_** :
* Le thon va essayer de se déplacer sur une case vide adjacente.
* S'il en existe une, le thon se déplace vers cette
case.
* Il reste sur place sinon.
* La variable *durée de gestation des thons* voit sa valeur réduite de 1.
* Si ce temps arrive à 0, le thon donne naissance à un nouveau
thon qui nait sur la case qu'il vient de quitter **_uniquement si celui ci s'est déplacé_**
* Le temps de gestation est alors remis à sa valeur initiale.
Pour les **_requins_** :
* Le requin perd 1 point d'_energie_
* Si le niveau d'énergie du requin est à 0, il meurt.
* Le requin choisit aléatoirement parmi ses voisines
une case occupée par un thon :
* S'il en existe une, le requin se
déplace vers cette case et mange le thon. Son niveau d'_énergie_
est alors remis à sa valeur initiale.
* Sinon il cherche à se déplacer vers une case voisine vide choisie au hasard. Il reste sur place s'il n'y en a aucune.
* Le _temps de gestation du requin_ est diminué de 1 :
* Si ce temps arrive à 0, il donne naissance à un nouveau
requin sur la case qu'il vient de quitter **si et uniquement s'il s'est déplacé**.
* Son temps de gestation est remis à sa valeur initiale.
----------
**_A votre avis : si les paramètres sont mal ajustés que risque t-il de se produire_** ?
C'est exact : Le nombre de thons sera trop faible au bout d'un moment, et le cycle recherché disparaitra.
Pour notre simulation, il est necessaire de bien paramétrer notre programme afin de voir emerger un cycle qui va régir la population:
* Lorsqu'il y aura suffisament de thons, le nombre de requin va accroitre.
* Cela va donc réduire le nombre de thons...
* Puis lorsqu'il y n'y aura plus assez de thons, les requins vont disparaitre.
* Et de nouveaux, le nombre de thon va grandir...
La chose à éviter est donc l'extinction totale des thons, car on ne pourrait plus relancer la simulation.
Il faut donc respecter une règle :
```
temps gestation des thons < énergie des requins < durée gestation des requins
```
_Que peut-on choisir comme valeurs, selon vous?_
**Nous prendront ces valeurs ci :**
* Temps de gestation des thons : 2
* Energie des requins : 3
* Durée de gestations des requins : 5
Question :
Il y a un paramètre important qu'il nous reste à gérer :
**Combien de thons et de requins doit on initialiser au lancement de notre simulation ?**
### Algorithme
Avant de commencer à travailler sur le code, il est necessaire de revenir sur l'algorithme. Celui ci nous permettra d'avoir une feuille de route claire, et de savoir exactement ce que l'on doit faire. Ne restera plus qu'à réaliser cela à travers python.
Ici, nous avons un exemple d'algorithme sur la gestion des thons:
![Algorithme_thon](assets/Algo_thon.png)
Trouvez vous cet algorithme fonctionnel ?
**_Ecrire un algorithme similaire pour les requins._**
L'important ici, est de bien couvrir tous les cas de figure possibles :
Plus nous seront précis dans l'algorithme, plus le travail de programmation sera facile.
------------
### Programmation
Dans le but de faciliter notre tâche, voilà la marche à suivre :
* Créer une classe Animal, qui comprendra les différents paramètres qui vont régir l'évolution d'un thon ou d'un requin par exemple
* Créer une classe World, dans laquelle nous pourrons définir toutes les fonctions necessaires au bon fonctionnement de notre simulation
* Appeler les fonctions pour lancer la simulation
C'est parti !
Pour commencer, appelons donc les bibliothèques que nous pourrions avoir besoin :
Question : trouvez le mot clé permettant d'importer les bibliothèques ci dessous, et ajoutez le à votre code.
```python
i***** matplotlib
pylab
random
numpy
time
```
Maintenant, pensons aux quelques variables que l'on aura besoin d'utiliser :
Pour créer la mer, et la diviser en grille, il nous faudra donc un nombre de lignes, et un nombre de colonnes :
```python
n_lignes = 25
n_colonnes = 25
```
Puis, on décomptera le nombre de thons et de requins afin de garder le ratio souhaité, puis nous initialiserons les paramètres que l'on appliquera:
```python
n_thon = 0
n_requin = 0
energie_init_thon = 10
energie_init_requin = 3
temps_gestation_thon = 2
temps_gestation_requin = 5
```
On peut donc passer aux choses sérieuses :
Créez une classe Animal, qui intégrera les paramètres associés aux thons et requins :
```python
class Animal():
def __init__(self, id, energie_base, temps_gestation, x, y):
...
```
​
Puis la classe World, dans laquelle on initialisera la grille que l'on utilise pour simuler une mer :
```python
class Wator():
def __init__(self,...):
self. =
self. =
self.grille =
self.nbcase = hauteur * largeur
self.animaux = []
```
Deux choses importantes :
Pour notre grille, il est primordial de choisir une structure efficace.
**Indice** : Comment crée t-on un tableau ou _array_ en python ?
Il faut ensuite ajouter les fonctions pour que notre océan se remplisse :
* Gérer le peuplement de la mer
* Gérer le placement des animaux
* Une fonction pour créer la grille
* ???
Nous allons utiliser une structure pour retenir le type d'animal présent sur une case de coordonées x, y.
C'est ici que l'on peut reflechir au quota que l'on aura :
on propose 30% de thon, 10% de requins, et 60% de cases vides.
Vu le nombre d'animaux qu'il va falloir gérer, quelle structure proposez vous ?
```python
def ...:
= ...(a_id, energie_init[a_id], temps_gestation[a_id], x, y)
self.animaux.append(animal)
self.grille[y][x] = animal
```
Ici, on applique donc notre quota :
```python
def peupler(self, n_thon = 30, n_requin = 10 ):
self.n_thon = n_thon
self.n_requin = n_requin
```
Pour le placement des thons et requins, il va nous falloir utiliser une boucle, afin de générer des créatures jusqu'à ce que l'on ai le nombre de thons et de requins souhaité.
```python
def generer_placement(n_animaux, a_id):
... i in ...(n_animaux):
... True:
x, y = divmod(random.randrange(self.nbcase), self.hauteur)
if not self.grid[y][x]:
self.pop_animal(a_id, x, y)
break
generer_placement(n_thon, thon)
generer_placement(n_requin, requin)
```
```python
def tableau_grille(self):
return [[self.grille[y][x].id if self.grille[y][x] else 0
for x in range(self.largeur)] for y in range(self.hauteur)]
```
Il est important de vérifier les cases voisines quand on fait déplacer un thon ou un requin :
D'abord, on cherche à obtenir leur coordonées.
Pour cela, on a besoin de p-upplets ou d'un dictionnaire :
```python
def voisin(self, x, y):
voisin = {}
for dx, dy in ((0,-1), (1,0), (0,1), (-1,0)):
xp, yp = (x+dx) % self.largeur, (y+dy) % self.hauteur
voisin[xp,yp] = self.grille[yp][xp]
return voisin
```
Il ne nous reste plus qu'à créer la fonction qui permettra à notre mer, à notre monde, d'évoluer
```python
def evolution(self, animal):
voisin = self.voisin(animal.x, animal.y)
# Ajouter +1 à la gestation.
déplacement = False
Si l'animal est un requin
try:
xp, yp = utiliser la bibliothèque random...
..............
...................
if not déplacement:
try:
xp, yp = random.choice([position
for position in voisin if voisin[position]==case])
if animal.id != thon:
animal.energie -= 1
déplacement = True
except IndexError:
xp, yp = animal.x, animal.y
if animal.energie < 0:
animal.vie = False
self.grille[animal.y][animal.x] = case
elif déplacement:
x, y = animal.x, animal.y
animal.x, animal.y = xp, yp
self.grille[yp][xp] = animal
if animal.gestation >= animal.temps_gestation:
animal.gestation = 0
self.pop_animal(animal.id, x, y)
else:
self.grille[y][x] = case
def progression(self):
random.shuffle(self.animal)
n_animal = len(self.animal)
for i in range(n_animal):
animal = self.animal[i]
if not animal.vie:
continue
self.evolution(animal)
self.animaux = [animal for animal in self.animaux if animaux.vie]
```
Mais après tout cela : comment voir ce que l'on a crée ?
Comment s'assurer que cela fonctionne ?
Il nous faut une représentation graphique :
```python
def image_grille(self):
img = self.tableau_grille()
trace = plt.figure(figsize=(10, 5), dpi = 36)
axe = fig.add_subplot(100)
return trace
def afficher_image(self):
trace = self.image_grill()
plt.show()
```
​
​

600
Projets/wator/README.md
View File

@@ -1,194 +1,406 @@
# TP : Simulation Wa-Tor - Proies et Prédateurs # TP Python
## Introduction ### Le Wator
Wa-Tor est une simulation de type proie-prédateur. Dans une mer torique, évoluent des thons (*les proies*) et des requins (*les prédateurs*). Ces deux espèces se déplacent, se reproduisent, et interagissent selon des règles spécifiques. Durée : Le temps pour les requins de manger tous les thons ?
- Les requins doivent manger des thons pour survivre.
- Les thons vivent éternellement tant qu'ils ne sont pas dévorés.
## Principe
---
Il s'agit d'un TP qui vous permettra de générer votre propre simulation "proie - prédateur".
## La Mer
--------------------
La mer est modélisée par une **grille torique à deux dimensions**. ## Contexte
Chaque case de cette grille peut contenir :
- TP à faire en solo ou en binôme, une machine par binôme.
- Rien (*case vide*), - 2 Séances de 2H pour en arriver au bout.
- Un thon, - Support en markdown avec du python intégré pour fournir aux élèves certaines fonctions et d'afficher le résultat / courbe.
- Un requin.
Chaque case possède **quatre voisines** : ----------------
- Nord (N), ## Table des matières
- Sud (S),
- Est (E), 1. [Introduction](#Introduction)
- Ouest (O).
2. [Fonctionnement](###Fonctionnement)
---
3. [Algorithme](###Algorithme)
## Les Poissons
4. [Programmation](#Programmation)
### Thons
- **Caractéristique** : *Temps de gestation*.
- **Initialisation** : à une valeur commune, appelée *durée de gestation des thons*.
### Introduction et règles de jeu
### Requins
Le Wator se présente comme un jeu proie - prédateur, sur une grille qui comportera trois types de cases :
- **Caractéristiques** :
1. *Temps de gestation*. * Des cases vides
2. *Énergie*. * Des cases contenant des prédateurs (Requins)
- **Initialisation** : * Des cases contenant des proies (Thons)
- *Durée de gestation des requins*.
- *Énergie des requins*.
### **Les poissons**
--- Les prédateurs mangent dès qu'ils entrent sur une case contenant une proie, qui, elle, disparait donc.
## Simulation et Comportements Pour survivre, un requin doit manger un thon de manière régulière. En revanche, le thon ne disparait que s'il est mangé.
### Étapes d'une Simulation Les deux espèces sont caractérisées par des variables qui sont communes à tous les individus de l'espèce en question :
À chaque pas de simulation, une case est sélectionnée aléatoirement. Les thons ont un temps de gestation : On utilisera une variable appelée *durée de gestation des thons* pour la représenter.
Deux scénarios possibles :
Chez les requins, le temps de gestation est également présent mais de plus, ici, on devra gérer une energie. Ces deux valeurs seront initialisées à une valeur commune à tous les requins, appelées respectivement *durée de gestation des requins* et *énergie des requins*.
1. La case est vide : **Rien ne se passe**.
2. La case est occupée : **Le poisson applique son comportement**. -----------------------
### Comportement des Thons ### Fonctionnement
1. **Déplacement** Lors de chaque étape de la simulation, nous allons répéter plusieurs étapes :
- Le thon choisit une case voisine libre au hasard.
- Si aucune case libre, il reste sur place. Pour les **_thons_** :
2. **Reproduction** * Le thon va essayer de se déplacer sur une case vide adjacente.
- Son *temps de gestation* diminue de 1. * S'il en existe une, le thon se déplace vers cette
- Si ce temps atteint 0 : case.
- Le thon se reproduit sur la case qu'il quitte (s'il s'est déplacé). * Il reste sur place sinon.
- Son *temps de gestation* est réinitialisé.
* La variable *durée de gestation des thons* voit sa valeur réduite de 1.
--- * Si ce temps arrive à 0, le thon donne naissance à un nouveau
thon qui nait sur la case qu'il vient de quitter **_uniquement si celui ci s'est déplacé_**
### Comportement des Requins * Le temps de gestation est alors remis à sa valeur initiale.
1. **Énergie**
- Le requin perd 1 point d'énergie.
Pour les **_requins_** :
2. **Déplacement**
- Il cherche une case voisine contenant un thon pour le manger. * Le requin perd 1 point d'_energie_
Si une telle case existe : * Si le niveau d'énergie du requin est à 0, il meurt.
- Il s'y déplace et mange le thon.
- Son *énergie* est réinitialisée. * Le requin choisit aléatoirement parmi ses voisines
- Sinon, il choisit une case voisine vide. une case occupée par un thon :
- S'il n'y en a pas, il reste sur place.
* S'il en existe une, le requin se
3. **Mort** déplace vers cette case et mange le thon. Son niveau d'_énergie_
- Si l'énergie du requin atteint 0, il meurt. est alors remis à sa valeur initiale.
4. **Reproduction** * Sinon il cherche à se déplacer vers une case voisine vide choisie au hasard. Il reste sur place s'il n'y en a aucune.
- Son *temps de gestation* diminue de 1.
- Si ce temps atteint 0 : * Le _temps de gestation du requin_ est diminué de 1 :
- Il se reproduit sur la case qu'il quitte (s'il s'est déplacé).
- Son *temps de gestation* est réinitialisé. * Si ce temps arrive à 0, il donne naissance à un nouveau
requin sur la case qu'il vient de quitter **si et uniquement s'il s'est déplacé**.
---
* Son temps de gestation est remis à sa valeur initiale.
## Phénomènes Émergents
----------
La simulation peut générer des **cycles proies-prédateurs** si les paramètres sont bien choisis.
**_A votre avis : si les paramètres sont mal ajustés que risque t-il de se produire_** ?
### Paramètres Clés
C'est exact : Le nombre de thons sera trop faible au bout d'un moment, et le cycle recherché disparaitra.
- *Temps de gestation des thons*.
- *Énergie des requins*. Pour notre simulation, il est necessaire de bien paramétrer notre programme afin de voir emerger un cycle qui va régir la population:
- *Durée de gestation des requins*.
* Lorsqu'il y aura suffisament de thons, le nombre de requin va accroitre.
Pour observer un cycle périodique, il faut respecter : * Cela va donc réduire le nombre de thons...
**temps gestation des thons < énergie des requins < durée gestation des requins**. * Puis lorsqu'il y n'y aura plus assez de thons, les requins vont disparaitre.
* Et de nouveaux, le nombre de thon va grandir...
### Configuration Initiale
La chose à éviter est donc l'extinction totale des thons, car on ne pourrait plus relancer la simulation.
- **30%** des cases occupées par des thons.
- **10%** des cases occupées par des requins. Il faut donc respecter une règle :
Valeurs suggérées : ```
temps gestation des thons < énergie des requins < durée gestation des requins
- Temps gestation des thons : **2**.
- Énergie des requins : **3**. ```
- Durée gestation des requins : **5**.
_Que peut-on choisir comme valeurs, selon vous?_
---
**Nous prendront ces valeurs ci :**
## Travail à Réaliser * Temps de gestation des thons : 2
* Energie des requins : 3
L’objectif est de programmer une simulation Wa-Tor sur un nombre donné de pas. * Durée de gestations des requins : 5
### Étapes
Question :
1. **Concevoir les structures de données**.
2. **Décomposer le programme** en fonctions ou classes. Il y a un paramètre important qu'il nous reste à gérer :
3. **Programmer et tester** progressivement. **Combien de thons et de requins doit on initialiser au lancement de notre simulation ?**
### Questions Clés
- Quels défis vos élèves pourraient-ils rencontrer ? ### Algorithme
- Quelles notions ce TP permet-il d’évaluer ?
--- Avant de commencer à travailler sur le code, il est necessaire de revenir sur l'algorithme. Celui ci nous permettra d'avoir une feuille de route claire, et de savoir exactement ce que l'on doit faire. Ne restera plus qu'à réaliser cela à travers python.
## Rendu Attendu
Ici, nous avons un exemple d'algorithme sur la gestion des thons:
- **L’activité complète en markdown**.
- **Corrigé** détaillé. ![Algorithme_thon](assets/Algo_thon.png)
- **Notions abordées** dans l'activité.
Trouvez vous cet algorithme fonctionnel ?
Déposez votre travail sur **GitLab** avec votre enseignant ajouté comme **développeur**.
**_Ecrire un algorithme similaire pour les requins._**
---
L'important ici, est de bien couvrir tous les cas de figure possibles :
## Compléments
Plus nous seront précis dans l'algorithme, plus le travail de programmation sera facile.
### Affichage des Résultats
Pour visualiser l'évolution de la mer, on peut afficher l'état de la grille tous les 100 pas, avec une petite pause entre chaque affichage :
------------
```python
import time ### Programmation
time.sleep(0.1) # pause de 1/10e de seconde
``` Dans le but de faciliter notre tâche, voilà la marche à suivre :
**Analyse des Populations** * Créer une classe Animal, qui comprendra les différents paramètres qui vont régir l'évolution d'un thon ou d'un requin par exemple
* Créer une classe World, dans laquelle nous pourrons définir toutes les fonctions necessaires au bon fonctionnement de notre simulation
Ajoutez des variables globales pour suivre : * Appeler les fonctions pour lancer la simulation
​ • Nombre de thons. C'est parti !
​ • Nombre de requins. Pour commencer, appelons donc les bibliothèques que nous pourrions avoir besoin :
Question : trouvez le mot clé permettant d'importer les bibliothèques ci dessous, et ajoutez le à votre code.
Enregistrez ces données à chaque pas sous forme de triplets : ```python
i***** matplotlib
(numéro du pas, nombre de thons, nombre de requins). pylab
random
numpy
time
**Tracé des Courbes** ```
Maintenant, pensons aux quelques variables que l'on aura besoin d'utiliser :
Utilisez pylab pour visualiser l’évolution des populations :
Pour créer la mer, et la diviser en grille, il nous faudra donc un nombre de lignes, et un nombre de colonnes :
```python
`import pylab` ```python
`data_x = [pas1, pas2, ..., pasN]` n_lignes = 25
`data_y1 = [nb_thons1, nb_thons2, ..., nb_thonsN]` n_colonnes = 25
`data_y2 = [nb_requins1, nb_requins2, ..., nb_requinsN]`
`pylab.plot(data_x, data_y1, label="Thons")` ```
`pylab.plot(data_x, data_y2, label="Requins")` Puis, on décomptera le nombre de thons et de requins afin de garder le ratio souhaité, puis nous initialiserons les paramètres que l'on appliquera:
`pylab.title("Évolution des populations")`
`pylab.legend()` ```python
`pylab.show()` n_thon = 0
``` n_requin = 0
energie_init_thon = 10
energie_init_requin = 3
temps_gestation_thon = 2
temps_gestation_requin = 5
```
On peut donc passer aux choses sérieuses :
Créez une classe Animal, qui intégrera les paramètres associés aux thons et requins :
```python
class Animal():
def __init__(self, id, energie_base, temps_gestation, x, y):
...
```
​
Puis la classe World, dans laquelle on initialisera la grille que l'on utilise pour simuler une mer :
```python
class Wator():
def __init__(self,...):
self. =
self. =
self.grille =
self.nbcase = hauteur * largeur
self.animaux = []
```
Deux choses importantes :
Pour notre grille, il est primordial de choisir une structure efficace.
**Indice** : Comment crée t-on un tableau ou _array_ en python ?
Il faut ensuite ajouter les fonctions pour que notre océan se remplisse :
* Gérer le peuplement de la mer
* Gérer le placement des animaux
* Une fonction pour créer la grille
* ???
Nous allons utiliser une structure pour retenir le type d'animal présent sur une case de coordonées x, y.
C'est ici que l'on peut reflechir au quota que l'on aura :
on propose 30% de thon, 10% de requins, et 60% de cases vides.
Vu le nombre d'animaux qu'il va falloir gérer, quelle structure proposez vous ?
```python
def ...:
= ...(a_id, energie_init[a_id], temps_gestation[a_id], x, y)
self.animaux.append(animal)
self.grille[y][x] = animal
```
Ici, on applique donc notre quota :
```python
def peupler(self, n_thon = 30, n_requin = 10 ):
self.n_thon = n_thon
self.n_requin = n_requin
```
Pour le placement des thons et requins, il va nous falloir utiliser une boucle, afin de générer des créatures jusqu'à ce que l'on ai le nombre de thons et de requins souhaité.
```python
def generer_placement(n_animaux, a_id):
... i in ...(n_animaux):
... True:
x, y = divmod(random.randrange(self.nbcase), self.hauteur)
if not self.grid[y][x]:
self.pop_animal(a_id, x, y)
break
generer_placement(n_thon, thon)
generer_placement(n_requin, requin)
```
```python
def tableau_grille(self):
return [[self.grille[y][x].id if self.grille[y][x] else 0
for x in range(self.largeur)] for y in range(self.hauteur)]
```
Il est important de vérifier les cases voisines quand on fait déplacer un thon ou un requin :
D'abord, on cherche à obtenir leur coordonées.
Pour cela, on a besoin de p-upplets ou d'un dictionnaire :
```python
def voisin(self, x, y):
voisin = {}
for dx, dy in ((0,-1), (1,0), (0,1), (-1,0)):
xp, yp = (x+dx) % self.largeur, (y+dy) % self.hauteur
voisin[xp,yp] = self.grille[yp][xp]
return voisin
```
Il ne nous reste plus qu'à créer la fonction qui permettra à notre mer, à notre monde, d'évoluer
```python
def evolution(self, animal):
voisin = self.voisin(animal.x, animal.y)
# Ajouter +1 à la gestation.
déplacement = False
Si l'animal est un requin
try:
xp, yp = utiliser la bibliothèque random...
..............
...................
if not déplacement:
try:
xp, yp = random.choice([position
for position in voisin if voisin[position]==case])
if animal.id != thon:
animal.energie -= 1
déplacement = True
except IndexError:
xp, yp = animal.x, animal.y
if animal.energie < 0:
animal.vie = False
self.grille[animal.y][animal.x] = case
elif déplacement:
x, y = animal.x, animal.y
animal.x, animal.y = xp, yp
self.grille[yp][xp] = animal
if animal.gestation >= animal.temps_gestation:
animal.gestation = 0
self.pop_animal(animal.id, x, y)
else:
self.grille[y][x] = case
def progression(self):
random.shuffle(self.animal)
n_animal = len(self.animal)
for i in range(n_animal):
animal = self.animal[i]
if not animal.vie:
continue
self.evolution(animal)
self.animaux = [animal for animal in self.animaux if animaux.vie]
```
Mais après tout cela : comment voir ce que l'on a crée ?
Comment s'assurer que cela fonctionne ?
Il nous faut une représentation graphique :
```python
def image_grille(self):
img = self.tableau_grille()
trace = plt.figure(figsize=(10, 5), dpi = 36)
axe = fig.add_subplot(100)
return trace
def afficher_image(self):
trace = self.image_grill()
plt.show()
```
​
​