les premiers pas d une souris (Fonctionnel).py
À propos du fichier
- Type de fichier
- Fichier PY de 24 Ko (text/x-python)
- Confidentialité
- Fichier public, envoyé le 24 février 2016 à 11:25, depuis l'adresse IP 88.160.x.x (France)
- Sécurité
- Ne contient aucun Virus ou Malware connus - Dernière vérification: 2 jours
- Statistiques
- La présente page de téléchargement a été vue 833 fois depuis l'envoi du fichier
- Page de téléchargement
-
Aperçu du fichier
# ------------------------ Importation ------------------------ #
from time import *
from tkinter import *
from random import *
# ------------------------ Déclaration ------------------------ #
x = 20 # Indique la position x initiale du premier carré
y = 20 # Indique la position y initiale du premier carré
r = 10 # Le rayon des carrés (éviter de le modifier)
Nmbrx = 30 # Définit en nombre de carré la Largeur de la box
Nmbry = 20 # Définit en nombre de carré la Hauteur de la box
xSave = 20 # Indique la position x initiale du Sauveteur
ySave = 20 # Indique la position y initiale du sauveteur
IDSauveteur = "" # C'est une chaîne de caractère qui va recevoir la valeur de l'ID du sauveteur
xPoint = xSave # La position du pointeur en x
yPoint = ySave # La position du pointeur en y
deplacement = [] # Créer une liste qui enregistrera tous les déplacements éfféctués par la souris
num = 0 # un compteur afin de se retrouver dans la liste il fonctionne de pair avec "ineg"
ineg = 0 # ---
RETURN = 0 # Cette variable est un interrupteur, elle nous permettra de savoir quand le sauveteur devra faire marche arrière.
ISSUE = 1 # Quand cette variable sera égale à 0 il n'y aura plus d'issus.
CREATE = FALSE # Cet interrupteur permet d'activé le placement de "way"
PUTFINISH = FALSE # Cet interrupteur permet d'activé le placement de "finish"
FINISH = FALSE # Cet interrupteur permet de savoir si le sauveteur a trouvé la case finale.
# ------------------------ Fonctions ------------------------ #
# ----------------------------------------------- #
"""Cette fonction va permettre de générer tous les murs et de placer le sauveteur à son emplacement initial."""
def Generer():
""" Va Génerer la salle """
global x , y , Largeur , Hauteur, item, r, IDSauveteur,xSave,ySave, FINISH, ISSUE, num, ineg, deplacement
num = 0
ineg = 0
deplacement = []
FINISH = 0
ISSUE = 1
Canevas.delete(ALL)
xSave = 20 # Indique la position x initiale du Sauveteur
ySave = 20 # Indique la position y initiale du sauveteur
#Cette conndition permet de remplir le tableau
while x <= Largeur-2 * r and y<= Hauteur-2 * r:
# Va crer un rectangle au niveau du curseur.
item = Canevas.create_rectangle(x-r, y-r, x+r, y+r, outline='black', fill= "#00DD00" )
if (x < Largeur - 2 * r): # Fait les retours à la ligne si nécessaires
x = x + 2 * r
y = y
else:
x = 2 * r
y = y + 2 * r
print("Création de",item,"rectangles")
x = 2 * r
y = 2 * r
Canevas.addtag_all ("wall")
"""------------------------Placer Le sauveteur-----------------------------"""
#Formation
""" Va placer le sauveteur"""
Canevas.create_rectangle(xSave-r, ySave-r, xSave+r, ySave+r, outline='black', fill= "#FF0000" ) # Va placer le rectangle par rapport aux positions initiales
IDSauveteur = Canevas.find_closest (xSave,ySave , halo = None, start = None) # Va récupérer L'id du sauveteur.
IDSauveteur = str(IDSauveteur)[1:len(str(IDSauveteur))-2] # Permet de retourner l'ID du sauveteur sans les parenthèse et sans la virgule
print (IDSauveteur)
Canevas.addtag_withtag ("sauveteur", IDSauveteur)
# ----------------------------------------------- #
"""Cette fonction va renvoyé les TAGS des cases ,haut, droite, bas et gauche, du sauveteur"""
def Check():
global IDSauveteur , xSave, ySave,r, TAGCaseTop, TAGCaseBot, TAGCaseRight, TAGCaseLeft
CaseTop = Canevas.find_closest (xSave, ySave - 2 * r, halo = None, start = None)
CaseTop = str(CaseTop)[1:len(str(CaseTop))-2]
TAGCaseTop = Canevas.gettags (CaseTop)
print ("Le Tag de la caseTOP est :" , TAGCaseTop)
CaseBot = Canevas.find_closest (xSave, ySave + 2*r , halo = None, start = None)
CaseBot = str(CaseBot)[1:len(str(CaseBot))-2]
TAGCaseBot = Canevas.gettags (CaseBot)
print ("Le Tag de la caseBOT est :" , TAGCaseBot)
CaseRight = Canevas.find_closest (xSave + 2 * r, ySave, halo = None, start = None)
CaseRight = str(CaseRight)[1:len(str(CaseRight))-2]
TAGCaseRight = Canevas.gettags (CaseRight)
print ("Le Tag de la caseRIGHT est :" , TAGCaseRight)
CaseLeft = Canevas.find_closest (xSave- 2 * r, ySave , halo = None, start = None)
CaseLeft = str(CaseLeft)[1:len(str(CaseLeft))-2]
TAGCaseLeft = Canevas.gettags (CaseLeft)
print ("Le Tag de la caseLEFT est :" , TAGCaseLeft)
return TAGCaseTop, TAGCaseBot, TAGCaseRight, TAGCaseLeft
# ----------------------------------------------- #
"""Cette fonction va renvoyé les TAGS des cases ,haut, droite, bas et gauche, du chien (pour tenter de créer une carte aléatoire)"""
def CheckChien():
global IDChien , x, y,r, TAGCaseTop, TAGCaseBot, TAGCaseRight, TAGCaseLeft
CaseTop = Canevas.find_closest (x, y - 2 * r, halo = None, start = None)
CaseTop = str(CaseTop)[1:len(str(CaseTop))-2]
TAGCaseTop = Canevas.gettags (CaseTop)
print ("Le Tag de la caseTOP est :" , TAGCaseTop)
CaseBot = Canevas.find_closest (x, y + 2 * r, halo = None, start = None)
CaseBot = str(CaseBot)[1:len(str(CaseBot))-2]
TAGCaseBot = Canevas.gettags (CaseBot)
print ("Le Tag de la caseBOT est :" , TAGCaseBot)
CaseRight = Canevas.find_closest (x + 2 * r, y, halo = None, start = None)
CaseRight = str(CaseRight)[1:len(str(CaseRight))-2]
TAGCaseRight = Canevas.gettags (CaseRight)
print ("Le Tag de la caseRIGHT est :" , TAGCaseRight)
CaseLeft = Canevas.find_closest (x- 2 * r, y , halo = None, start = None)
CaseLeft = str(CaseLeft)[1:len(str(CaseLeft))-2]
TAGCaseLeft = Canevas.gettags (CaseLeft)
print ("Le Tag de la caseLEFT est :" , TAGCaseLeft)
return TAGCaseTop, TAGCaseBot, TAGCaseRight, TAGCaseLeft
# ----------------------------------------------- #
"""Cette fonction ne fait que vérifier si la case finale, la sortie est adjacente au sauveteur."""
def CheckFinish():
global IDSauveteur , xSave, ySave,r, TAGCaseTop, TAGCaseBot, TAGCaseRight, TAGCaseLeft, FINISH
if str(TAGCaseTop) == "('finish',)":
ySave = ySave - 2*r
Canevas.coords(IDSauveteur, xSave-r, ySave-r, xSave+r, ySave+r) # Repositionne Le sauveteur avec les nouvelles coordonées
Canevas.addtag_closest ("Vu", xSave, ySave + 2*r ) # Va mettre une marque à son dernier emplacement de manière à indiquer que ce chemin est vu.
FINISH = 1
if str(TAGCaseRight) == "('finish',)":
xSave = xSave + 2*r
Canevas.coords(IDSauveteur, xSave-r, ySave-r, xSave+r, ySave+r) # Repositionne Le sauveteur avec les nouvelles coordonées
Canevas.addtag_closest ("Vu", xSave - 2*r , ySave) # Va mettre une marque à son dernier emplacement de manière à indiquer que ce chemin est vu.
FINISH = 1
if str(TAGCaseBot) == "('finish',)":
ySave = ySave + 2*r
Canevas.coords(IDSauveteur, xSave-r, ySave-r, xSave+r, ySave+r) # Repositionne Le sauveteur avec les nouvelles coordonées
Canevas.addtag_closest ("Vu", xSave, ySave - 2*r ) # Va mettre une marque à son dernier emplacement de manière à indiquer que ce chemin est vu.
FINISH = 1
if str(TAGCaseLeft) == "('finish',)" :
xSave = xSave - 2*r
Canevas.coords(IDSauveteur, xSave-r, ySave-r, xSave+r, ySave+r) # Repositionne Le sauveteur avec les nouvelles coordonées
Canevas.addtag_closest ("Vu", xSave + 2*r , ySave ) # Va mettre une marque à son dernier emplacement de manière à indiquer que ce chemin est vu.
FINISH = 1
# ----------------------------------------------- #
"""Cette fonction permettra au sauveteur de se déplacer de manière aléatoire, sur les différents choix de chemin qui s'ofrent à lui."""
def MvmtFree():
global TAGCaseTop, TAGCaseBot, TAGCaseRight, TAGCaseLeft, ySave, xSave, RETURN, deplacement, ineg, num
liste = []
i = 0
bouger = 0
if str(TAGCaseTop) == "('way',)":
print("Top libre")
liste.append (1)
i += 1
if str(TAGCaseRight) == "('way',)":
print("Right libre")
liste.append (2)
i += 1
if str(TAGCaseBot) == "('way',)":
print("Bot libre")
liste.append (3)
i += 1
if str(TAGCaseLeft) == "('way',)" or str(TAGCaseLeft) == "('finish',)":
print("Left libre")
liste.append (4)
i += 1
if i != 0 :
ineg = 0
bouger = choice(liste)
print (bouger)
if bouger == 1:
ySave = ySave - 2*r
Canevas.coords(IDSauveteur, xSave-r, ySave-r, xSave+r, ySave+r) # Repositionne Le sauveteur avec les nouvelles coordonées
Canevas.addtag_closest ("Vu", xSave, ySave + 2*r ) # Va mettre une marque à son dernier emplacement de manière à indiquer que ce chemin est vu.
deplacement.append (1) # Ajoute le déplacement haut (1) à l'historique des déplacements
num += 1
elif bouger == 2:
xSave = xSave + 2*r
Canevas.coords(IDSauveteur, xSave-r, ySave-r, xSave+r, ySave+r) # Repositionne Le sauveteur avec les nouvelles coordonées
Canevas.addtag_closest ("Vu", xSave - 2*r , ySave) # Va mettre une marque à son dernier emplacement de manière à indiquer que ce chemin est vu.
deplacement.append (2) # Ajoute le déplacement droite (2) à l'historique des déplacements
num += 1
elif bouger == 3:
ySave = ySave + 2*r
Canevas.coords(IDSauveteur, xSave-r, ySave-r, xSave+r, ySave+r) # Repositionne Le sauveteur avec les nouvelles coordonées
Canevas.addtag_closest ("Vu", xSave, ySave - 2*r ) # Va mettre une marque à son dernier emplacement de manière à indiquer que ce chemin est vu.
deplacement.append (3) # Ajoute le déplacement bas (3) à l'historique des déplacements
num += 1
elif bouger == 4:
xSave = xSave - 2*r
Canevas.coords(IDSauveteur, xSave-r, ySave-r, xSave+r, ySave+r) # Repositionne Le sauveteur avec les nouvelles coordonées
Canevas.addtag_closest ("Vu", xSave + 2*r , ySave ) # Va mettre une marque à son dernier emplacement de manière à indiquer que ce chemin est vu.
deplacement.append (4) # Ajoute le déplacement gauche (4) à l'historique des déplacements
num += 1
else:
print ("Marche arrière")
RETURN = 1
# ----------------------------------------------- #
"""Cette fonction permettra au sauveteur de retourner en arrière jusqu'à son dernier choix."""
def Return():
global ySave, xSave, RETURN, ISSUE, deplacement, num, ineg
bouger = 0 # Cette variable va indiquer la direction à suivre, (coordonées sont inversés par rapport à la fonction MvmtFree car le sauveteur devra faire les mouvements contraires de ceux déjà éxécutés).
if 2 * ineg < num -1:
bouger = deplacement [num-1 - 2 * ineg] # Va assigné à la variable bouger la valeur des déplacements précédents.
if bouger == 1:
ySave = ySave + 2*r
Canevas.coords(IDSauveteur, xSave-r, ySave-r, xSave+r, ySave+r) # Repositionne Le sauveteur avec les nouvelles coordonées
Canevas.addtag_closest ("Block", xSave, ySave - 2*r ) # Va mettre une marque à son dernier emplacement de manière à indiquer que ce chemin est le mauvais.
deplacement.append (3) # Ajoute le déplacement bas (3) à l'historique des déplacements
elif bouger == 2:
xSave = xSave - 2*r
Canevas.coords(IDSauveteur, xSave-r, ySave-r, xSave+r, ySave+r) # Repositionne Le sauveteur avec les nouvelles coordonées
Canevas.addtag_closest ("Block", xSave + 2*r , ySave ) # Va mettre une marque à son dernier emplacement de manière à indiquer que ce chemin est le mauvais.
deplacement.append (4) # Ajoute le déplacement gauche (4) à l'historique des déplacements
elif bouger == 3:
ySave = ySave - 2*r
Canevas.coords(IDSauveteur, xSave-r, ySave-r, xSave+r, ySave+r) # Repositionne Le sauveteur avec les nouvelles coordonées
Canevas.addtag_closest ("Block", xSave, ySave + 2*r ) # Va mettre une marque à son dernier emplacement de manière à indiquer que ce chemin est le mauvais.
deplacement.append (1) # Ajoute le déplacement haut (1) à l'historique des déplacements
elif bouger == 4:
xSave = xSave + 2*r
Canevas.coords(IDSauveteur, xSave-r, ySave-r, xSave+r, ySave+r) # Repositionne Le sauveteur avec les nouvelles coordonées
Canevas.addtag_closest ("Block", xSave - 2*r , ySave) # Va mettre une marque à son dernier emplacement de manière à indiquer que ce chemin est le mauvais.
deplacement.append (2) # Ajoute le déplacement droite (2) à l'historique des déplacements
else:
ISSUE = 0 # Va indiquer qu'il n'y a plus d'issus
RETURN = 0
print (ineg)
print (num)
ineg += 1
num += 1
# ----------------------------------------------- #
"""Cette fonction permettra De gérer les différentes fonctions liés aux déplacements avec toutes les conditions nécéssaires."""
def Bouger():
global TAGCaseTop, TAGCaseBot, TAGCaseRight, TAGCaseLeft, ySave, xSave, RETURN, ISSUE, FINISH, ISSUE, ineg, num
while FINISH == 0 and ISSUE == 1:
Check ()
CheckFinish()
print (RETURN)
print (FINISH)
if FINISH == 1 and ISSUE == 1: # Cette condition va vérifier si nous avons trouvé la fin du labyrinthe.
print ("Votre petite souris a trouvé la sortie.")
elif FINISH == 0 and ISSUE == 1: # Cette condition va vérifier que nous n'avons pas trouvé trouvé la fin et si nous ne sommes pas au point où il n'y a plus d'issus.
if RETURN == 0:
MvmtFree ()
if RETURN == 1:
Return ()
Canevas.dtag ("Vu", "way")
Canevas.dtag ("Block", "Vu")
Canevas.dtag ("Block","way")
Canevas.dtag ("wall","Vu")
Canevas.itemconfigure ("Vu", outline= "#000000", fill= "#0000CC" )
Canevas.itemconfigure ("Block", outline= "#000000", fill= "#FF9933" )
cadre.update()
sleep (0.2)
if ISSUE == 0 : # Cette condition s'effectuera si aucune issue n'a était trouvé au labyrinthe.
print ("Ce labyrinthe est sans issus. Votre souris risque de décéder.")
# ----------------------------------------------- #
"""Cette fonction va générer la map automatiquement, en créant un pointeur qui créera la map.(en cours de création.)"""
def Auto():
global TAGCaseTop, TAGCaseBot, TAGCaseRight, TAGCaseLeft, y, x, RETURN
Canevas.create_rectangle(x-r, y-r, x+r, y+r, outline='black', fill= "#FFFF99" ) # Va placer le rectangle par rapport aux positions initiales
IDChien = Canevas.find_closest (x,y , halo = None, start = None) # Va récupérer L'id du chien.
IDChien = str(IDChien)[1:len(str(IDChien))-2] # Permet de retourner l'ID du chien sans les parenthèse et sans la virgule
print (IDChien)
Canevas.addtag_withtag ("chien", IDChien)
b = 0
while b != 200:
CheckChien ()
liste = []
i = 0
bouger = 0
if str(TAGCaseTop) == "('wall',)" :
print("Top libre")
liste.append (1)
i += 1
if str(TAGCaseRight) == "('wall',)" :
print("Right libre")
liste.append (2)
i += 1
if str(TAGCaseBot) == "('wall',)" :
print("Bot libre")
liste.append (3)
i += 1
if str(TAGCaseLeft) == "('wall',)" :
print("Left libre")
liste.append (4)
i += 1
if i != 0 :
bouger = choice(liste)
print (bouger)
if bouger == 1:
y = y - 2*r
Canevas.coords(IDChien, x-r, y-r, x+r, y+r) # Repositionne Le chien avec les nouvelles coordonées
Canevas.addtag_closest ("way", x, y + 2*r )
elif bouger == 2:
x = x + 2*r
Canevas.coords(IDChien, x-r, y-r, x+r, y+r)
Canevas.addtag_closest ("way", x - 2*r , y)
elif bouger == 3:
y = y + 2*r
Canevas.coords(IDChien, x-r, y-r, x+r, y+r)
Canevas.addtag_closest ("way", x ,y - 2*r )
elif bouger == 4:
x = x - 2*r
Canevas.coords(IDChien, x-r, y-r, x+r, y+r)
Canevas.addtag_closest ("way", x + 2*r , y )
b += 1
Canevas.dtag ("way", "wall")
Canevas.itemconfigure ("way", outline= None, fill= "#999999" )
# ----------------------------------------------- #
"""Cette fonction va permettre de déplacer le sauveteur (à l'aide du clavier) avant de le lancer dans le labyrinthe"""
def clavier(event):
global coords , IDSauveteur, xSave, ySave
touche = event.keysym #La variable touche récupère la valeur de la touche entrée
"""Les quatres diffférents déplacements possibles"""
if touche == "Up" and ySave - 2*r > 0: # Si l'utilisateur appuie sur la touche haut, le sauveteur se déplacera vers le haut d'une case. Tant qu'il ne sort pas du cadre.
ySave = ySave - 2*r
elif touche == "Down" and ySave + 2*r < Hauteur: # Si l'utilisateur appuie sur la touche bas, le sauveteur se déplacera vers le bas d'une case.
ySave = ySave + 2*r
elif touche == "Right" and xSave + 2*r < Largeur: # Si l'utilisateur appuie sur la touche droite, le sauveteur se déplacera vers la droite d'une case.
xSave = xSave + 2*r
elif touche == "Left" and xSave - 2*r > 0: # Si l'utilisateur appuie sur la touche gauche, le sauveteur se déplacera vers la gauche d'une case.
xSave = xSave -2*r
Canevas.coords(IDSauveteur, xSave-r, ySave-r, xSave+r, ySave+r) # Repositionne Le sauveteur avec les nouvelles coordonées
if touche == "Escape": # Pour quitter le programme
cadre.destroy()
# -----------"""Fonctions souris"""----------- #
# ----------------------------------------------- #
"""Cette fonction permet d'activé l'interrupteur nous permettant de placé des chemin"""
def Create():
global CREATE, PUTFINISH
CREATE = TRUE
PUTFINISH = FALSE
# ----------------------------------------------- #
"""Cette fonction permet d'activé l'interrupteur nous permettant de placé une ligne d'arrivée"""
def PutFinish():
global CREATE, PUTFINISH
CREATE = FALSE
PUTFINISH = TRUE
# ----------------------------------------------- #
"""Cette fonction va permettre placer certains points, les chemins ou le point final."""
def Clic(event):
global r, sauveteur, IDSauveteur, CREATE, PUTFINISH
# Va chercher les valeurs des coordonées de la souris X et Y
X = event.x
Y = event.y
if PUTFINISH == TRUE:
# Va donner au carre le plus proche des coordonées de la souris le TAG "finish"
Canevas.addtag_withtag('wall', 'finish')
Canevas.dtag ("wall", "finish")
Canevas.itemconfigure ("wall", outline= "#000000", fill= "#00DD00" )
Canevas.addtag_closest ("finish", X, Y)
if CREATE == TRUE:
# Va donner au carre le plus proche des coordonées de la souris le TAG "way"
Canevas.addtag_closest ("way", X, Y)
"""CLEAN"""
# Ce bloc permet d'éviter que les objet aient différents TAG
Canevas.dtag ("way", "wall")
Canevas.dtag ("sauveteur", "way")
Canevas.dtag ("sauveteur", "finish")
Canevas.dtag ("finish", "way")
Canevas.dtag ("finish", "wall")
Canevas.itemconfigure ("sauveteur", outline= "#000000", fill= None )
Canevas.itemconfigure ("finish", outline= "#000000", fill= "#FFFF00" )
Canevas.itemconfigure ("wall", outline= "#000000", fill= "#00DD00" )
Canevas.itemconfigure ("way", outline= None, fill= "#999999" )
# -----------"""Fonctions utilitaires"""----------- #
# ----------------------------------------------- #
"""Cette fonctione permet de nettoyer la zone graphique"""
def Effacer():
Canevas.delete(ALL)
# ----------------------------------------------- #
"""Cette fonctione permet de fermer la fenetre."""
def Quitter(event):
cadre.destroy()
# ----------------------------------------------- #
"""Cette fonctione permet d'empecher le sauveteur de se déplacer en cas de problème."""
def Interrupt():
global FINISH
FINISH = 1
# ------------------------ Partie graphique ------------------------ #
# Création de la fenêtre principale (main window)
cadre = Tk()
cadre.title('La souricière')
# Création d'un widget Canevas (zone graphique)
Largeur = r * 2 * Nmbrx
Hauteur = r * 2 * Nmbry
Canevas = Canvas(cadre, width = Largeur, height =Hauteur, bg ='white')
Canevas.pack(padx =5, pady =5)
# Création d'un widget Button (bouton Go)
BoutonGo = Button(cadre, text ='Go', command = Generer)
BoutonGo.pack(side = LEFT, padx = 5, pady = 5)
# Création d'un widget Auto (bouton Auto)
BoutonAuto = Button(cadre, text ='Auto', command = Auto)
BoutonAuto.pack(side = LEFT, padx = 5, pady = 5)
# Création d'un widget Auto (bouton Create)
BoutonGo = Button(cadre, text ='Create', command = Create)
BoutonGo.pack(side = LEFT, padx = 5, pady = 5)
# Création d'un widget Auto (bouton PutFinish)
BoutonGo = Button(cadre, text ='PutFinish', command = PutFinish)
BoutonGo.pack(side = LEFT, padx = 5, pady = 5)
# Création d'un widget Button (bouton Effacer)
BoutonEffacer = Button(cadre, text ='Effacer', command = Effacer)
BoutonEffacer.pack(side = LEFT, padx = 5, pady = 5)
# Création d'un widget Button (bouton Check)
BoutonCheck = Button(cadre, text ='Check', command = Check)
BoutonCheck.pack(side = LEFT, padx = 5, pady = 5)
# Création d'un widget Button (bouton Bouger)
BoutonBouger = Button(cadre, text ='Bouger', command = Bouger)
BoutonBouger.pack(side = LEFT, padx = 5, pady = 5)
# Création d'un widget Button (bouton Interrupt)
BoutonInterrupt = Button(cadre, text ='Interrupt', command = Interrupt)
BoutonInterrupt.pack(side = LEFT, padx = 5, pady = 5)
# Création d'un widget Button (bouton Quitter)
BoutonQuitter = Button(cadre, text ='Quitter', command = cadre.destroy)
BoutonQuitter.pack(side = LEFT, padx = 5, pady = 5)
Canevas.focus_set() # Permet de réinitialisé le focus, il est conseillé d'en placer un pour éviter certains bugs.
Canevas.bind('<Button-1>',Clic) # évévement clic gauche (press)
Canevas.bind('<B1-Motion>',Clic) # évévement clic gauche (enfoncé)
Canevas.bind("<Key>", clavier) # Récupère la touche entrée
cadre.mainloop()
Partager le fichier les-premiers-pas-d-une-souris (Fonctionnel).py sur le Web et les réseaux sociaux:
Télécharger le fichier les-premiers-pas-d-une-souris (Fonctionnel).py
Télécharger les-premiers-pas-d-une-souris (Fonctionnel).py
