# Python - Les fonctions

Dans le précédent TP vous avez vu les bases du langage Python. Vous les avez mises en pratique dans de petits programmes, et vous savez maintenant gérer des variables, des structures conditionnelles et des structures répétitives (les boucles). Vous pouvez déjà faire beaucoup de choses en Python avec ça.

Dans ce TP, nous allons commencer à utiliser Visual Studio Code, qui nous servira toute l'année d'éditeur de texte pour la plupart des TP. Ensuite, nous verrons une notion indispensable à tous les langages de programmation : les fonctions. Nous en profiterons pour réutiliser les notions du TP précédent pour continuer de les pratiquer et, petit à petit, mieux les maîtriser. Vous écrirez, pas à pas, un programme plus conséquent que ce que vous avez écrit jusqu'à maintenant. 

## 1 - Utilisation de Visual Studio Code

### 1.1 - Mise en route

Pour ce TP nous n'allons plus utiliser Thonny mais Visual Studio Code. Thonny est un excellent logiciel pour débuter en python, et il sera facile à utiliser pour vous entraîner à la maison, mais il n'est pas beaucoup utilisé par les professionnels car il manque de nombreuses fonctionnalités indispensables. Visual Studio Code est un éditeur de texte libre édité par Microsoft, compatible avec toutes les plateformes. Il permet de faire ce que fait Thonny, mais également plein d'autres choses. C'est un logiciel très utilisé en entreprise et pourra vous servir pour de nombreux langages de programmation. C'est pour cela que nous allons commencer à l'utiliser, et vous vous habituerez à son fonctionnement au fil du temps.

Lancez Visual Studio Code depuis le menu démarrer de votre machine. Vous verrez une interface comme ci-dessous. Sur la capture d'écran, les sections dont vous aurez besoin lors de ce TP sont indiquées par des flèches.

![alt text](image-3.png)

![alt text](image-8.png)

```admonish travail
- Ouvrez un répertoire : créez un sous-répertoire dans votre espace personnel, sous `projets/python/tp2_fonctions/` et selectionnez-le. Cochez la case et cliquez sur `Yes, I trust the authors` si la fenêtre ci-dessous s'ouvre.
    ![alt text](image-4.png)
- Vérifiez dans le menu extensions que l'extension Python proposée par Microsoft soit bien installée. Sinon, recherchez-la dans la barre de recherche du menu des extensions et installez-la. 

    ![alt text](image-6.png)

    Cette extension vous permettra d'avoir une coloration syntaxique ainsi que des suggestions pour écrire le code qui vous seront très utiles. Elle vous permettra aussi de détecter des erreurs de syntaxe, ce qui pourra vous permettre de progresser plus vite.
- Ouvrez l'explorateur. Vous verrez qu'il n'y a aucun fichier, ce qui est normal. Nous en créerons un tout à l'heure.
- Ouvrez le menu Terminal, et cliquez sur `Nouveau terminal`. Vous verrez apparaître un volet en bas avec un terminal prêt à l'emploi. 

    ![alt text](image-7.png)

- Dans le terminal, tapez la commande `python`. Vous verrez apparaître l'invite de commande de l'interpréteur python. Vous pourrez l'utiliser pour essayer des commandes python au cours du TP. En attendant, essayez de taper `print("Hello, World!")` dans l'interpréteur pour vérifier que tout fonctionne.

    ![alt text](image-9.png)

- Dans l'explorateur, faites un clic droit et créez un nouveau fichier que vous appellerez `main.py`. Dans ce fichier, ajoutez la ligne `print("Hello, World!")`. 
    ![alt text](image-5.png)
- Via l'explorateur Windows, allez dans le répertoire de travail que vous avez sélectionné à la première étape. Vous y trouverez votre fichier main.py nouvellement créé : l'explorateur de VSCode montre le contenu de votre répertoire de travail. Mais vous l'avez toujours sous les yeux, ce qui est bien plus pratique.
- Dans un nouveau terminal (vous pouvez cliquer sur le petit + en haut à droite du volet terminal actuel) tapez `python main.py`. Vous devriez voir s'afficher `Hello, World!` dans le terminal.
    ![alt text](image-10.png)

- Cliquez maintenant sur le triangle en haut à droite de votre fichier. Vous devriez voir un nouveau terminal s'ouvrir et votre script sera exécuté. Vous connaissez maintenant deux méthodes pour lancer un script Python dans VSCode. 

    ![alt text](image-11.png)

    Remarquez que dans ce second cas, VSCode utilise des chemins absolus (depuis `C:/`), tandis que vous avez utilisé un chemin relatif (depuis le répertoire de travail).

Nous voilà prêts à travailler.
```

## 2 - Les fonctions

### 2.1 - Utilisation d'une fonction

Nous allons maintenant écrire un script que nous modifierons pour découvrir les fonctions. 

Vous connaissez déjà certaines fonctions, celles que vous avez utilisées lors du précédent TP : `print`, `input`, `math.sqrt`, `range` ... Ce sont des fonctions que vous avez **appelées** mais qui existent déjà, soit par défaut dans le langage Python, soit dans une bibliothèque (`math`).

```admonish travail
1. Copiez le script suivant dans votre fichier `main.py`. Indiquez les fonctions que vous identifiez.

    ~~~python
    import math

    nb = 7

    print("Table par 7 : ")
    for i in range(1, 11):
        print(f"{i} * {nb}", "=", i*nb)

    racine_carree = math.sqrt(7)
    retour_print = print(f"Racine carrée de {nb} : {racine_carree}")
    ~~~

1. Indiquez les symboles utilisés pour appeler des fonctions.
1. 
    1. Quels sont les **arguments** (ou **paramètres**) passés à la fonction `range` ligne 6 ? 
    1. Quel symbole sert à les séparer ? 
    1. Que se passe-t-il si on retire ce symbole ?
1.
    1. Modifiez l'ordre des arguments passés à `print` ligne 7. Qu'est-ce que ça change ?
    1. Ajoutez à la fonction `print` ligne 7 un argument `sep='-'`. Réexécutez le script. Qu'est-ce que ça change ? 
    1. Ajoutez maintenant un argument `end='|'` à la fonction `print` ligne 7. Réexécutez le script. Qu'est-ce que ça change ?
    1. Expliquez selon vous ce que font les paramètres `sep` et `end` de la fonction `print`
    1. Inversez l'ordre des paramètres `sep` et `end` entre les parenthèses. Qu'est-ce que ça change ? À votre avis pourquoi ?
1. 
    1. Quelle est la valeur de la variable `racine_carree` à la fin du script ? D'où vient cette valeur ?
    1. Quelle est la valeur de la variable `retour_print` à la fin du script ? À votre avis pourquoi ?
```

```admonish success title="À retenir"
- Les fonction s'utilisent avec la syntaxe suivante : `nom_de_la_fonction(parametre_1, parametre_2, ...., parametre_n)`
    - Vous mettez le nom de la fonction, suivi de parenthèses
    - Entre les parenthèses vous mettez les paramètres séparés par des virgules
    - Si une fonction n'a pas besoin de paramètres, les parenthèses sont quand même indispensables

- Certaines fonctions peuvent prendre des paramètres nommés, avec la syntaxe suivante : `nom_de_la_fonction(nom_parametre=valeur_parametre)`. Les paramètres nommés sont toujours à la fin et leur ordre n'a pas d'importance.

- Une fonction peut renvoyer un résultat, que l'on peut alors affecter à une variable.
    - Si une fonction ne renvoie rien, alors elle renverra en réalité la valeur spéciale `None`.
```

### 2.2 - Créer notre première fonction

Maintenant que vous savez comment utiliser une fonction nous allons créer une fonction par nous-mêmes.

Si on reprend le code de la partie précédente, on voit qu'il permet d'afficher la table de multiplication par 7. Nous allons en faire une fonction.

```admonish travail
1. Remplacez le contenu de votre fichier main.py par le code qui suit. C'est le même que dans la partie précédente, débarrassé des choses qui ne servent pas à calculer notre table de 7. Vérfiez qu'il affiche correctement ce que vous attendez.
    ~~~python
    nb = 7

    print("Table par 7 : ")
    for i in range(1, 11):
        print(f"{i} * {nb}", "=", i*nb)
    ~~~
2. Une fonction se définit de la manière suivante :
    ~~~python
    def nom_de_la_fonction(parametre_1, parametre_2, ..., parametre_n):
        # Instructions
    ~~~
    - On utilise le mot-clé `def` suivi du nom de la fonction. 
    - Entre parenthèses on ajoute les paramètres qu'il faudra fournir
    - à la fin de la ligne on met `:` (encore et toujours)
    - On passe à la ligne suivante et on indente pour écrire les instructions.

    Modifiez le code pour mettre le contenu au dessus dans une fonction, comme ci-dessous. Puis exécutez-le. Que se passe-t-il ? A votre avis, pourquoi ?
    ~~~python
    def table_par_7():
        nb = 7

        print("Table par 7 : ")
        for i in range(1, 11):
            print(f"{i} * {nb}", "=", i*nb)
    ~~~
3. Il faut en réalité appeler notre fonction maintenant. En 2. elle était uniquement déclarée, Python connaissait son existence. Mais nous ne lui avons jamais dit de l'utiliser. 
    1. Ajoutez alors la ligne `table_par_7()` à la toute fin du fichier. Exécutez le code et vérifiez que cette fois, tout se passe comme prévu.
    2. Déplacez cette ligne tout en haut du fichier. Que se passe-t-il ? Pourquoi à votre avis ?
    3. Replacez la ligne à la fin du fichier, comme en 3.1.

4. Bon, maintenant nous avons une fonction qui fait la même chose qu'avant. Mais si on veut calculer la table par 5 ou 8, il nous faudrait pouvoir passer la valeur en paramètre.
    1. Renommez la fonction en `table`, puisqu'elle nous servira à d'autres tables que celle par 7
    2. Ajoutez un argument `nb` dans la définition et retirez la variable `nb = 7`
    ~~~python
    def table(nb):
        print(f"Table par {nb} : ")
        for i in range(1, 11):
            print(f"{i} * {nb}", "=", i*nb)
    ~~~
    3. Maintenant, donnez le code nécessaire pour afficher la table par 5. Vérifiez que cela fonctionne bien dans votre script.
5. Ajoutez un nouveau paramètre `maximum` qui servira à déterminer le nombre de lignes à afficher. Par exemple, si `nb` vaut 5 et `maximum` vaut 20, on affichera la table de 5 avec les valeurs de 1 à 20. 
    
    Modifiez les appels à votre fonction en conséquence et vérifiez que tout fonctionne comme prévu.
    
    Mettez le code dans votre compte rendu.

6. Dans la majorité des cas on voudra probablement afficher la table jusqu'à 10. Pour nous éviter de devoir préciser `maximum` à chaque fois, nous allons mettre une valeur par défaut à `maximum` pour que la fonction affiche les 10 premières lignes si le paramètre n'est pas précisé. 

    Pour cela ajoutez simplement `=10` dans la déclaration de la fonction, à côté de l'argument `maximum`. Cela affectera la valeur 10 à `maximum` si rien n'est précisé. 

    Exécutez votre fonction avec `table(5, 20)` puis `table(7)` et vérifiez que nous avons bien la table par 5 de 1 à 20 dans le premier cas, et la table par 7 de 1 à 10 dans le second

7. Copiez le code suivant à la suite de votre fichier, puis exécutez-le. Quelle est la dernière ligne qui s'affiche ? À votre avis pourquoi ? 
    ~~~python
    def exemple():
        print("Ma première fonction d'exemple")

    def exemple():
        print("Ma deuxième fonction d'exemple")

    exemple()
    ~~~
```

```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):
        # Instructions
    ~~~
    - On utilise le mot-clé `def` suivi du nom de la fonction. 
    - Entre parenthèses on ajoute les paramètres qu'il faudra fournir
    - À la fin de la ligne on met `:` (encore et toujours)
    - On passe à la ligne suivante et on indente pour écrire les instructions.
- Les paramètres fonctionnent comme des variables : on peut les utiliser dans la fonction avec leur nom.
- On peut définir une valeur par défaut à un paramètre : il suffit d'écrire `parametre=valeur_par_defaut` lors de la déclaration. On peut alors omettre le paramètre, qui prendra automatiquement la valeur par défaut.
- 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'
- On nomme les fonctions en `snake_case` en Python
- 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
    ~~~
```

### 2.3 - L'instruction `return`

```admonish travail
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.
1. Expérimentez pour répondre aux questions suivantes. Donnez le code utilisé à chaque fois.
    1. Que retourne une fonction qui utilise l'instruction `return` sans préciser de valeur ?
    1. Que se passe-t-il si une instruction se trouve après l'instruction `return` dans votre fonction ?
    1. Que retourne une fonction qui n'a pas d'instruction `return` ?
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(...)`.
```

### 2.4 - Mise en pratique

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 les fonctions suivantes à l'aide des règles du jeu :
    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 est 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 le nombre de 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. 
```

# Annexes

## Un peu d'anglais
|Français|Anglais|
|-|-|
|Appeler une fonction|Call a function|
|Virgule|Comma|
|Parenthèses|Brackets|
|Crochets|Square brackets|
|Accolades|Curly brackets|