From 1647035df29c5efc9125672d2edf5bed55ce699d Mon Sep 17 00:00:00 2001 From: Florian Mathieu Date: Tue, 7 Jul 2026 02:19:27 +0200 Subject: [PATCH] =?UTF-8?q?Programmation=20:=20chapitres=205=20(f-strings)?= =?UTF-8?q?=20et=206=20(typage)=20=E2=80=94=20corrigent=20les=20liens=20mo?= =?UTF-8?q?rts=20du=20site?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- programmation/chapitre_5/README.md | 180 ++++++++++++++++++++ programmation/chapitre_6/README.md | 256 +++++++++++++++++++++++++++++ 2 files changed, 436 insertions(+) create mode 100644 programmation/chapitre_5/README.md create mode 100644 programmation/chapitre_6/README.md diff --git a/programmation/chapitre_5/README.md b/programmation/chapitre_5/README.md new file mode 100644 index 0000000..444ea55 --- /dev/null +++ b/programmation/chapitre_5/README.md @@ -0,0 +1,180 @@ +# Les f-strings + +L'activité consiste en un TD comprenant un __cours dirigé__ et des __exercices__ relatifs aux __f-strings__ en Python. + +## Pré-requis + +Avoir effectué l'activité sur les [fonctions](../chapitre_4/) + +## Consignes + +1. Télécharger le fichier [TD.ipynb](./TD.ipynb), +2. Se rendre sur [Basthon](https://notebook.basthon.fr/), +3. Ouvrir le fichier TD.ipynb téléchargé, +4. Suivre le déroulé du TD, les réponses sont à mettre directement dans votre fichier, +5. À la fin de la séance, n'oubliez pas de sauvegarder votre fichier sur votre clé USB ou espace personnel. + +--------- + +## Mémo — Les f-strings + +### Pourquoi les f-strings ? + +Jusqu'ici, pour afficher une variable dans une phrase, on utilisait la **concaténation** ou la **virgule dans `print()`** : + +```python +prenom = "Alice" +age = 17 + +# Méthode 1 : concaténation (fastidieuse) +print("Bonjour " + prenom + ", tu as " + str(age) + " ans.") + +# Méthode 2 : virgule dans print (peu flexible) +print("Bonjour", prenom, ", tu as", age, "ans.") +``` + +Les **f-strings** (introduites en Python 3.6) permettent d'écrire cela de façon bien plus lisible : + +```python +print(f"Bonjour {prenom}, tu as {age} ans.") +# → Bonjour Alice, tu as 17 ans. +``` + +--- + +### Syntaxe de base + +Une f-string est une chaîne de caractères précédée de la lettre `f`. Les **expressions entre accolades `{}`** sont évaluées et insérées dans la chaîne. + +```python +nom = "Bob" +score = 142 + +message = f"Le joueur {nom} a obtenu {score} points." +print(message) +# → Le joueur Bob a obtenu 142 points. +``` + +On peut mettre **n'importe quelle expression** entre les accolades : + +```python +a = 5 +b = 3 +print(f"{a} + {b} = {a + b}") # → 5 + 3 = 8 +print(f"Le double de {a} : {a * 2}") # → Le double de 5 : 10 +print(f"Est-ce que {a} > {b} ? {a > b}") # → Est-ce que 5 > 3 ? True +``` + +--- + +### Appel de fonctions dans une f-string + +```python +prenom = "alice" +print(f"Bonjour {prenom.upper()} !") # → Bonjour ALICE ! +print(f"Longueur : {len(prenom)}") # → Longueur : 5 +``` + +--- + +### Formatage des nombres + +C'est l'un des points les plus utiles des f-strings. On ajoute un **format** après un `:` dans les accolades. + +#### Nombres décimaux — précision + +```python +pi = 3.14159265 + +print(f"{pi}") # → 3.14159265 (pas de format) +print(f"{pi:.2f}") # → 3.14 (2 chiffres après la virgule) +print(f"{pi:.4f}") # → 3.1416 (4 chiffres après la virgule) +print(f"{pi:.0f}") # → 3 (0 chiffres, arrondi) +``` + +#### Largeur et alignement + +```python +nom = "Alice" + +print(f"|{nom:<10}|") # → |Alice | (aligné à gauche, largeur 10) +print(f"|{nom:>10}|") # → | Alice| (aligné à droite) +print(f"|{nom:^10}|") # → | Alice | (centré) +``` + +#### Nombres entiers — remplissage avec des zéros + +```python +numero = 7 +print(f"Joueur n°{numero:03d}") # → Joueur n°007 +``` + +#### Combinaison : largeur ET précision + +```python +temperature = 18.5 +print(f"Température : {temperature:6.1f} °C") # → Température : 18.5 °C +``` + +--- + +### Tableau récapitulatif des formats + +| Format | Signification | Exemple | Résultat | +|--------|--------------|---------|----------| +| `:.2f` | 2 décimales | `f"{3.14159:.2f}"` | `3.14` | +| `:d` | Entier | `f"{42:d}"` | `42` | +| `:05d` | Entier, 5 chiffres, zéros | `f"{7:05d}"` | `00007` | +| `:<10` | Aligné gauche, 10 chars | `f"{'a':<10}"` | `a ` | +| `:>10` | Aligné droite, 10 chars | `f"{'a':>10}"` | ` a` | +| `:^10` | Centré, 10 chars | `f"{'a':^10}"` | ` a ` | + +--- + +### Exemple complet : tableau de résultats + +```python +resultats = [ + ("Alice", 17.5, 1), + ("Bob", 14.0, 2), + ("Carla", 15.75, 3), +] + +print(f"{'Nom':<10} {'Note':>6} {'Rang':>5}") +print("-" * 25) +for nom, note, rang in resultats: + print(f"{nom:<10} {note:>6.2f} {rang:>5}") +``` + +Affiche : +``` +Nom Note Rang +------------------------- +Alice 17.50 1 +Bob 14.00 2 +Carla 15.75 3 +``` + +--- + +### Erreurs fréquentes + +```python +# ERREUR : oublier le f devant la chaîne +prenom = "Alice" +print("{prenom}") # → {prenom} (littéral, pas de substitution !) +print(f"{prenom}") # → Alice (correct) + +# ERREUR : accolades sans contenu valide +print(f"{}") # SyntaxError + +# ERREUR : mettre des guillemets identiques à l'intérieur +# print(f"{"Alice"}") # SyntaxError — utiliser des guillemets différents +print(f"{'Alice'}") # → Alice (guillemets simples à l'intérieur) +``` + +--------- + +## Pour aller plus loin + +Une fois le TD __fini__ et __validé__, vous pouvez effectuer l'[activité suivante](../chapitre_6/) diff --git a/programmation/chapitre_6/README.md b/programmation/chapitre_6/README.md new file mode 100644 index 0000000..e0598f7 --- /dev/null +++ b/programmation/chapitre_6/README.md @@ -0,0 +1,256 @@ +# Le typage + +L'activité consiste en un TD comprenant un __cours dirigé__ et des __exercices__ relatifs au __typage__ en Python. + +## Pré-requis + +Avoir effectué l'activité sur les [f-strings](../chapitre_5/) et les [fonctions](../chapitre_4/) + +## Consignes + +1. Télécharger le fichier [TD.ipynb](./TD.ipynb), +2. Se rendre sur [Basthon](https://notebook.basthon.fr/), +3. Ouvrir le fichier TD.ipynb téléchargé, +4. Suivre le déroulé du TD, les réponses sont à mettre directement dans votre fichier, +5. À la fin de la séance, n'oubliez pas de sauvegarder votre fichier sur votre clé USB ou espace personnel. + +--------- + +## Mémo — Le typage + +### Rappel : les types de base en Python + +Toute valeur en Python possède un **type**. Les types de base vus en [chapitre 1](../chapitre_1/) sont : + +| Type | Description | Exemple | +|------|-------------|---------| +| `int` | Entier relatif | `42`, `-7`, `0` | +| `float` | Nombre décimal | `3.14`, `-0.5` | +| `str` | Chaîne de caractères | `"Bonjour"`, `'NSI'` | +| `bool` | Booléen | `True`, `False` | + +```python +type(42) # → +type(3.14) # → +type("Bonjour") # → +type(True) # → +``` + +--- + +### Typage dynamique + +Python est un langage à **typage dynamique** : le type d'une variable n'est pas déclaré à l'avance, il est déterminé **au moment de l'exécution**, selon la valeur qu'on lui affecte. + +```python +x = 42 # x est un int +print(type(x)) # → + +x = "Bonjour" # x devient un str (la même variable change de type !) +print(type(x)) # → +``` + +C'est différent des langages à **typage statique** comme C ou Java, où le type est déclaré une fois pour toutes : + +```c +// En C : le type est fixé dès la déclaration +int x = 42; +x = "Bonjour"; // ERREUR de compilation +``` + +| | Typage dynamique | Typage statique | +|--|--|--| +| Exemples | Python, JavaScript | C, Java, Rust | +| Type déclaré ? | Non | Oui | +| Erreurs de type | À l'exécution | À la compilation | +| Flexibilité | Élevée | Faible | + +--- + +### Vérifier le type : `type()` et `isinstance()` + +#### `type()` + +Retourne le type exact d'une valeur. + +```python +x = 42 +print(type(x)) # → +print(type(x) == int) # → True +print(type(x) == str) # → False +``` + +#### `isinstance()` + +Vérifie si une valeur est d'un type donné. **À préférer** dans les programmes car plus robuste. + +```python +x = 42 +print(isinstance(x, int)) # → True +print(isinstance(x, float)) # → False +print(isinstance(x, str)) # → False + +# isinstance accepte aussi un tuple de types +print(isinstance(x, (int, float))) # → True (int ou float) +``` + +Cas utile : valider une saisie utilisateur. + +```python +def verifier_age(valeur): + if not isinstance(valeur, int): + return "Erreur : l'âge doit être un entier." + if valeur < 0 or valeur > 130: + return "Erreur : âge invalide." + return f"Âge valide : {valeur} ans." + +print(verifier_age(17)) # → Âge valide : 17 ans. +print(verifier_age("dix-sept")) # → Erreur : l'âge doit être un entier. +``` + +--- + +### Les annotations de type + +Depuis Python 3.5, on peut **annoter** les types des paramètres et du retour d'une fonction. Ces annotations sont **facultatives** : Python ne les vérifie pas à l'exécution, mais elles servent de **documentation** et aident les outils de développement. + +#### Syntaxe + +```python +def nom_fonction(parametre: type_attendu) -> type_retour: + ... +``` + +#### Exemples + +```python +def aire_rectangle(longueur: float, largeur: float) -> float: + return longueur * largeur + +def est_pair(n: int) -> bool: + return n % 2 == 0 + +def saluer(prenom: str) -> str: + return f"Bonjour {prenom} !" +``` + +On peut aussi annoter des variables : + +```python +age: int = 17 +nom: str = "Alice" +scores: list = [10, 15, 12] +``` + +#### Pourquoi annoter ? + +```python +# Sans annotation : que doit-on passer ? Qu'est-ce qui est retourné ? +def transformer(x): + return x * 2 + +# Avec annotation : c'est immédiatement clair +def transformer(x: int) -> int: + return x * 2 +``` + +Les annotations permettent de : +- **Documenter** le code (qui lit la fonction sait quoi passer) +- **Détecter des erreurs** avec des outils comme `mypy` +- **Faciliter la maintenance** du code sur le long terme + +--- + +### Erreurs de type courantes + +#### Opération sur des types incompatibles + +```python +age = input("Votre âge : ") # input() retourne TOUJOURS un str +print(age + 1) # TypeError : on ne peut pas additionner str et int +``` + +Solution : convertir avec `int()`. + +```python +age = int(input("Votre âge : ")) +print(age + 1) # Correct +``` + +#### Confusion entre `str` et `int` + +```python +a = "5" +b = "3" +print(a + b) # → "53" (concaténation de chaînes !) +print(int(a) + int(b)) # → 8 (addition d'entiers) +``` + +--- + +### Conversion de types (rappel) + +| Conversion | Fonction | Exemple | +|---|---|---| +| Vers entier | `int()` | `int("42")` → `42` | +| Vers flottant | `float()` | `float("3.14")` → `3.14` | +| Vers chaîne | `str()` | `str(42)` → `"42"` | +| Vers booléen | `bool()` | `bool(0)` → `False` | + +Valeurs considérées comme `False` par `bool()` : + +```python +bool(0) # False +bool(0.0) # False +bool("") # False (chaîne vide) +bool([]) # False (liste vide) +bool(None) # False +# Tout le reste est True +``` + +--- + +### Exemple complet : fonction bien typée + +```python +def calculer_moyenne(notes: list) -> float: + """ + Calcule la moyenne d'une liste de notes. + + Paramètres : + notes (list) : liste de nombres (int ou float) + + Retourne : + float : la moyenne, ou 0.0 si la liste est vide + """ + if not isinstance(notes, list): + raise TypeError("notes doit être une liste") + if len(notes) == 0: + return 0.0 + return sum(notes) / len(notes) + + +# Utilisation +mes_notes = [12, 15, 9, 17, 14] +print(f"Moyenne : {calculer_moyenne(mes_notes):.2f}") # → Moyenne : 13.40 +``` + +--- + +### Résumé + +| Notion | Ce qu'il faut retenir | +|---|---| +| Typage dynamique | Le type est déterminé à l'exécution, pas à la déclaration | +| `type(x)` | Retourne le type exact de `x` | +| `isinstance(x, T)` | Vérifie si `x` est du type `T` (à préférer à `type()`) | +| Annotations | Facultatives, servent de documentation, pas vérifiées par Python | +| `input()` | Retourne **toujours** un `str` — penser à convertir | + +--------- + +## Pour aller plus loin + +Félicitations ! Vous avez terminé le module de programmation Python. + +Pour approfondir le typage en Python : [PEP 484 — Type Hints](https://peps.python.org/pep-0484/)