Alexis Fourmaux afecc46ce3 Ajoute TP1 Python CIEL2

2025-08-07 13:08:35 +02:00

37 KiB

Raw Blame History

Découverte de Python

Découverte de l'interpréteur Python

Nous allons commencer par découvrir l'interpréteur python que nous allons utiliser de manière interactive.

Pour cela, commençons par lancer le logiciel Thonny. Cliquez sur le menu en bas à gauche dans Windows, puis recherchez Thonny.

Thonny est un logiciel qui va nous permettre d'utiliser très simplement Python. Il est libre, c'est à dire que vous pouvez l'utiliser librement et gratuitement, y compris chez vous. N'hésitez donc pas à l'installer sur votre propre machine pour vous entraîner à écrire du Python chez vous, ou préparer vos exercices. 

Vous pourrez le trouver sur ce site : https://thonny.org/

Nous allons commencer par utiliser Python en mode interactif. Cela nous permettra de saisir des instructions, que Python va exécuter. Regardez la fenêtre de Thonny, et trouvez la section qui s'appelle Console. Vous y verrez la mention Python 3.13.5 (/usr/bin/python) (le texte exact peut être différent), et sur la ligne suivante trois chevrons (le symbole >).

Le mode interactif fonctionne de la manière suivante :

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.
Vous pouvez taper une commande (nous verrons lesquelles juste après) et les valider avec la touche Entrée
Il évalue l'expression saisie : il l'analyse et l'exécute
Il affiche enfin le résultat.

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.

Python est une calculatrice

Vous pouvez utiliser l'interpréteur de python comme une calculatrice. C'est évidemment bien plus puissant, mais nous allons commencer par découvrir ses capacités de calcul.

Une calculatrice simple

1. Tout d'abord, essayez de taper l'expression `2 + 3` dans l'invite de commande et appuyez sur <kbd>Entrée</kbd>. Que se passe-t-il ?

2. Dans l'invite de commande, essayez d'effectuer les opérations suivantes. Notez les expressions utilisées et leur résultat.
    - 4 plus 7
    - 3 moins 12
    - 6 fois 7
    - 9 divisé par 2
    - 4,2 plus 1,5
    - 5 modulo 2
    - le quotient de la division euclidienne de 5 par 2
    - 2 puissance 10
    - 37 fois la somme de 13 et 24

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

- 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.
- Les symboles `+`, `-`, `*`, `/`... sont appelés **opérateurs** en Python
- L'opérateur modulo `%` est souvent utilisé pour savoir si un nombre est multiple d'un autre. Il vaut mieux s'en souvenir. Il permet de calculer le reste de la division euclidienne de deux nombres. Par exemple si on divise 5 par 2 on obtient 2 et il reste 1. 1 est donc notre reste et `5 % 2` nous donnera 1.
- Si l'on veut effectuer la division euclidiuenne d'un nombre par un autre, on peut le faire avec l'opérateur `//` qui est différent de `/`. Par exemple `5//2` nous donnera 2, alors que `5/2` nous donnera `2.5`
- Les nombres décimaux ont parfois des valeurs approximatives. Il faut être vigilant lorsqu'on les utilise dans des calculs.

Mais aussi une calculatrice scientifique

Après avoir utilisé les opérateurs mathématiques simples, nous allons voir que Python permet également de faire des opérations plus complexes, comme celles que l'on retrouve sur une calculatrice scientifique. Elles ne se retrouvent pas directement sous forme d'opérateurs mais sous forme de fonctions.

Nous verrons dans le prochain TP ce que sont les fonctions plus en détail. Pour le moment, l'important est de retenir qu'une fonction est un ensemble d'instructions que l'on a regroupées sous un nom pour les exécuter ensemble sans avoir à les taper à chaque fois.

Il existe des fonctions par défaut dans Python (voir Built-in functions) mais celles qui nous intéressent ici sont situées dasn un module appelé math. Nous verrons plus tard ce que sont les modules. Ici nous allons nous contenter de l'importer.

Dans l'invite de commande, écrivez :

>>> import math

Nous pouvous ensuite appeler tout un tas de nouvelles fonctions liées aux mathématiques. Par exemple, si nous voulons la racine carré de 2 ('racine carrée' c'est 'square root' en anglais), nous pouvons écrire :

>>> math.sqrt(2)
1.4142135623730951

Explication :

On appelle la fonction sqrt en la précédant du nom du module math, séparés par un point
Les parenthèses servent à donner les arguments à la fonction, ici 2 car nous voulons calculer la racine carrée de 2.
Python nous donne ensuite le résultat : 1.4142135623730951

En utilisant la [documentation du module `math`](https://docs.python.org/3/library/math.html)

1. Donnez les expressions qui permettront de calculer :
    - la racine carrée de 81
    - la valeur absolue de -12 (celle-ci n'est pas dans `math` mais existe par défaut)
    - la valeur de $\pi$
    - le cosinus de $\pi$
    - la partie entière de 3.56
2. Expliquez la différence entre les fonctions `math.floor()` et `math.ceil()`

Les variables et les types

Les variables

Dans la suite nous allons apprendre à utiliser des variables. 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.

- 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

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.

Nous allons donc affecter et utiliser nos premières variables. 

1. Pour cela, dans l'interpréteur, écrivez `mon_age = 19` puis appuyez sur <kbd>Entrée</kbd>. Que se passe-t-il ?
2. Essayez d'entrer un nom de variable **illégal** (c'est à dire qu'il n'est pas autorisé dans le langage et qu'il causera une erreur). Notez-le. Que se passe-t-il ?
3. Essayez d'écrire `3 = x`. que se passe-t-il ?
4. Ecrivez le code suivant. Expliquez ce qu'il fait
    ~~~python
    >>> mon_age = 19
    >>> mon_age = mon_age * 2
    >>> mon_age
    ~~~
5. 
    a. Le code suivant calcule le prix TTC d'un article à partir de sont prix hors taxes (45€), en lui ajoutant la TVA. 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
    ~~~

    b. Modifiez la valeur de `tva` pour qu'elle prenne la valeur de 20%. Quelle valeur a `prix_ttc` ? Pourquoi ?
    
    c. 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.
    
    d. Donnez l’expression qui permet d’évaluer le prix à payer par le client lorsqu’on lui accorde une réduction de 5% sur le prix **hors taxes**.

    e. Donnez l'expression qui permet d'augmenter la TVA de 1%, quel que soit sont taux actuel.

Les types et la fonction `type`

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.

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

1. Affecter le valeur `21` à une variable `mon_age`. Donner le type de cette variable en utilisant la fonction `type`.
2. Affecter la valeur `3.14` à une variable `pi`. Donner le type de cette variable.
3. Affecter la valeur `True` (ou `False`) à une variable `j_aime_les_spaghettis`. Donnez son type.
4. Affecter la valeur `"<votre prénom>"` à une variable `prenom` et donnez son type. 
5. Ecrivez `age = '85'` (Attention aux guillemets) dans l'interpréteur. Donnez le type de `age`.
6. Ecrivez maintenant `age * 2`. Que se passe-t-il ? comment se comporte l'opérateur `*` lorsqu'il est utilisé avec des chaînes de caractères ? 
7. Donnez une expression permettant d'affecter le *texte* `'21'` à la variable `mon_age_str` en utilsant uniquement la variable `mon_age` (question 1) et la fonction `str`. Utilisez la fonction type pour vérifier. Qu'en déduisez-vous sur la fonction `str` ? 
8. De même donnez une expression permettant de d'affecter le *nombre* 85 à la variable `age_int` en utilisant uniquement `age` (question 6) et la fonction `int`. Qu'en déduisez-vous sur ce que fait la fonction `int` ?

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"'`

Un premier script

Pour la suite de ce TP nous allons arrêter d'utiliser l'interpréteur. L'interpréteur est très pratique pour tester des expressions ou des commandes. Mais il n'est pas pratique pour réexécuter ou modifier des programmes : il faut retaper toutes les commandes dans le bon ordre à chaque fois. Et en plus de ça, dès que l'on ferme l'interpréteur, tout ce qui a été écrit est perdu.

Nous allons utiliser des fichiers, désormais, pour écrire nos programmes. Pour cela on peut utiliser n'importe quel éditeur de texte.

Un **éditeur de texte** est différent d'un logiciel de **traitement de texte** comme peut l'être Microsoft Word ou Libre Office Writer. 

Il permet d'écrire du texte brut, sans aucune mise en forme, contrairement aux logiciels de traitement de texte qui contiennent des informations invisibles. Pour écrire du code, il faut uniquement du texte brut, c'est pour cela qu'on utilisera un éditeur de texte : par exemple, on peut utiliser Thonny comme dans ce TP, ou Notepad++ ou Visual Studio Code sous Windows, Geany, Gedit, nano, vim ou également VSCode sous Linux. Il en existe plein d'autres, avec plus ou moins de fonctionnalités avancées.

L'une d'entre elles, probablement la plus importante, c'est la **coloration syntaxique** : les mots du code sont colorés de différentes manières pour vous aider à identifier la structure et les mots clés, les variables etc...

Dans Thonny, nous allons utiliser l'autre encadré, celui qui s'appelle <sans nom> pour l'instant. Nous verrons dans un prochain TP comment travailler avec Visual Studio Code, un logiciel très performant et puissant pour écrire du code. Pour l'instant, gardons les choses simples et continuons avec Thonny. Vous pouvez continuer à utiliser Thonny chez vous également, il comporte le nécessaire pour utiliser Python.

Nous allons donc écrire un premier fichier comportant du code que vous pourrez exécuter autant de fois que nécessaire pour le tester, le modifier etc.

Un fichier contenant du code Python s'appelle un **script**. Les scripts python ont un nom se finissant par l'**extension** `.py`

Pour commencer nous allons enregistrer notre script dans un fichier. Cliquez sur le bouton Enregistrer comme sur l'image ci-dessous. Vous pouvez aussi appuyer sur CTRL+S.

Allez dans votre espace personnel, choisissez un nom, par exemple tp01-hello-world.py, et cliquez sur Sauvegarder. Voilà, nous sommes prêts à travailler.

La fonction print

1. Recopiez le code suivant, sauvegardez vos modifications, et cliquez sur le bouton en forme de rond vert avec un triangle à l'intérieur. Vous pouvez aussi appuyer sur <kbd>F5</kbd> pour exécuter le script. Que fait-il ?

    ~~~python
    print("Hello, world!")
    ~~~

    ![Exécuter votre script](image-2.png)

2. Créez, à la suite du programme existant, une variable `a` à laquelle vous affecterez la valeur 3. Donnez maintenant l'expression pour d'afficher la valeur de `a` à l'aide de `print`.
3. Copiez le programme suivant :
    ~~~python
    a = 3
    print(a)
    a = a + 3
    b = a - 2
    ~~~

    Que valent `a` et `b` à votre avis ? Vérifiez à l'aide de print en écrivant la ligne suivante : `print("a =", a, "et b =", b)`

4. Nous allons voir une autre manière d'écrire le print précédent, avec une **chaîne de caractères formatée**. Ajoutez la ligne : `print(f"a = {a} et b = {b}")`. Vérifiez que le résultat est bien identique au print précédent.

5. Donnez le code qui permettra, sur le même modèle, d'afficher la chaîne `Je m'appelle <prénom>` où prénom sera remplacé par votre prénom.

Pourquoi utiliser la fonction print, alors que dans l'interpréteur, écrire une chaîne de caractères ou le nom d'une variable permet déjà de l'afficher ?

L'interpréteur affiche les valeurs des variables pour vous aider à comprendre les étapes du programme, mais dans un script cela n'aura aucun effet. De plus l'interpréteur affiche les guillemets, et parfois d'autres informations que vous ne voulez pas forcément voir affichées. La fonction print permet d'afficher les informations dans la console, et de les formater (c'est à dire les organiser) comme cela vous arrange.

- 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
- Elle peut également prendre une chaîne de caractères **formatée** : 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.

La fonction input

Pouvoir afficher du texte est déjà très bien, mais pouvoir en saisir est également très utile, par exemple pour que la personne qui utilisera votre programme puisse entrer des données sans modifier votre programme. Nous allons maintenant voir comment faire ça.

La fonction input permet de demander une saisie de texte dans la console, et il suffit de taper Entrée pour valider votre saisie.
Cette fonction prend un argument optionnel : une chaîne de caractères à afficher dans la console, pour dire ce que vous demandez de saisir.
On peut affecter le résultat de input à une variable directement, comme dans l'exemple ci-dessous.

1. Testons dans un premier temps dans l'interpréteur. Utilisez la fonction `type` pour vérifier le type de la variable `nombre`. Quel est ce type ? 
    ~~~python
    >>> nombre = input("Saisissez un nombre : ")
    Saisissez un nombre : 42
    ~~~
2. Nous allons donc devoir convertir la variable `nombre` en un nombre entier. Pour cela, utilisons la fonction `int` sur `nombre`
   ~~~python
   >>> nombre = int(nombre)
   ~~~
3. Repassons sur un fichier de script : ouvrez un nouvel onglet, et sauvegardez le fichier sous le nom `tp01-input.py`. 

    Ensuite, écrivez un programme permettant de saisir un nombre et de l'afficher avec `print`. Votre programme devra afficher `Vous avez entré le nombre : ` suivi du nombre saisi. Aidez vous des questions précédentes. 
    
    Mettez le script dans votre compte rendu.

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

Structure conditionnelle

if ... elif ... else ...

Nous allons maintenant voir l'un des éléments les plus importants dans l'écriture d'un programme. Jusqu'à maintenant nos programmes exécutaient les instructions les unes à la suite des autres. Mais il est parfois pratique d'effectuer quelque chose dans un cas, et autre chose dans un autre cas. Pour cela, il nous faut un moyen de séparer les cas : les structures conditionnelles.

En python, pour écrire une structure conditionnelle, on va utiliser le mot clé if, qui signifie "si" en anglais. Par exemple, pour faire quelque chose si une variable vaut 1, on va écrire le programme suivant :

ma_variable = 1
if ma_variable == 1:
    print("Ma variable vaut 1")

Décorticons un peu ce programme.

Nous avons le mot clé if, qui veut dire "si"
puis ma_variable == 1, ce qui s'appelle un test.
- ma_variable est le nom de notre variable, celle que l'on veut tester
- == est un opérateur de comparaison pour tester l'égalité. Ici on veut vérifier que ma_variable vaut la valeur 1. Remarquez qu'il est différent du = simple, qui sert pour affecter une variable.
Nous avons : à la fin de la ligne. C'est pour marquer la fin de la condition, et indiquer qu'après cela, nous passerons aux instructions exécutées si la condition est vraie
Enfin, nous avons la ligne print("Ma variable vaut 1") qui vient afficher du texte. Mais remarquons une chose très importante : elle est décalée par rapport à la ligne précédente avec des espaces. C'est ce qu'on appelle l'indentation, et en python c'est indispensable. Si le code n'est pas correctement identé, c'est une erreur et votre programme ne marchera pas. Ici on indente tout ce qui sera exécuté si la condition est réalisée. Notez aussi que cela permet de rendre le code beaucoup plus facile à lire, car il s'organise en blocs plus ou moins décalés, ce qui vous permet de savoir en un coup d'oeil ce qui est exécuté ou non.

Dans un nouveau fichier que vous appellerez `tp-01-conditions.py`

1. 
    a. Copiez et exécutez le code de l'exemple ci-dessus. Vérifiez que la phrase `Ma variable vaut 1` s'affiche correctement.
    b. Au début du programme, nous avons déclaré `ma_variable`. Remplacez cette déclaration pour pouvoir saisir un nombre de manière interactive, avec `input`. Mettez la ligne modifiée dans le compte rendu.
    c. Réexécutez le programme en testant différentes valeurs (dont `1` pour vérifier qu'il marche toujours comme en a.). Qu'affiche le programme et pourquoi ?

2. Maintenant, nous allons essayer d'écrire quelque chose lorsque la condition est respectée mais autre chose quand elle ne l'est pas. Pour cela, nous allons utiliser le mot clé `else` qui signifie "sinon". En faisant ça on pourra avoir un programme qui fera "**Si** ma condition est vraie *alors* je fais ça, **sinon** je fais ça". 

    Écrivez le programme suivant, et modifiez la valeur d'âge en réexécutant le programme pour voir dans quel cas s'affiche quel texte. Que signifie le symbole `>` à votre avis ?
    ~~~python
    age = 17
    if age > 18:
        print("Vous êtes majeur.e")
    else:
        print("Vous êtes mineur.e")
    ~~~

3. Imaginons maintenant que nous ayons 3 cas possibles : majeur, mineur et retraité. 
    
    Nous pouvons enchaîner plusieurs conditions grâce au mot clé `elif` (contraction de de "else if", c'est à dire "sinon, si..."). `elif` s'utilise exactement comme `if` mais doit forcément se trouver après une première condition `if`. 
    
    Modifiez le code précédent en rajoutant le cas des retraités, pour afficher une phrase `Vous êtes en retraite` lorsque la variable `age` est supérieure à 60 (Allez, on y croit !). Mettez ce code dans votre rapport de TP.

4. **Bonus :** Imaginons maintenant que l'on ait une autre variable, `annees_de_cotisation`. À partir de 60 ans, si on a 40 années de cotisation, on peut prendre la retraite. Sinon, il faut atteindre 40 années de cotisation. 

    Nous allons donc devoir rajouter une condition supplémentaire pour les personnes ayant plus de 60 ans, en fonction de la variable `annee_cotisation`. Rajoutez cette variable, et rajoutez une **condition imbriquée** dans la branche qui concerne les plus de 60 ans.

En résumé, 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

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
~~~

Les opérateurs de comparaison

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.

Reprenez l'interpréteur python, déclarez les variables `a = 1`, `b = 3` et `c = 4` et testez les expressions suivantes. Que retournent-elles ? 

1. `b > a`
1. `c <= a`
1. `a != b`
1. `b == '3'` (attention aux guillemets simples). Qu'en déduisez-vous ?
1. `a < b < c`

Ces opérateurs de comparaison retournent des booléens (le type bool que nous avons vu plus haut). Nous pouvons même stocker le résultat d'une comparaison dans une variable (qui sera de type bool) pour la réutiliser plus tard.

De même, si vous écrivez if True: ... la condition sera toujours vraie, donc toujours réalisée. L'inverse également.

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'

Les opérateurs booléens

En utilisant l'interpréteur, déclarez les variables `a = 3`, `b = 1`, `c = 4` puis donnez le résultat des expressions suivantes:
1. `a == 3 and (a + b) == c`
1. `a < 0 or b > 1`
1. `not a != b`
1. `bool(c)`
1. `bool(0)`
1. Que déduisez-vous des deux questions précédentes ?

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.

Les boucles

Créez un nouveau script que vous appellerez `tp01-boucles.py`
1. À l'aide de la fonction print et d'une chaîne formatée, donnez un code vous permettant d'afficher la table de multiplication par 7, en allant de 0 à 5. 
    
    **Aide**: La chaîne de caractères pourra avoir la forme suivante : `f"0 x 7 = {0 * 7}"`

1. C'était pénible, n'est-ce pas <span>&#128513;</span> ? Imaginez si j'avais poussé en vous demandant d'aller jusqu'à 1000... On ne vas pas pouvoir continuer comme ça, bien évidemment. Les répétitions de code, en plus d'être pénibles sont une source d'erreurs infinie, et à chaque changement il faut mettre toutes les copies à jour. Pour cela nous allons donc utiliser des **boucles**, parfois appelées **structures répétitives**.

    a. Nous allons utiliser le mot-clé `while` ("tant que" en anglais). `while` fonctionne un peu comme if : il prend une condition, et tant que cette condition est vraie, il continue de répéter les instructions qui sont dans son bloc. Commençons par écrire le code suivant. Exécutez-le et expliquez ce qu'il fait, ligne par ligne.
    ~~~python
    i = 0
    while i <= 5:
       print(f"{i} x 7 = {i * 7}")
       i = i + 1
    ~~~
    b. Modifiez le pour qu'il affiche la même table de multiplication, mais cette fois de 0 à 100. Donnez la ligne modifiée dans votre compte rendu.

    c. Modifiez le pour qu'il commence à partir de 50 jusqu'à 100. Donnez la ligne modifiée dans le compte rendu

    d. Modifiez le pour qu'il n'affiche qu'une ligne sur deux. Donnez la ligne modifiée dans le compte rendu

2. La boucle `while` permet déjà bcp de choses, mais il en existe une autre encore plus pratique pour ce cas : la boucle `for`. Modifiez le code précédent de la manière suivante, exécutez-le et vérifiez que le résultat soit identique à celui de la question 1.a. :
    ~~~python
    for i in range(0, 6):
        print(f"{i} x 7 = {i * 7}")
    ~~~
    
    Quels sont les changements que vous remarquez par rapport à la boucle `while` ? 
    
    **Aide**: `range` renvoie une sorte de liste des nombres entiers situés dans l'intervalle de nombres qu'on lui passe en paramètre. Ici il renvoie les nombres de 0 à 5 (6 est exclu).

- 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

Mises en pratique

L'heure de faire des vrais programmes est venue. N'hésitez pas à tester vos syntaxes dans l'interpréteur de commande avant de les mettre dans votre script. Procédez par étapes, prenez le temps de réfléchir avec un papier et un crayon.

Ces exercices sont moins guidés que le reste du TP. N'hésitez donc pas à vous entraider, ou demander de l'aide si vous êtes coincés.

Les années bissextiles

Nous allons commencer par é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 mettre en pratique 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.

1. Commencez par dessiner un schéma 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 saisir une année, et de la stocker dans une variable. N'oubliez pas de convertir en nombre 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. Ecrivez 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

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 :

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

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.

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.

37 KiB Raw Blame History Unescape Escape