ciel-b1/src/cours/CIEL1/01-bases-python/tp/01_decouverte.md

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 :

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 (nous verrons lesquelles juste après) et les valider avec la touche Entrée
3. Il évalue l'expression saisie : il l'analyse et l'exécute
4. 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
    - 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 apostrphe 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

• print
• chaines de caractères + formatage

Structure conditionnelle

• if
• if elif else
• opérateurs de comparaison
• booléens
• opérateurs logiques and, or, not

Les boucles

• while
• for
• break + continue