Mon Pythaquarium

Exercice Javaquarium

L'auteur de ce sujet a trouvé une solution à son problème.
Auteur du sujet

Bonjour

Je tente l'exercice du Javaquarium mais en langage python !

Le premier script python que je vous soumets suit a peu prés les premières règles de l'exercice(manger, PV). L'aquarium démarre avec quelques poissons et algues.

Entre chaque tour, du texte explique qui mange quoi, qui meurt …(cela me permet de vérifier le bon fonctionnement).

Le script en Python 3 : Pythaquarium (le mot de passe pour télécharger 'aquarium')

Merci de me donner vos avis sur le code Python (je suis un amateur !)

Édité par Coyote

+0 -0
Staff

Pour les codes, préfère des services comme gists par exemple. On peut ainsi le visualiser en ligne avec coloration syntaxique et sans pub ni mot de passe.

Tu peux le mettre aussi directement sur le site, dans une balise secret si il est trop long :

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import random

class Vivant():

    def __init__(self):
        super(Vivant, self).__init__()
        self.vie = 10

    def variation_vie(self, variation):
        #Augmente la  vitalité  d'une valeur = à 'variation'
        self.vie += variation



class Poisson(Vivant):

    def __init__(self,nom,sexe,regime,race):
        super(Poisson, self).__init__()
        self.nom = nom
        self.sexe = sexe
        self.regime = regime
        self.race = race


class Algue(Vivant):

    def __init__(self):
        super(Algue, self).__init__()



class Aquarium():

    def __init__(self):
        super(Aquarium, self).__init__()
        self.compte_tour = 0
        self.liste_poisson = []  ## Crée une liste vide pour contenir les poissons
        self.liste_algue = []  ##Crée une liste vide pour contenir les algues
        self.ajout_poisson('Alpha','mâle','carnivore')  ## Crée un premier poisson dans l'aquarium

        self.ajout_algue()


    def ajout_poisson(self, nom, sexe,regime, race ='inconnu'):
        """Fonction pour ajouter un poisson et l'ajouter à la liste"""
        self.nom=nom
        self.sexe=sexe
        self.regime=regime
        self.race=race
        self.liste_poisson.append(Poisson(self.nom, self.sexe, self.regime, self.race))

    def ajout_algue(self):
        """Fonction pour ajouter une algue dans l'aquarium et dans une liste"""
        self.liste_algue.append(Algue())

    def manger(self):
        """Simule l'action de manger pour les poissons"""
        print ('############################################')
        print ('Journal des actions: ')
        for self.mangeur in self.liste_poisson:
            print()

            print ('Mangeur : ',self.mangeur.nom,self. mangeur.vie, self.mangeur.race)

            if self.mangeur.regime == 'carnivore':
                self.victime = random.choice(self.liste_poisson)
                print ('Victime : ',self.victime.nom, self.victime.vie, self.victime.race)

                if self.victime.race !=self.mangeur.race:
                    self.victime.variation_vie(-4)
                    self.mangeur.variation_vie(5)

                    if self.victime.vie <= 0:
                        print (self.victime.nom, ' est mort !')
                        self.liste_poisson.remove(self.victime)
                        del self.victime
                else:
                    print ('ne se mange pas lui-meme')
                    print ('ou ne mange pas un poisson de la meme espèce!')
            if self.mangeur.regime == 'herbivore':
                    self.victime = random.choice(self.liste_algue)
                    print ('Algue Victime : ',id(self.victime))
                    self.victime.variation_vie(-2)
                    self.mangeur.variation_vie(3)

                    if self.victime.vie <= 0:
                        print ('Une algue est morte !')
                        self.liste_algue.remove(self.victime)
                        del self.victime



    def tour(self):
        """ Fonction qui gére chaque tour """

        self.affichage()

        if input ('Un autre tour ? (o/n) ') == 'o':
            self.compte_tour += 1
            self.vie_algues = 0

            for ref in (self.liste_poisson):  #Calcul de de la nouvelle vitalité pour chaque poisson
                ref.variation_vie(-1)
                # print(ref.nom,ref.sexe, ref.vie)
            for ref in (self.liste_algue): #Calcul de la nouvelle vitalité pour les algues
                ref.variation_vie(1)
            self.manger()

                # print(ref.nom,ref.sexe, ref.vie)
            self.tour()
        else:
            print ('arret')

    def affichage(self):

        print()
        print ('############################################')
        print ('Tour n° ', self.compte_tour )
        print()

        print ('--- Liste des poissons : (nom/sexe/vitalité/régime/race) ---')
        for ref in (aqua1.liste_poisson):
            print(ref.nom,ref.sexe, ref.vie, ref.regime,ref.race)
        print()
        print ('--- Nombre d\'algues : ', len(self.liste_algue),' ---')


        for ref in (aqua1.liste_algue):
            print('- vitalité : ', ref.vie)
        print()

class Merou(Poisson):
    race = 'Mérou'
    def __init__(self,nom,sexe,regime):
        super(Merou).__init__()

        self.nom = nom
        self.sexe = sexe
        self.regime = regime
        aqua1.ajout_poisson(self.nom, self.sexe, self.regime, self.race)


aqua1=Aquarium()
#aqua1.ajout_poisson('Béta','femelle','herbivore')
aqua1.ajout_poisson('Gamma','femelle','herbivore')
aqua1.ajout_poisson('Delta','femelle','carnivore')
merou1=Merou('Mon Mérou','mâle', 'carnivore')
aqua1.ajout_algue()

aqua1.tour()

au passage, quelques commentaires rapidement :

  • ta deuxième ligne # -*- coding: utf-8 -*- est inutile car c'est ce qui est activé par défaut en python 3.
  • Pour appeler le constructeur de la classe de base, en python 3, on préfère utiliser directement super(). Ainsi tes ligne 8, 20, 30, 37 et 136 se remplacent toutes par super().__init__(). Le gros avantage est que si tu change de classe de base tu n'a pas à modifier ces lignes.
  • Ligne 12 : Tu commente le fonctionnement de la fonction donc utilise une docstring plutot qu'un commentaire.
  • Ligne 19, rajoute des espaces après les virgules pour être compatible PEP8
  • Ligne 29-30, tu ne fais qu'appeler la classe de base dans le constructeur, il ne sert donc à rien. tes lignes 27 à 30 peuvent être résumés en :

    1
    2
    class Algue(Vivant):
        pass
    

  • tes lignes 48 à 51 n'ont pas de sens. Il n'y a aucune raison que les infos soient ajoutés à l'aquarium. Ce devrait être plutot un truc comme :

    1
    2
    def ajout_poisson(self, nom, sexe, regime, race ='inconnu'):
        self.liste_poisson.append(Poisson(nom, sexe, regime, race))
    
    • Idem ligne 62 et suivantes. Il n'y a aucune raison d'en faire des membres de l'instance. La quasi-totalité de tes self sont a virer.
    • La gestion de la mort devrait probablement être directement géré par Vivant() plutot que de répeter du code commun.
    • lignes 104 et 107 les parenthèses sont inutiles.
    • ta ligne 142 n'a pas trop de sens, ce n'est pas à un mérou de s'ajouter à un aquarium

voila déjà très rapidement.

+0 -0
Auteur du sujet

Voici la dernière version de mon Pythaquarium mise dans une balise secret suivant la méthode d'artragis.

!/usr/bin/env python3

import random

class Vivant(): """Classe permettant de créer les êtres vivants""" liste_vivant = [] # Création d'une liste pour enregistrer les vivants créés caractere = 'Vivant' regime = 'inconnu' # Régima alimentaire

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def __init__(self):
    """L'instance créée possede 10 point de vie, est âgée de 0 an et est ajoutée à la liste"""
    self.vie = 10
    self.age = 0
    Vivant.liste_vivant.append(self)

def calcul_age(self):
    """Augmente l'âge de  + 1 et vérifie si le vivant doit mourir"""
    self.age += 1
    Vivant.mort()

def calcul_vitalite(self, variation):
    """Fait varier les points de vie de la valeur 'variation' et vérifie si le vivant doit mourir"""
    self.vie += variation
    Vivant.mort()

def mort():
    """Supprime l'instance de la liste si les PV sont < à 0
        Crée une liste des morts et efface les instances correspondantes"""
    Vivant.liste_mort = [x for x in Vivant.liste_vivant if x.vie <= 0]
    Vivant.liste_vivant = [x for x in Vivant.liste_vivant if x.vie > 0]
    for i in Vivant.liste_mort:
        del i

class Poisson(Vivant): espece = 'Inconnu' regime = 'herbivore'

1
2
3
def __init__(self, nom):
    super().__init__()
    self.nom = nom

class Algue(Vivant): espece = 'algue'

1
2
3
def __init__(self, nom='Algue'):
    super().__init__()
    self.nom = nom

class Merou(Poisson): espece = 'Mérou' regime = 'carnivore'

1
2
def __init__(self, nom='Mon Mérou'):
    super().__init__(nom)

class Aquarium():

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
def __init__(self):
    self.compte_tour = 0

def manger(self):
    """Simule l'action de manger pour les poissons"""
    print ('############################################')
    print ('Manger !!! : ')
    for mangeur in [x for x in Vivant.liste_vivant if x.espece != 'algue']:
        print()

        print ('Mangeur : ', mangeur.nom, mangeur.vie, mangeur.espece)

        if mangeur.regime == 'carnivore':
            victime = random.choice(Vivant.liste_vivant)
            print ('Victime : ', victime.nom, victime.vie, victime.espece)

            if victime.espece != mangeur.espece:
                victime.calcul_vitalite(-4)
                mangeur.calcul_vitalite(5)

            elif victime.nom == mangeur.nom:
                print ('Un poisson ne se mange pas lui-meme !')
            elif victime.espece == mangeur.espece:
                print ('Un poisson ne mange pas un poisson de la meme espèce!')
        if mangeur.regime == 'herbivore':
            if len([x for x in Vivant.liste_vivant if x.espece == 'algue']) >= 1:
                victime = random.choice([x for x in Vivant.liste_vivant if x.espece == 'algue'])
                print ('Algue Victime : ', victime.nom, victime.vie, victime.espece)
                victime.calcul_vitalite(-2)
                mangeur.calcul_vitalite(3)
            else:
                print ('Plus d\'algues ')

def affichage(self):
    print()
    print ('############################################')
    print ('Tour n° ', self.compte_tour)
    print()

    print ('--- Liste : (nom/vitalité/régime/espece/age) ---')
    for i in (Vivant.liste_vivant):
        print ('nom : {}, espèce : {}, age : {}, vitalité : {}' . format(i.nom, i.espece, i.age, i.vie))

def tour(self):
    self.affichage()
    print()
    if input('Un autre tour ? (o/n) ') == 'o':
        self.compte_tour += 1
        print ()
        print ('############################################')
        print ('Journal des actions : ')
        for i in Vivant.liste_vivant:

            i.calcul_age()
            if i.espece == 'algue':
                i.calcul_vitalite(+1)
            else:
                i.calcul_vitalite(-1)
        Vivant.mort()

        print()
        print ('Résultat de la variation de la vitalité et de l\'age :')
        for i in Vivant.liste_vivant:

            print('nom : {}, age : {}, vitalité : {}' . format(i.nom, i.age, i.vie))

        self.manger()
        self.tour()
    else:
        print ('FIN')

if name == "main": aqua1 = Aquarium() Poisson('Toto') Merou('Titi') Algue() aqua1.tour()

+0 -0
Auteur du sujet

Ok c'est mieux avec le ``` (altGr+7 sur mon clavier)

Merci

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
#!/usr/bin/env python3
import random

class Vivant():
    """Classe permettant de créer les êtres vivants"""
    liste_vivant = []  # Création d'une liste pour enregistrer les vivants créés
    caractere = 'Vivant'
    regime = 'inconnu'  # Régime alimentaire

    def __init__(self):
        """L'instance créée possède 10 point de vie, est âgée de 0 an et est ajoutée à la liste"""
        self.vie = 10
        self.age = 0
        Vivant.liste_vivant.append(self)

    def calcul_age(self):
        """Augmente l'âge de  + 1 et vérifie si le vivant doit mourir"""
        self.age += 1
        Vivant.mort()

    def calcul_vitalite(self, variation):
        """Fait varier les points de vie de la valeur 'variation' et vérifie si le vivant doit mourir"""
        self.vie += variation
        Vivant.mort()

    def mort():
        """Supprime l'instance de la liste si les PV sont < à 0
            Crée une liste des morts et efface les instances correspondantes"""
        Vivant.liste_mort = [x for x in Vivant.liste_vivant if x.vie <= 0]
        Vivant.liste_vivant = [x for x in Vivant.liste_vivant if x.vie > 0]
        for i in Vivant.liste_mort:
            del i


class Poisson(Vivant):
    espece = 'Inconnu'
    regime = 'herbivore'

    def __init__(self, nom):
        super().__init__()
        self.nom = nom


class Algue(Vivant):
    espece = 'algue'

    def __init__(self, nom='Algue'):
        super().__init__()
        self.nom = nom


class Merou(Poisson):
    espece = 'Mérou'
    regime = 'carnivore'

    def __init__(self, nom='Mon Mérou'):
        super().__init__(nom)


class Aquarium():

    def __init__(self):
        self.compte_tour = 0

    def manger(self):
        """Simule l'action de manger pour les poissons"""
        print ('############################################')
        print ('Manger !!! : ')
        for mangeur in [x for x in Vivant.liste_vivant if x.espece != 'algue']:
            print()

            print ('Mangeur : ', mangeur.nom, mangeur.vie, mangeur.espece)

            if mangeur.regime == 'carnivore':
                victime = random.choice(Vivant.liste_vivant)
                print ('Victime : ', victime.nom, victime.vie, victime.espece)

                if victime.espece != mangeur.espece:
                    victime.calcul_vitalite(-4)
                    mangeur.calcul_vitalite(5)

                elif victime.nom == mangeur.nom:
                    print ('Un poisson ne se mange pas lui-meme !')
                elif victime.espece == mangeur.espece:
                    print ('Un poisson ne mange pas un poisson de la meme espèce!')
            if mangeur.regime == 'herbivore':
                if len([x for x in Vivant.liste_vivant if x.espece == 'algue']) >= 1:
                    victime = random.choice([x for x in Vivant.liste_vivant if x.espece == 'algue'])
                    print ('Algue Victime : ', victime.nom, victime.vie, victime.espece)
                    victime.calcul_vitalite(-2)
                    mangeur.calcul_vitalite(3)
                else:
                    print ('Plus d\'algues ')

    def affichage(self):
        print()
        print ('############################################')
        print ('Tour n° ', self.compte_tour)
        print()

        print ('--- Liste : (nom/vitalité/régime/espece/age) ---')
        for i in (Vivant.liste_vivant):
            print ('nom : {}, espèce : {}, age : {}, vitalité : {}' . format(i.nom, i.espece, i.age, i.vie))

    def tour(self):
        self.affichage()
        print()
        if input('Un autre tour ? (o/n) ') == 'o':
            self.compte_tour += 1
            print ()
            print ('############################################')
            print ('Journal des actions : ')
            for i in Vivant.liste_vivant:

                i.calcul_age()
                if i.espece == 'algue':
                    i.calcul_vitalite(+1)
                else:
                    i.calcul_vitalite(-1)
            Vivant.mort()

            print()
            print ('Résultat de la variation de la vitalité et de l\'age :')
            for i in Vivant.liste_vivant:

                print('nom : {}, age : {}, vitalité : {}' . format(i.nom, i.age, i.vie))

            self.manger()
            self.tour()
        else:
            print ('FIN')

if __name__ == "__main__":
    aqua1 = Aquarium()
    Poisson('Toto')
    Merou('Titi')
    Algue()
    aqua1.tour()
+0 -0

Cette partie est un peu étrange :

1
2
3
4
5
    def __init__(self):
        """L'instance créée possède 10 point de vie, est âgée de 0 an et est ajoutée à la liste"""
        self.vie = 10
        self.age = 0
        Vivant.liste_vivant.append(self)

En fait tu utilise directement des attributs de classe pour enregistrer tes êtres vivants dès leur création, au lieu d'avoir quelque chose comme :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
class Aquarium:
    def __init__(self):
        self.list_vivants = []

    def add(self, vivant):
        self.list_vivants.append(vivant)

class Vivant:
    def __init__(self):
        self.vie = 10

class Poisson(Vivant):
    pass

aquarium = Aquarium()
aquarium.add(Poisson())

L'avantage de la seconde version, est que tu peut avoir plusieurs aquariums séparés. Avec ta version, tous les aquariums ont le même contenu. C'est la différence entre classe et instance qui est importante ici.

Édité par Luthaf

Mon Github — Tuto Homebrew — Article Julia

+0 -0
Auteur du sujet

Merci Luthaf

Voici ma dernière version :

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
#!/usr/bin/env python3
import random


class Vivant():
    """Classe permettant de créer les êtres vivants"""

    caractere = 'Vivant'
    regime = 'inconnu'  # Régime alimentaire

    def __init__(self):
        """L'instance créée possede 10 point de vie, est âgée de 0 an et est ajoutée à la liste"""
        self.vie = 10
        self.age = 0

    def calcul_age(self):
        """Augmente l'âge de  + 1 et vérifie si le vivant doit mourir"""
        self.age += 1

    def calcul_vitalite(self, variation):
        """Fait varier les points de vie de la valeur 'variation' et vérifie si le vivant doit mourir"""
        self.vie += variation


class Poisson(Vivant):

    table = {'Mérou': ('carnivore','hermaAge'), 'Carpe': ('herbivore','mono'),
    'Sole': ('herbivore','hermaOpp')}  # Création d'un dictionnaire...

    def __init__(self, nom, espece, sexe):
        super().__init__()
        self.nom = nom
        self.espece = espece
        self.sexe = sexe
        self.regime = Poisson.table[espece][0]
        self.sexualite = Poisson.table[espece][1]


class Algue(Vivant):
    espece = 'algue'

    def __init__(self, nom='Algue'):
        super().__init__()
        self.nom = nom

    def reproduire(self):
        pass


class Aquarium():

    def __init__(self):
        self.compte_tour = 0
        self.liste_vivant = []  # Création d'une liste pour enregistrer les vivants créés

    def manger(self):
        """Simule l'action de manger pour les poissons"""
        print('############################################')
        print('Manger !!! : ')
        for mangeur in [x for x in self.liste_vivant if x.espece != 'algue']:
            print()
            print('Mangeur : ', mangeur.nom, mangeur.vie, mangeur.espece)

            if mangeur.regime == 'carnivore':
                victime = random.choice([x for x in self.liste_vivant if x.espece != 'algue'])
                print('Victime : ', victime.nom, victime.vie, victime.espece)

                if victime.espece != mangeur.espece:
                    victime.calcul_vitalite(-4)
                    mangeur.calcul_vitalite(5)
                elif victime.nom == mangeur.nom:
                    print('Un poisson ne se mange pas lui-meme !')
                elif victime.espece == mangeur.espece:
                    print('Un poisson ne mange pas un poisson de la meme espèce!')

            if mangeur.regime == 'herbivore':
                if len([x for x in self.liste_vivant if x.espece == 'algue']) >= 1:
                    victime = random.choice([x for x in self.liste_vivant if x.espece == 'algue'])
                    print('Algue Victime : ', victime.nom, victime.vie, victime.espece)
                    victime.calcul_vitalite(-2)
                    mangeur.calcul_vitalite(3)
                else:
                    print('Plus d\'algues ')

    def add(self, vivant):
        self.liste_vivant.append(vivant)

    def mort(self):
        """Supprime l'instance de la liste si les PV sont < à 0
            Crée une liste des morts et efface les instances correspondantes"""
        liste_mort = [x for x in self.liste_vivant if (x.vie <= 0 or x.age >= 21)]
        self.liste_vivant = [x for x in self.liste_vivant if (x.vie > 0 and x.age < 21)]
        for i in liste_mort:
            print (i.nom, 'disparait')
            del i

    def affichage(self):
        print()
        print('############################################')
        print('Tour n° ', self.compte_tour)
        print()
        print('--- Liste des Vivants en fin de tour dans l\'aquarium : ---')
        print()
        for i in (self.liste_vivant):
            print('nom : {}, espèce : {}, age : {}, vitalité : {}, regime : {}'
            . format(i.nom, i.espece, i.age, i.vie, i.regime))

    def tour(self):
        """"Gére les tours"""
        self.affichage()
        print()
        if input('Un autre tour ? (o/n) ') == 'o':
            self.compte_tour += 1
            print()
            print('############################################')
            print('Journal des actions : ')
            for i in self.liste_vivant:
                i.calcul_age()
                if i.espece == 'algue':
                    i.calcul_vitalite(+1)
                else:
                    i.calcul_vitalite(-1)
            print()
            print('Résultat de la variation de la vitalité et de l\'age :')
            for i in self.liste_vivant:
                print('nom : {}, age : {}, vitalité : {}' . format(i.nom, i.age, i.vie))
            self.mort()
            self.manger()
            self.mort()
            self.tour()
        else:
            print('FIN')

if __name__ == "__main__":
    aqua1 = Aquarium()
    aqua1.add(Poisson('Toto', 'Mérou', 'mâle'))
    aqua1.add(Poisson('Titi', 'Carpe', 'femelle'))
    aqua1.add(Algue())
    #aqua1.add(Algue())
    aqua1.tour()

+1 -0
Vous devez être connecté pour pouvoir poster un message.
Connexion

Pas encore inscrit ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte