# TP Python - Bases

Dans ce TP nous allons revoir les bases de la programmation en python. Nous commencerons par utiliser VSCode, qui nous sevrira d'éditeur de texte pour les TP Python cette année, puis nous verrons quelques exercices permettant de revoir les notions principales :
- Les variables, l'affichage d'informations et la saisie de l'utilisateurice
- Les structures conditionnelles : `if ... elif ... else`
- Les boucles `for` et `while`

Nous en profiterons pour ajouter quelques remarques sur les bonnes pratiques de code au fil de l'eau.

## 1 - Travailler avec Visual Studio Code - 10 minutes

Visual Studio Code est un éditeur de texte libre édité par Microsoft, compatible avec toutes les plateformes. Il 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 (continuer ?) à l'utiliser, et vous vous habituerez à son fonctionnement au fil du temps.

```admonish success title='À retenir'
Un **éditeur de texte** est différent d'un **logiciel de traitement de texte**.
- Un éditeur de texte permet de manipuler du texte brut, sans mise en forme. Il pourra avoir des fonctionnalités de coloration automatique ou de suggestions pour vous aider à écrire dans des langages de programmation. Ex: VSCode, Notepad++, Geany, Gedit, Kate, Sublime Text (non libre)...
- Un logiciel de traitement de texte ne peut pas être utilisé pour écrire du code : il contient de nombreuses informations de mise en forme et travaille généralement avec des fichiers binaires ou un format spécifique très éloigné du texte brut nécessaire à la programmation. Ex: Libre Office Writer, Only Office Document, Microsoft Office Word (non-libre)
```

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
1. Ouvrez un répertoire : créez un sous-répertoire dans votre espace personnel, sous `projets/python/tp1_bases/` 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)
1. 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.
1. Ouvrez l'explorateur. Vous verrez qu'il n'y a aucun fichier, ce qui est normal. Nous en créerons un tout à l'heure.
1. 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)

1. 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)

1. 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)
1. 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.
1. 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)

1. 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 - Variables, opérations, entrées-sorties et chaînes de caractères

```admonish warning title='Attention'
- Pour les parties 2.1 2.2 et 2.3 on travaille dans l'interpréteur python. Il n'y a pas de fichiers à créer.
- Pour votre compte rendu : un simple copier-coller de votre console (la commande et son résultat) suffira, sauf pour les questions d'interprétation.
```

Nous allons commencer par utiliser Python en mode interactif. Cela nous permettra de saisir des instructions, que Python va exécuter. Ouvrez le terminal vu en 5. dans la partie précédente.

Le mode interactif fonctionne de la manière suivante : 
1. Il y a une **invite de commande**, qui est symbolisée par les `>>>`. Comme son nom l'indique, elle est là pour vous inviter à taper une commande.
2. Vous pouvez taper une commande et la valider avec la touche <kbd>Entrée</kbd>
3. Il **évalue l'expression saisie** : il l'analyse et l'exécute
4. Il affiche enfin le résultat.

```admonish tip title="Astuce"
Si vous utilisez les flèches <kbd>&uarr;</kbd> et <kbd>&darr;</kbd> dans l'invite de commande, vous pourrez naviguer dans l'historique des commandes tapées, et réutiliser d'anciennes commandes pour les modifier ou les réexécuter.
```

### 2.1 - Opérateurs - 15 min

```admonish success title="À retenir"
- Python utilise la notation anglo-saxonne pour les nombres non entiers (c'est à dire un point au lieu d'une virgule) : il écrira `4.5` et non pas `4,5`. Il en va de même lorsque vous écrirez des nombres en Python.
- Opérateurs courants en python :

|Opérateur|Explication|
|-|-|
|`+`|Addition|
|`-`|Soustraction|
|`*`|Multiplication|
|`/`|Division|
|`//`|Division entière (renvoie un quotient entier)|
|`%`|Modulo (renvoie le reste de la division euclidienne)|
|`**`|Puissance|

- Les nombres décimaux ont parfois des valeurs approximatives. Il faut être vigilant lorsqu'on les utilise dans des calculs.
```

```admonish travail
1. Dans l'invite de commande, essayez d'effectuer les opérations suivantes. Notez les expressions utilisées et leur résultat.
    - 4 plus 7
    - 9 divisé par 2
    - le quotient de la division euclidienne de 9 par 2
    - 2 puissance 10

3. Divisez 10 par 3. Que remarquez-vous ?
```

### 2.2 - Variables - 30 minutes

Que sont les variables ? C'est la base de tout programme informatique : elles vous permettent de stocker une information (un nombre, le résultat d'un calcul, une phrase sous forme de chaîne de caractères...) pour la réutiliser plus tard.

```admonish success title="À retenir"
- Les variables sont une donnée de votre programme stockée dans l'ordinateur.
- Elles sont nommées et on peut les **affecter** en écrivant `ma_variable = <contenu de ma variable>` (attention la variable est toujours à gauche, le contenu toujours à droite). Affecter signifie mettre un contenu dans la variable.

- Les noms des variables peuvent comporter:
    - Des caratères **alphanumériques**, c'est à dire des lettres minuscules ou majuscules et des chiffres
    - Des `_` (tiret du bas, sur la touche <kbd>8</kbd> de votre clavier)
- Les noms des variables ne peuvent pas commencer par un chiffre
- Les noms des variables sont **sensibles à la casse** : c'est à dire qu'une variable écrite avec des majuscules sera différente d'une variable écrite avec des minuscules (par exemple ma variable `age` sera différente de `Age`)
- Certains mots-clés ne peuvent pas être utilisés comme des noms de variables parce qu'ils sont **réservés**, c'est à dire qu'ils ont une autre signification dans le langage.
- En python, la **convention** veut que l'on écrive les variables sous la forme dite **snake case** : on va l'écrire avec uniquement des minuscules en remplaçant les espaces par des `_`. Par exemple, une variable représentant la date de naissance pourra s'écrire : `date_de_naissance`
```

Vous verrez la plupart des mots **réservés** par la suite, et comprendrez vite pourquoi on ne peut pas les utiliser comme variables, tout en les retenant facilement, mais vous pourrez trouver la liste de ces mot-clés dans la [documentation python](https://docs.python.org/3/reference/lexical_analysis.html#keywords)

```admonish warning title="Important"
Python utilise beaucoup de **conventions** dans son langage. Une convention est une règle qui n'est pas obligatoire mais que tout le monde respecte par habitude, et parce que cela permet d'avoir un code qui est facile à lire par tout le monde. Même si elles sont parfois arbitraires, elles ont en général été pensées et établies par la communauté suite à des retours d'expérience. Par ailleurs, certaines conventions permettent de donner des informations supplémentaires importantes (nous en verrons régulièrement par la suite). 

Pour la suite de ce TP, mais également dans vos TD, projets ou évaluations, vous devrez respecter les conventions que nous verrons pour prendre les bonnes habitudes, sinon je les considèrerai comme des erreurs.
```

```admonish travail

1. Expliquez brièvement ce que fait le code suivant. Ecrivez-le dans l'interpréteur. Quel résultat obtenez-vous pour le prix TTC ?
~~~python
>>> prix_ht = 45
>>> tva = 5.5 / 100
>>> prix_ttc = prix_ht * (1 + tva)
>>> prix_ttc
~~~

1. Affectez une nouvelle valeur à `tva` pour qu'elle prenne la valeur de 20%. Quelle valeur a `prix_ttc` ? Pourquoi ?

1. Recalculez la valeur de `prix_ttc` pour prendre en compte la modification de `tva` (Astuce: vous pouvez utiliser <kbd>&uarr;</kbd> pour retrouver la ligne déjà tapée). Donnez la ligne que vous avez réexécutée.

1. On veut accorder une réduction de 5% sur le prix hors taxe à un client. Redonnez l'expression pour calculer le nouveau `prix_ttc` en tenant compte de la réduction.

1. On veut augmenter la TVA de 1% sans avoir besoin de connaître son taux actuel. Ecrivez l'expression qui permet de le faire.
```

### 2.3 - Types - 15 minutes

Les variables peuvent contenir differents types de données. Nous avons surtout vu des nombres jusqu'à maintenant, mais elles peuvent aussi contenir des **chaînes de caractères** ou d'autres types plus complexes. Nous verrons dans un premier temps les plus simples. 

```admonish success title="À retenir"
- Python est capable de trouver le type d'une donnée tout seul, et cette variable prend le type souhaité lors de l'affectation. On appelle ça du **typage dynamique**
- Python possède une fonction `type` qui permet d'afficher le type de chaque variable. 
- Certains types peuvent être **convertis** en d'autres, selon certaines conditions. On peut pour cela utiliser le type comme une fonction.
    - Si on veut convertir l'entier 3 (de type `int`) en `str`, on peut utiliser l'expression suivante : `str(3)` qui renverra `'3'`
```

```admonish travail
1. En utilisant la fonction `type`, donnez le type des valeurs suivantes:
    - 2 
    - 3.14
    - True
    - "<votre prénom>"
1. Donnez une expression permettant d'affecter le *texte* `'21'` à la variable `mon_age` en utilisant la fonction `str` et l'entier `21`
```

```admonish success title="À retenir"
Voici un tableau recensant les principaux types de base de Python

| Type | Explication | Exemple |
|------|-------------|---------|
| int  | Nombre entier | `1` |
| float | Nombre décimal (à virgule "flottante") | `1.23` |
| bool | Booléen : une valeur pouvant être soit vraie soit fausse | `True` ou `False` |
| str | Chaîne de caractères : des caractères qui se suivent pour représenter du texte | `'Hello !'` |

Les chaînes de caractères peuvent s'écrire avec des guillemets simples `'` (touche <kbd>4</kbd>) (qui est aussi utilisé en apostrophe en français) ou des guillemets doubles `"` (touche <kbd>3</kbd>).

Vous pourrez utiliser des `"` lorsque que votre chaîne contiendra des `'` et inversement. Exemples:
- `"J'aime les spaghettis"`
- `'Elle a dit "Hello"'`
```

### 2.4 - Print et input - 15 minutes

Pour la suite nous allons commencer à utiliser le fichier `main.py` créé au début de ce TP. Ouvrez-le dans VSCode.

```admonish success title="À retenir"
Un fichier contenant du code Python s'appelle un **script**. Les scripts python ont un nom se finissant par l'**extension** `.py`
```

```admonish success title="À retenir"
- La fonction `print` permet d'afficher des chaînes de caractères et/ou des variables.
    - Elle peut prendre plusieurs arguments, et affichera les arguments séparés par un espace
- La fonction `input` permet de demander la personne utilisant votre programme de saisir du texte
    - Elle prend en argument optionnel une chaîne de caractère qui s'affichera avant la saisie
    - Elle renvoie ce qui a été saisi sous forme d'une chaîne de caractères. Il faut donc penser à convertir si vous avez besoin d'un autre type.
    - Le résultat de la fonction peut être immédiatement affecté à une variable.

- Les chaînes de caratères peuvent être **formatées** : on l'écrira sous la forme `f"chaine de caractère {variable}"`, ce qui permettra de remplacer les variables entre accolades `{}` par leur valeur dans la chaîne de caractères. Le `f` avant les guillemets est important car il permet de dire à Python que la chaîne est formatée. Si vous l'oubliez, il ne cherchera pas à remplacer les variables par leur valeur.

Les chaînes formatées sont très utilisées en python. Elles servent à afficher des informations dynamiques en fonction de variables, mais vous aideront aussi à comprendre ce que font vos programmes et vous aider à les corriger.
```

```admonish travail
1. Écrivez un script permettant d'afficher le texte `Hello, World!` grâce à la fonction `print`
2. Écrivez un script permettant de demander à l'utilisateurice d'entrer son âge et le stocker dans une variable. Attention, la variable devra être de type `int`. 
3. En utilisant une **chaîne de caractères formatée**, complétez le script pour afficher la phrase suivante : `Votre nom est <votre nom> et vous avez <votre âge> ans.`
```

## 3 - Structures conditionnelles

### 3.1 - Opérateurs de comparaison et booléens - 20 minutes

```admonish success title='À retenir'
Nous avons vu dans l'activité précédente les opérateurs `==`, `<` et `>`. On les appelle les **opérateurs de comparaison**. Il en existe d'autres :

|Opérateur|Description|
|---------|-----------|
|`==`| Égal à|
|`!=`| Différent de|
|`<`| Strictement inférieur à|
|`>`| Strictement supérieur à|
|`<=`| Inférieur ou égal à|
|`>=`| Supérieur ou égal à|

Attention, l'opérateur d'égalité est bien `==`, et non pas `=`. Utiliser l'opérateur d'affectation `=` pourra produire un code qui s'exécute, mais n'aura pas le résultat que vous attendez.
```

```admonish success title='À retenir'
Les **opérateurs booléens** servent à faire des opérations avec des types `bool` ou pour créer des conditions plus complexes.

|Opérateur| Description|
|---------|------------|
|`and`| Si les deux conditions sont vraies, retourne `True`, sinon `False`|
|`or` | Si **au moins** l'une des deux conditions est vraie, retourne `True`, sinon `False`|
|`not`| Inverse le résultat de la condition|

Les opérateurs booléens peuvent être chainés et combinés pour faire des conditions plus complexes.

Les nombres (et plein d'autres types) peuvent être considérés comme `True` ou `False` dans une condition (ou convertis avec la fonction `bool`).
- Un entier non nul sera considéré comme `True`, un `0` sera considéré comme `False`
- Une chaîne de caractères sera considérée comme `True`, sauf si elle est vide. 
```

```admonish tip title="Astuce"
Les opérateurs `>`, `<`, `>=`, `<=` peuvent être chaînés pour faire des comparaisons d'intervalles. Par exemple, pour vérifier que la variable a est comprise entre 0 et 100, vous pouvez écrire '0 < a < 100'
```

```admonish travail
1. Déclarez les variables suivantes : `a = 1`, `b = 3` et `c = 4` et donnez les expressions et les résultats des opérations suivantes
    - a strictement supérieur à b
    - b égal à '3' (attention aux guillemets)
    - b compris entre a et c
    - a et b différents de c
```

### 3.2 - Les conditions - 30-45 minutes

```admonish success title='À retenir'
Les **structures conditionnelles** ressemblent à ceci : 
~~~python
if condition:
    # Faire quelque chose
elif autre_condition:
    # Faire autre chose
else:
    # Dans tous les autres cas, faire cette chose
~~~

- Elles permettent d'exécuter un code différent selon des conditions.
- Le mot-clé `if` est celui qui indique le début d'une structure conditionnelle. Il est obligatoire.
- Le mot-clé `elif` permet de rajouter des conditions. On peut en mettre autant que l'on veut. Il est optionnel.
- Le mot-clé `else` permet de gérer tous les cas qui n'entrent pas dans les précédentes conditions. Il est forcément en dernier et est optionnel.
- Il est important de ne pas oublier
    - Le symbole `:` à la fin de chaque ligne commençant par `if`, `elif` ou `else`
    - D'indenter votre code, pour indiquer à python ce qui est concerné par une condition. 
- Ne pas indenter correctement un code python est une **erreur de syntaxe**, c'est à dire que le code n'est pas valide et ne pourra pas s'exécuter
```

```admonish tip title='Astuce'
Il est possible d'imbriquer plusieurs conditions, en indentant correctement votre code de la manière suivante:
~~~python
if condition:
   if sous_condition:
        # Faire qqch
    elif sous_condition_2 :
        # Faire autre chose
else:
    # Traiter les autres cas
~~~
```

Nous allons écrire un programme qui permet de déterminer si une année saisie par l'utilisateur ou l'utilisatrice est une année bissextile. 

Ce script va vous permettre de revoir les structures conditionnelles mais également les entrées sorties (`print` et `input`), les variables, et certains opérateurs. N'hésitez donc pas à revenir à ces sections en cas de doute pour bien comprendre.

Une année est bissextile si c'est un multiple de 4, sauf si c'est un multiple de 100. Mais si c'est un multiple de 400 alors elle est quand même bissextile.

Si on pose les choses de manière structurée :
- Si une année n'est pas un multiple de 4, on s'arrête là : elle n'est pas bissextile.
- Si une année est un multiple de 4 alors on regarde si elle est multiple de 100
    - Si oui, on regarde si c'est un multiple de 400
        - Si oui elle est bissextile
        - Sinon elle ne l'est pas
    - Si elle n'est pas un multiple de 100, elle est bissextile

Les termes du problème sont bien posés, prenez le temps d'y réfléchir et de bien comprendre. Un fois que vous pensez avoir bien compris, vous pouvez passer à la suite.

```admonish travail
1. Commencez par dessiner un schéma au brouillon permettant de bien distinguer toutes les possibilités, sous forme d'arbre, chaque embranchement représentant une condition. L'important à ce stade est de bien cerner le problème.
1. Créez un nouveau script appelé `tp01-bissextile.py`
1. Écrivez le code vous permettant de demander à l'utilisateurice de saisir une année, et de la stocker dans une variable. N'oubliez pas de convertir en entier votre année.
1. Ensuite, écrivez la première condition, la plus simple pour vérifier si votre nombre est un multiple de 4 ou non. Nous ne tenons pas compte tout de suite des multiples de 100 et 400. Écrivez dans chaque branche votre `print` pour dire si l'année est bissextile ou non.

    Pour rappel, pour vérifier si un nombre est un multiple de 4, vous pouvez utiliser l'opérateur `%` : `nombre % 4`. Si cela renvoie 0, c'est un multiple de 4. Par ailleurs, le zéro est considéré comme `False` dans une condition.

    Testez bien votre programme, avec différents nombres. Pour vous aider, utilisez le tableau plus bas qui contient quelques années bissextiles ou non.

    Vous pouvez ajouter le code de votre script à cette étape au compte rendu.
1. Maintenant que vous savez vérifier si une année est multiple de 4, vérifions les autres conditions.
    
    Modifiez votre code pour ajouter la nouvelle condition. Testez bien cette nouvelle condition.

1. Maintenant, pour finaliser, vous allez devoir **valider** votre programme, c'est à dire vérifier qu'il fonctionne avec un certain nombre de cas prévus. Testez avec les années du tableau ci-dessous, et vérifiez que les résutats correspondent bien à la dernière colonne. Prenez des captures d'écran de vos résultats pour le compte rendu, et ajoutez le code final de votre script dedans également.
```

Quelques années, selon les critères :

|Année|Multiple de 4|Multiple de 100|Multiple de 400|Bissextile|
|-----|-------------|---------------|---------------|----------|
|2025|non|non|non|non|
|2024|oui|non|non|oui|
|1900|oui|oui|non|non|
|2000|oui|oui|oui|oui|

## 4 - Structures répétitives : `for` et `while` - 30 minutes

```admonish success title="À retenir"
- Les boucles permettent de répéter des instructions plusieurs fois.
- Il y a deux formes, la boucle `while` et la boucle `for`. En pratique, en Python, on préfère utiliser la boucle `for` la majorité du temps.
- La boucle `while` a la syntaxe suivante :
    ~~~python
    while condition_est_respectee :
        # Je fais quelque chose
    ~~~
   - Elle peut se lire de la manière suivante : "Tant que la condition est vraie, faire ..." 
   - Dès que la condition n'est plus respectée la boucle se termine. 
        - Si la condition n'est jamais respectée, le code de la boucle n'est jamais exécuté. 
        - Si la condition est toujours respectée, la boucle s'exécute à l'infini.
        - Il faut donc prévoir, dans votre boucle, un moyen de faire évoluer la condition.
   - Attention au `:` et à l'indentation !
- La boucle `for` a la syntaxe suivante : 
    ~~~python
    for variable in ensemble:
        # Je fais quelque chose
    ~~~
    - Elle peut se lire de la manière suivante : "Pour tous les éléments dans l'ensemble, faire ..."
    - La boucle `for` va **itérer** sur un ensemble de données. Itérer signifie répéter sur chaque élément de l'ensemble en passant au suivant, dans l'ordre.
    - L'ensemble peut être une liste, une chaîne de caractères, mais également plein d'autres choses. Nous aurons un TP quasiment entier consacré à ça.
    - Attention au `:` et à l'indentation
```

```admonish travail 
1. Donnez le code permettant d'afficher la table de multiplication par 7 en allant de 1 à 10. Utilisez une boucle `while` et une chaîne formatée.
2. Donnez le code permettant d'afficher la même table mais en utilisant cette fois une boucle `for`.

Résultat attendu :
~~~
0 * 7 = 0
1 * 7 = 7
2 * 7 = 14
3 * 7 = 21
4 * 7 = 28
5 * 7 = 35
6 * 7 = 42
7 * 7 = 49
8 * 7 = 56
9 * 7 = 63
10 * 7 = 70
~~~
```

```admonish help title='Aide'
Vous pouvez utiliser la fonction `range`, qui permet de renvoyer un **générateur** (sorte de liste dynamique) de séquence de nombres dans un intervalle. Ex: `range(1, 6)` renverra tour à tour les nombres de 1 à 5 (le dernier nombre de l'intervalle est exclu).
```

## Bonus - Le jeu du plus ou moins

Nous allons maintenant réaliser un petit jeu où la personne qui y joue doit deviner un nombre entre 1 et 100 choisi aléatoirement par l'ordinateur. L'ordinateur renvoie l'information "Plus" quand le nombre qu'il a choisi est plus grand que celui saisi, et "Moins" dans l'autre cas.

Pour que l'ordinateur vous fournisse un nombre aléatoire, vous pouvez utiliser le code suivant :
```python
import random # On importe le module random

random.seed() # On initialise la génération de nombres aléatoires
nombre_aleatoire = random.randint(1,100) # On récupère le nombre
```
```admonish note
Les portions de code qui se trouvent après des `#` en python sont considérées comme des **commentaires**, c'est à dire du texte que la personne ayant écrit le code a mis pour aider les personnes lisant le code. Ce qui se trouve en commentaire est totalement ignoré par Python.
```

```admonish travail
1. Créez un nouveau script appelé `tp01-plus-ou-moins.py`
1. Écrivez le code permettant à l'ordinateur de générer le nombre aléatoire. Affichez-le pour vérifier que cela fonctionne.
1. Écrivez le code permettant de demander à la personne qui joue d'entrer un nombre. N'oubliez pas les conversions
1. Écrivez le code permettant de comparer les deux nombres et afficher "Plus", "Moins" ou "Gagné !" selon les cas. Mettez le code de votre programme à ce stade dans le compte rendu.
1. Il faut maintenant boucler pour laisser plusieurs chances à l'utilisateur sans devoir relancer le programme à chaque fois. Écrivez une première version de votre boucle avec `while`. 
    La boucle devra demander de saisir un nombre, le comparer, et afficher le texte. Si l'utilisateur a trouvé le bon nombre, le programme doit afficher "Gagné !" et s'arrêter tout seul. En revanche, le nombre aléatoire ne devra être choisi qu'une seule fois, faites donc attention.

    Mettez le code de votre programme à ce stade dans le compte rendu.
1. Ecrivez une nouvelle version de votre boucle, en utilisant `for` cette fois. L'utilisateur aura maximum 10 essais, et s'il dépasse le jeu affichera "Perdu !" avant de s'arrêter. 
    Mettez le code final de votre programme dans le compte rendu.
```