WIP - TP Python Fonctions

src/cours/CIEL1/01-bases-python/tp/02_fonctions.md

@@ -153,6 +153,7 @@ Si on reprend le code de la partie précédente, on voit qu'il permet d'afficher
 ```
 
 ```admonish success title='À retenir'
+- Les fonctions servent à rendre votre code plus clair et mieux découpé. Elles permettent de réutiliser du code.
 - Pour déclarer une fonction en python :
     ~~~python
     def nom_de_la_fonction(parametre_1, parametre_2, ..., parametre_n):
@@ -167,11 +168,180 @@ Si on reprend le code de la partie précédente, on voit qu'il permet d'afficher
 - Deux fonctions ne peuvent pas avoir le même nom, sinon, la dernière a avoir été déclarée écrase la précédente.
 ```
 
+```admonish tip title='Bonnes pratiques'
+- Faites des fonctions courtes qui vont à l'essentiel (20 lignes est un bon maximum)
+- Choisissez bien les noms de vos fonctions et de vos paramètres pour qu'ils soient clairs et explicites
+- Vous pouvez documenter vos fonctions à l'aide d'une **docstring** : après l'en-tête de la fonction, avant le bloc d'instructions vous pouvez écrire une chaîne de caractères qui commence par 3 `"` ou `'`. 
+    Exemple:
+    ~~~python
+    def ma_fonction(arg_1, arg2):
+        """Ceci est une docstring qui vient documenter ma fonction.
+        Une docstring peut prendre plusieurs lignes.
+        """
+        # Bloc d'instructions
+    ~~~
+```
+
 ### L'instruction `return`
-- return value
-- return seul
-- après le return, rien n'est exécuté
+
+```admonish return
+1. Créez un nouveau fichier dans l'explorateur, nomme carre.py puis copiez la fonction ci-dessous :
+    ~~~python
+    def aire_carre(cote):
+        aire = cote * cote
+        return aire
+    ~~~
+   Que fait l'instruction `return` selon vous ? N'hésitez pas à expérimenter
+2. Donnez le code permettant d'affecter le résultat de la fonction à une variable pour ensuite l'afficher. Vous pourrez calculer l'aire d'un carré de côté 3m pour cet exemple.
+3. Modifiez la fonction comme suit :
+    ~~~python
+    def aire_carre(cote):
+        aire = cote * cote
+        print("Avant return")
+        return aire
+        print("Après return")
+    ~~~
+    Exécutez la fonction. Que se passe-t-il ? Pourquoi à votre avis ? 
+    
+    Vous pouvez retirer les deux lignes `print` pour la suite.
+4. Modifiez la fonction comme suit:
+    ~~~python
+    def aire_carre(cote):
+        aire = cote * cote
+        return
+    ~~~
+    1. Affectez le résultat de la fonction à une variable, puis affichez cette variable. Quelle valeur a la variable ? pourquoi ?
+    1. Retirez la ligne return et recommencez. Est-ce que cela change quelque chose ?
+1. Nous voulons maintenant que notre fonction renvoie l'aire **et** le périmètre d'un carré. Pour cela, modifions la fonction comme suit.
+   ~~~python
+   def carre(cote):
+       aire = cote * cote
+       perimetre = cote * 4
+       return aire, perimetre
+   ~~~
+   1. Affectez le résultat de la fonction à une variable. Que vaut-elle ?
+   2. Appelez la fonction de la manière suivante : `aire_carre, perimetre_carre = carre(3)`. Que valent les variables `aire_carre` et `perimetre_carre` ? Que s'est-il passé selon vous ?
+1. Écrivez une fonction qui permet de diviser deux nombres. Cette fonction devra renvoyer la chaîne de caractères "Erreur : division par zéro impossible" si le deuxième nombre vaut zéro. Elle renverra le résultat dans tous les autres cas. Appelez la fonction dans les deux cas et affichez le résultat pour vérifier qu'elle fonctionne comme prévu.
+```
+
+```admonish success title="A retenir"
+- L'instruction `return` permet de sortir immédiatement d'une fonction. Rien ne s'exécutera après le `return`
+- `return` permet de retourner un résultat, avec la syntaxe `return valeur`. Si aucune valeur n'est mentionnée, elle retournera `None`
+- Si `return` n'est pas mentionnée, la fonction s'exécute jusqu'au bout et sortira à la fin du bloc d'instructions en retournant `None`
+- On peut retourner plusieurs valeurs en les séparant par une virgule. 
+    - Ces valeurs peuvent être affectées à une seule variable sous forme d'un **tuple** (nous en parlerons au prochain TP)
+    - Chaque valeur peut être affectée à une variable différente avec la syntaxe `variable_1, variable_2 ... = nom_de_la_fonction(...)`.
+```
 
 ### Mise en pratique
 
-## Les modules
+Nous allons mettre en pratique ce que nous avons vu jusqu'à maintenant dans un script un peu plus conséquent.
+
+L'objectif est de créer un mini jeu dans lequel vous pourrez jouer à la roulette. Les règles seront évidemment simplifiées.
+
+- Le joueur mise sur un nombre (entier) entre 0 et 49, et annonce une mise en jetons (par exemple : 20 jetons).
+- La croupière lance la roulette, et celle-ci déterminera le numéro gagnant. Les numéros impairs ont une couleur rouge, les numéros pairs sont noirs.
+    - Si le joueur a misé sur le numéro gagnant, il remporte 3 fois sa mise
+    - Si le joueur a misé sur un nombre de même couleur (donc de même parité que le numéro gagnant), il remporte 0,5 fois sa mise (arrondi à l'entier supérieur, car les jetons sont toujours entiers)
+    - Sinon, le joueur perd sa mise. Notons qu'il la garde dans les deux autres cas, en plus de ses gains.
+- Le joueur aura 100 jetons disponibles au début de la partie. Il ne peut miser qu'un nombre entier de jeton, et seulement des jetons qu'il possède.
+- Si le joueur tombe à zéro jetons, la partie est finie.
+- Sinon, il peut rejouer (mais n'est pas obligé).
+
+Imprégnez-vous bien des règles du jeu.
+
+
+```admonish travail
+1. Créez un nouveau fichier appelé `roulette.py`.
+2. Copiez le contenu suivant dedans. Ce sera la structure du script, que vous complèterez à l'aide des questions suivantes. 
+
+    Il y a de nombreux `#TODO` (parfois `"#TODO"`) qu'il faudra remplacer par le code adéquat.
+
+    L'instruction `pass` sert à ne rien faire tout en ayant un script valide qui pourra donc s'exécuter sans erreur pour que vous puissiez avancer et tester votre code. Vérifiez que le code ci-dessous fonctionne sans erreur (il ne fera évidemment pas ce qui est demandé, ça c'est votre job !)
+
+    ~~~python
+    from random import randint
+    #TODO
+
+    def miser(jetons_restants):
+        #TODO
+        return 7, 12
+
+    def choisir_nombre():
+        nombre = -1
+        while "#TODO condition" :
+            nombre = "#TODO demander un nombre à l'utilisatrice"
+            if "#TODO condition":
+                print("Erreur : le nombre doit être compris entre 0 et 49")
+        return nombre
+
+    #TODO fonction miser_jetons
+
+    def tourner_la_roulette():
+        numero = 8 #TODO
+        print(f"Le croupier tourne la roulette. Le numéro {numero} est le numéro gagnant !")
+        return numero
+
+    def calculer_gains_couleur(mise):
+        pass #TODO
+
+    def calculer_gains_numero(mise):
+        pass #TODO
+
+    def continuer_de_jouer(jetons_restants):
+        return #TODO Effacer cette ligne quand ce sera demandé
+        if "#TODO condition":
+            print("Vous êtes ruiné.e. C'est la fin de la partie.")
+            #TODO Retourner une valeur
+        else:
+            #TODO Afficher les jetons restants (avec une phrase)
+            rejouer = input("Souhaitez-vous continuer ? (o/n)")
+            if rejouer == "o" or rejouer == "O":
+                pass #TODO Retourner une valeur
+            else:
+                #TODO Annoncer qu'on quitte le jeu avec le nombre de jetons restants
+                pass #TODO Retourner une valeur
+
+    jetons = 100
+    continuer = True
+
+    while continuer:
+        gains = 0
+        numero_misé, mise = miser(jetons)
+
+        numero_gagnant = tourner_la_roulette()
+        #TODO Écrire ici la condition principale, pour déterminer les gains
+
+        jetons += gains
+        continuer = continuer_de_jouer(jetons)
+    ~~~
+
+3. Expliquez les étapes du programme qui se déroulent dans la boucle à la fin du script, et quand est-ce qu'elle s'arrête.
+1. Complétez à l'aide des règles du jeu au dessus les fonctions :
+    1. `calculer_gains_numero`
+    1. `calculer_gains_couleur`. Comme nous voulons arrondir à l'entier supérieur, il faudra importer et utiliser la fonction `ceil` du module `math`. 
+    
+    Pour vérifier vos résultats, vous pouvez soit utiliser l'interpréteur en console, soit appeler les fonctions dans votre script et utiliser `print` pour afficher le résultat
+
+2. Allez à la ligne `#TODO Écrire ici la condition principale, pour déterminer les gains`. Cette condition correspond à celle qui permet de savoir si un joueur a gagné ou non.
+    1. Écrivez la condition en utilisant les fonctions `calculer_gains_couleur` et `calculer_gains_numero`. N'oubliez pas le cas où le joueur perd.
+    2. Ajoutez des `print` dans chaque branche pour annoncer les gains ou pertes.
+    3. Testez les différents cas possibles en modifiant les valeurs retournées par la fonction `tourner_la_roulette`
+1. Maintenant que nous sommes sûrs que nos trois cas fonctionnent, nous allons pouvoir réellement tirer un nombre au hasard. Pour cela, nous avons déjà importé la fonction `randint` du module `random` dont voici la [documentation](https://docs.python.org/3.13/library/random.html#random.randint) :
+    > random.**randint**(a, b)
+    >
+    > Return a random integer N such that a <= N <= b. Alias for randrange(a, b+1).
+    
+    1. Expliquez brièvement ce que fait `randint`
+    2. Modifiez la fonction `tourner_la_roulette` de façon à ce qu'elle retourne un nombre entre 0 et 49 tiré aléatoirement.
+
+1. Le coeur du jeu semble maintenant fonctionner. Il ne reste plus qu'à permettre à la joueuse d'interagir avec le programme. Commençons par la mise.
+    1. Complétez la fonction `choisir_nombre` de façon à ce que l'on demande à la joueuse un nombre tant que celui-ci n'est pas valide. Pour simplifier, considérons que personne ne s'amusera à entrer autre chose que des nombres (nous verrons plus tard dans l'année un moyen bien plus efficace de gérer les erreurs).
+    2. Complétez la fonction `miser` pour qu'elle utilise notre fonction nouvellement complétée. Vérifiez que tout fonctionne comme prévu.
+    3. Sur le même modèle que `choisir_nombre`, écrivez une fonction `miser_jetons` qui permettra à la joueuse de choisir un nombre de jetons à miser. Attention : il faudra vérifier qu'elle ne mise pas plus de jetons que ce qu'elle a. Vous aurez donc besoin d'un paramètre pour passer les jetons restants à votre fonction.
+    4. Complétez la fonction `miser` pour qu'elle utilise notre nouvelle fonction. Vérifiez que tout fonctionne comme prévu.
+
+1. Maintenant, il ne reste plus qu'à demander au joueur s'il souhaite continuer de jouer, et mettre fin à la partie s'il n'a plus de jetons. Dans la fonction `continuer_de_jouer`, retirez la première ligne, celle qui contient un `return`. Complétez le reste de la fonction en remplaçant les lignes contenant la mention `#TODO`. Testez votre programme de bout en bout.
+
+1. Mettez le programme final dans votre compte rendu. 
+```

src/cours/CIEL1/01-bases-python/tp/roulette.py

@@ -0,0 +1,70 @@
+from random import randint
+from math import ceil
+
+def miser(argent_restant):
+    numero = choisir_nombre()
+    mise = miser_argent(argent_restant)
+    return numero, mise
+
+def choisir_nombre():
+    nombre = -1
+    while not (0 <= nombre <= 49):
+        nombre = int(input("Choisissez un nombre (0-49) : "))
+        if not (0 <= nombre <= 49):
+            print("Erreur : le nombre doit être compris entre 0 et 49")
+    return nombre
+
+def miser_argent(argent_restant):
+    mise = -1
+    while not (0 < mise <= argent_restant):
+        mise = int(input(f"Choisissez votre mise (argent disponible : {argent_restant}) : "))
+        if not (0 < mise <= 49):
+            print(f"Erreur : la mise doit être comprise entre 1 et {argent_restant}")
+    return mise
+
+def tourner_la_roulette():
+    numero = randint(0, 49)
+    print(f"Le croupier tourne la roulette. Le numéro {numero} est le numéro gagnant !")
+    return numero
+
+def calculer_gains_couleur(mise):
+    return ceil(mise*0.5)
+
+def calculer_gains_numero(mise):
+    return mise * 3
+
+def continuer_de_jouer(argent):
+    if argent <= 0:
+        print("Vous êtes ruiné.e. C'est la fin de la partie.")
+        return False
+    else:
+        print(f"Il vous reste {argent}")
+        rejouer = input("Souhaitez-vous continuer ? (o/n)")
+        if rejouer == "o" or rejouer == "O":
+            return True
+        else:
+            print(f"Vous quittez le jeu avec {argent}")
+            return False
+
+argent = 100
+continuer = True
+
+while continuer:
+    gains = 0
+    numero_misé, mise = miser(argent)
+
+    numero_gagnant = tourner_la_roulette()
+    if numero_misé == numero_gagnant:
+        gains = calculer_gains_numero(mise)
+        print(f"Bravo, vous avez misé sur le numéro gagnant. Vous gagnez {gains}")
+    elif numero_misé % 2 == numero_gagnant % 2:
+        gains = calculer_gains_couleur(mise)
+        print(f"Bravo, vous avez misé sur la bonne couleur. Vous gagnez {gains}")
+    else:
+        gains = -mise
+        print(f"Dommage, vous avez perdu votre mise : {mise}")
+
+    argent += gains
+    continuer = continuer_de_jouer(argent)
+
+

src/cours/CIEL1/01-bases-python/tp/roulette_debut.py

@@ -0,0 +1,56 @@
+from random import randint
+#TODO
+
+def miser(jetons_restants):
+    #TODO
+    return 7, 12
+
+def choisir_nombre():
+    nombre = -1
+    while "#TODO" :
+        nombre = "#TODO"
+        if "#TODO":
+            print("Erreur : le nombre doit être compris entre 0 et 49")
+    return nombre
+
+#TODO fonction miser_jetons
+
+def tourner_la_roulette():
+    numero = 8 #TODO
+    print(f"Le croupier tourne la roulette. Le numéro {numero} est le numéro gagnant !")
+    return numero
+
+def calculer_gains_couleur(mise):
+    #TODO
+    pass
+
+def calculer_gains_numero(mise):
+    #TODO
+    pass
+
+def continuer_de_jouer(jetons_restants):
+    return #TODO Effacer cette ligne quand ce sera demandé
+    if "#TODO condition":
+        print("Vous êtes ruiné.e. C'est la fin de la partie.")
+        #TODO Retourner une valeur
+    else:
+        #TODO Afficher les jetons restants (avec une phrase)
+        rejouer = input("Souhaitez-vous continuer ? (o/n)")
+        if rejouer == "o" or rejouer == "O":
+            pass #TODO Retourner une valeur
+        else:
+            #TODO Annoncer qu'on quitte le jeu avec le nombre de jetons restants
+            return False
+
+jetons = 100
+continuer = True
+
+while continuer:
+    gains = 0
+    numero_misé, mise = miser(jetons)
+
+    numero_gagnant = tourner_la_roulette()
+    #TODO Écrire la condition principale, pour déterminer les gains
+
+    jetons += gains
+    continuer = continuer_de_jouer(jetons)

src/cours/CIEL1/01-bases-python/tp/roulette_test.py

@@ -0,0 +1,69 @@
+from math import ceil
+from random import randint
+#TODO
+
+def miser(jetons_restants):
+    nombre = choisir_nombre()
+    mise = miser_jetons(jetons_restants)
+    return nombre, mise
+
+def choisir_nombre():
+    nombre = -1
+    while not (0 <= nombre <= 49):
+        nombre = int(input("Choisissez un nombre (0-49) : "))
+        if not (0 <= nombre <= 49):
+            print("Erreur : le nombre doit être compris entre 0 et 49")
+    return nombre
+
+def miser_jetons(jetons_restants):
+    mise = -1
+    while not (0 < mise <= jetons_restants):
+        mise = int(input(f"Choisissez votre mise (argent disponible : {jetons_restants}) : "))
+        if not (0 < mise <= jetons_restants):
+            print(f"Erreur : la mise doit être comprise entre 1 et {jetons_restants}")
+    return mise
+
+def tourner_la_roulette():
+    numero = randint(0, 49)
+    print(f"Le croupier tourne la roulette. Le numéro {numero} est le numéro gagnant !")
+    return numero
+
+def calculer_gains_couleur(mise):
+    return ceil(mise*0.5)
+
+def calculer_gains_numero(mise):
+    return mise*3
+
+def continuer_de_jouer(jetons_restants):
+    if jetons_restants <= 0:
+        print("Vous êtes ruiné.e. C'est la fin de la partie.")
+        return False
+    else:
+        print(f"Il vous reste {jetons_restants} jetons")
+        rejouer = input("Souhaitez-vous continuer ? (o/n)")
+        if rejouer == "o" or rejouer == "O":
+            return True
+        else:
+            print(f"Vous quittez le jeu avec {jetons_restants}")
+            return False
+
+jetons = 100
+continuer = True
+
+while continuer:
+    gains = 0
+    numero_misé, mise = miser(jetons)
+
+    numero_gagnant = tourner_la_roulette()
+    if numero_misé == numero_gagnant:
+        gains = calculer_gains_numero(mise)
+        print(f"Bravo, vous avez misé sur le numéro gagnant. Vous gagnez {gains} jetons")
+    elif numero_misé % 2 == numero_gagnant % 2:
+        gains = calculer_gains_couleur(mise)
+        print(f"Bravo, vous avez misé sur la bonne couleur. Vous gagnez {gains} jetons")
+    else:
+        gains = -mise
+        print(f"Dommage, vous avez perdu votre mise : {gains} jetons")
+
+    jetons += gains
+    continuer = continuer_de_jouer(jetons)