1777 lines
57 KiB
Markdown
1777 lines
57 KiB
Markdown
# Chapitre 09 — Modules et bibliothèque standard
|
|
|
|
> **Durée estimée** : 4 à 5 heures (cours + exercices + mini-projet)
|
|
>
|
|
> **Prérequis** : [Chapitre 08 — Erreurs et débogage](08-erreurs-et-debogage.md) (et en particulier les fonctions du [chapitre 05](05-fonctions.md)).
|
|
>
|
|
> **Objectifs** — À la fin de ce chapitre, tu sauras :
|
|
> - importer un module de plusieurs façons (`import`, `from … import`, `as`) et choisir la bonne ;
|
|
> - découper ton propre programme en plusieurs fichiers (modules) et en dossiers (paquets) ;
|
|
> - comprendre et utiliser `if __name__ == "__main__":` ;
|
|
> - utiliser les modules incontournables de la bibliothèque standard : `random`, `math`, `datetime`, `os`, `sys`, `collections` ;
|
|
> - explorer un module inconnu avec `dir()`, `help()` et la documentation officielle ;
|
|
> - éviter les pièges classiques (fichier nommé `random.py`, import circulaire…).
|
|
|
|
---
|
|
|
|
## Cours
|
|
|
|
### 1. Pourquoi des modules ?
|
|
|
|
Jusqu'ici, tous tes programmes tenaient dans **un seul fichier**. C'est parfait pour 50 lignes. Mais un vrai programme en fait vite 500, 5 000 ou 50 000. Tout mettre dans un seul fichier, ce serait comme ranger toutes tes affaires dans un unique tiroir géant : on ne retrouve plus rien.
|
|
|
|
Un **module**, c'est simplement **un fichier `.py`** qui contient des fonctions, des variables (et plus tard des classes) qu'on peut **réutiliser ailleurs**. Les modules servent à :
|
|
|
|
- **organiser** : un fichier par thème (`calculs.py`, `affichage.py`, `sauvegarde.py`) ;
|
|
- **réutiliser** : écrire une fonction une fois, l'utiliser dans dix programmes ;
|
|
- **profiter du travail des autres** : Python est livré avec des centaines de modules prêts à l'emploi.
|
|
|
|
Cette collection de modules livrés avec Python s'appelle la **bibliothèque standard**. On dit souvent que Python est livré « piles incluses » (*batteries included*) : pas besoin d'installer quoi que ce soit pour tirer des nombres au hasard, manipuler des dates, lire du JSON ou calculer une racine carrée.
|
|
|
|
> 💡 **Analogie** : la bibliothèque standard, c'est une boîte à outils fournie avec ta maison. Un module, c'est un tiroir de cette boîte (le tiroir « dates », le tiroir « hasard »…). `import`, c'est ouvrir le tiroir pour y prendre ce dont tu as besoin.
|
|
|
|
Tu en as déjà utilisé sans le savoir : `json` et `csv` au [chapitre 07](07-fichiers-csv-json.md), `pathlib` aussi. Ce chapitre t'explique enfin ce qui se passe vraiment derrière `import`.
|
|
|
|
### 2. Importer un module
|
|
|
|
#### `import module`
|
|
|
|
La forme la plus simple et la plus courante :
|
|
|
|
```python
|
|
import math
|
|
|
|
print(math.sqrt(16))
|
|
print(math.pi)
|
|
```
|
|
|
|
```
|
|
4.0
|
|
3.141592653589793
|
|
```
|
|
|
|
`import math` charge le module et crée une variable `math` qui le représente. Pour utiliser son contenu, on écrit **`module.nom`** (notation pointée). L'avantage est énorme : en lisant `math.sqrt`, tu sais immédiatement d'où vient `sqrt`.
|
|
|
|
#### `from module import nom`
|
|
|
|
Si tu utilises souvent les mêmes fonctions, tu peux les importer directement :
|
|
|
|
```python
|
|
from math import sqrt, pi
|
|
|
|
print(sqrt(16))
|
|
print(pi)
|
|
```
|
|
|
|
```
|
|
4.0
|
|
3.141592653589793
|
|
```
|
|
|
|
Plus court à écrire, mais on perd l'information « ça vient de `math` ». Et attention : seuls les noms listés sont importés. `math` lui-même n'existe pas dans ce programme.
|
|
|
|
#### Renommer avec `as`
|
|
|
|
Tu peux donner un **alias** à un module ou à une fonction :
|
|
|
|
```python
|
|
import statistics as stats
|
|
from datetime import datetime as dt
|
|
|
|
print(stats.mean([12, 15, 9, 18]))
|
|
print(type(dt.now()).__name__)
|
|
```
|
|
|
|
```
|
|
13.5
|
|
datetime
|
|
```
|
|
|
|
Certains alias sont des conventions universelles que tu rencontreras au [chapitre 14](14-specialisations.md) : `import pandas as pd`, `import numpy as np`.
|
|
|
|
#### `from module import *` : à éviter
|
|
|
|
```python
|
|
from math import *
|
|
from statistics import *
|
|
```
|
|
|
|
L'étoile importe **tout** le contenu du module. Problème : tu ne sais plus d'où vient chaque nom, et si deux modules ont une fonction du même nom, la seconde écrase la première **en silence**. Réserve cette forme à l'interpréteur interactif pour tester rapidement.
|
|
|
|
#### Quelle forme choisir ?
|
|
|
|
| Forme | Quand l'utiliser |
|
|
|---|---|
|
|
| `import math` | Par défaut. Clair et sans conflit. |
|
|
| `from math import sqrt` | Pour 1 à 3 noms utilisés très souvent. |
|
|
| `import statistics as stats` | Pour un nom de module long, ou une convention connue. |
|
|
| `from math import *` | Jamais dans un vrai programme. |
|
|
|
|
**Convention** (PEP 8, voir [chapitre 13](13-tests-pytest-bonnes-pratiques.md)) : les `import` se placent **tout en haut du fichier**, un module par ligne, dans cet ordre : bibliothèque standard, puis bibliothèques installées, puis tes propres modules, séparés par une ligne vide.
|
|
|
|
```python
|
|
import json
|
|
import random
|
|
from pathlib import Path
|
|
|
|
from mes_outils import nettoyer_texte
|
|
```
|
|
|
|
> ⚠️ Cet extrait suppose qu'un fichier `mes_outils.py` existe : il illustre seulement l'ordre des imports.
|
|
|
|
### 3. Explorer un module : `dir()`, `help()` et la documentation
|
|
|
|
Comment savoir ce que contient un module ? Trois outils :
|
|
|
|
**`dir(module)`** liste tout ce qu'il contient :
|
|
|
|
```python
|
|
import math
|
|
|
|
print(dir(math)[:12])
|
|
```
|
|
|
|
```
|
|
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh']
|
|
```
|
|
|
|
Les noms entourés de doubles tirets bas (`__doc__`…) sont des éléments techniques ; ignore-les pour l'instant.
|
|
|
|
**`help(fonction)`** affiche la documentation (la *docstring*, vue au [chapitre 05](05-fonctions.md)). Essaie dans l'interpréteur interactif (`python` dans le terminal) :
|
|
|
|
```
|
|
>>> import math
|
|
>>> help(math.sqrt)
|
|
Help on built-in function sqrt in module math:
|
|
|
|
sqrt(x, /)
|
|
Return the square root of x.
|
|
```
|
|
|
|
Appuie sur `q` pour quitter l'aide.
|
|
|
|
**La documentation officielle**, en français : <https://docs.python.org/fr/3/library/index.html>. Chaque module y a sa page, avec des exemples. Prends l'habitude d'y aller : c'est **la** référence. Dans VS Code, survoler une fonction ou faire **Ctrl+clic** dessus affiche aussi sa documentation.
|
|
|
|
### 4. Créer ton propre module
|
|
|
|
Créer un module, c'est… créer un fichier `.py`. Rien de plus. Prenons un dossier de projet avec deux fichiers **côte à côte** :
|
|
|
|
```
|
|
mon_projet/
|
|
├── geometrie.py
|
|
└── main.py
|
|
```
|
|
|
|
`geometrie.py` :
|
|
|
|
```python
|
|
"""Petites fonctions de géométrie."""
|
|
|
|
import math
|
|
|
|
PI_ARRONDI = 3.14
|
|
|
|
|
|
def aire_cercle(rayon):
|
|
"""Renvoie l'aire d'un cercle."""
|
|
return math.pi * rayon**2
|
|
|
|
|
|
def perimetre_rectangle(longueur, largeur):
|
|
"""Renvoie le périmètre d'un rectangle."""
|
|
return 2 * (longueur + largeur)
|
|
```
|
|
|
|
`main.py` :
|
|
|
|
```python
|
|
import geometrie
|
|
|
|
print(f"{geometrie.aire_cercle(2):.2f}")
|
|
print(geometrie.perimetre_rectangle(3, 5))
|
|
print(geometrie.PI_ARRONDI)
|
|
```
|
|
|
|
En lançant `python main.py` depuis le dossier `mon_projet` :
|
|
|
|
```
|
|
12.57
|
|
16
|
|
3.14
|
|
```
|
|
|
|
Points importants :
|
|
|
|
- On écrit `import geometrie` **sans** l'extension `.py`.
|
|
- Le nom du fichier doit être un **nom de variable valide** : lettres minuscules, chiffres, tirets bas. `mon-module.py` ou `2outils.py` ne pourront pas être importés (`import mon-module` provoque une `SyntaxError`).
|
|
- Le module a sa propre « boîte » de noms : la variable `PI_ARRONDI` de `geometrie` ne se mélange pas avec celles de `main.py`. On parle d'**espace de noms**.
|
|
- Un module peut lui-même importer d'autres modules (`geometrie` importe `math`).
|
|
|
|
#### Où Python cherche-t-il les modules ?
|
|
|
|
Quand tu écris `import geometrie`, Python cherche dans l'ordre :
|
|
|
|
1. **le dossier du script lancé** (ici `mon_projet/`) ;
|
|
2. les dossiers de la bibliothèque standard ;
|
|
3. les dossiers des bibliothèques installées avec `pip` (voir [chapitre 12](12-outils-venv-pip-git.md)).
|
|
|
|
Il prend **le premier fichier trouvé**. Tu peux voir cette liste de dossiers avec `sys.path` :
|
|
|
|
```python
|
|
import sys
|
|
|
|
for dossier in sys.path:
|
|
print(dossier)
|
|
```
|
|
|
|
Le premier dossier de la liste est celui de ton script. Retiens bien ce point, il explique le piège le plus célèbre de ce chapitre (fichier nommé `random.py`, voir les pièges).
|
|
|
|
#### Un module n'est exécuté qu'une fois
|
|
|
|
Lors du premier `import`, Python **exécute tout le fichier** du module, de haut en bas, puis le garde en mémoire. Les `import` suivants du même module (dans le même programme) réutilisent la version déjà chargée, sans le réexécuter.
|
|
|
|
### 5. `if __name__ == "__main__":`
|
|
|
|
Puisque `import` exécute tout le fichier, que se passe-t-il si ton module contient du code de test ?
|
|
|
|
`temperatures.py` :
|
|
|
|
```python
|
|
def celsius_vers_fahrenheit(celsius):
|
|
return celsius * 9 / 5 + 32
|
|
|
|
|
|
print("Test :", celsius_vers_fahrenheit(100))
|
|
```
|
|
|
|
`meteo.py` :
|
|
|
|
```python
|
|
import temperatures
|
|
|
|
print(f"Il fait {temperatures.celsius_vers_fahrenheit(20)} °F")
|
|
```
|
|
|
|
```
|
|
Test : 212.0
|
|
Il fait 68.0 °F
|
|
```
|
|
|
|
La ligne `Test : 212.0` s'affiche alors qu'on ne l'a pas demandée : elle vient de l'exécution de `temperatures.py` au moment de l'import. Gênant.
|
|
|
|
La solution est une variable spéciale, **`__name__`**, que Python crée automatiquement dans chaque fichier :
|
|
|
|
- si le fichier est **lancé directement** (`python temperatures.py`), `__name__` vaut `"__main__"` ;
|
|
- si le fichier est **importé**, `__name__` vaut le nom du module (`"temperatures"`).
|
|
|
|
D'où ce schéma, que tu verras dans presque tous les fichiers Python :
|
|
|
|
```python
|
|
def celsius_vers_fahrenheit(celsius):
|
|
return celsius * 9 / 5 + 32
|
|
|
|
|
|
if __name__ == "__main__":
|
|
# Ce bloc ne s'exécute QUE si on lance ce fichier directement
|
|
print("Test :", celsius_vers_fahrenheit(100))
|
|
```
|
|
|
|
Maintenant :
|
|
|
|
- `python temperatures.py` affiche `Test : 212.0` ;
|
|
- `python meteo.py` affiche seulement `Il fait 68.0 °F`.
|
|
|
|
> 💡 **Analogie** : un module, c'est comme un chef cuisinier. Quand on l'invite dans une autre cuisine (import), il apporte ses recettes mais ne se met pas à cuisiner tout seul. Quand il est dans sa propre cuisine (lancé directement), il peut faire une démonstration.
|
|
|
|
Une organisation très répandue consiste à regrouper le programme principal dans une fonction `main()` :
|
|
|
|
```python
|
|
def saluer(nom):
|
|
return f"Bonjour {nom} !"
|
|
|
|
|
|
def main():
|
|
nom = input("Ton prénom : ")
|
|
print(saluer(nom))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|
|
```
|
|
|
|
Avec l'entrée `Léa` :
|
|
|
|
```
|
|
Ton prénom : Léa
|
|
Bonjour Léa !
|
|
```
|
|
|
|
Ainsi, un autre fichier peut faire `from salutations import saluer` sans déclencher le `input()`.
|
|
|
|
### 6. Les paquets : des modules rangés dans des dossiers
|
|
|
|
Quand tu as beaucoup de modules, tu peux les regrouper dans un **dossier** : c'est un **paquet** (*package*). On y ajoute traditionnellement un fichier (souvent vide) nommé `__init__.py`, qui indique « ce dossier est un paquet Python ».
|
|
|
|
```
|
|
jeu/
|
|
├── main.py
|
|
└── outils/
|
|
├── __init__.py
|
|
├── des.py
|
|
└── affichage.py
|
|
```
|
|
|
|
`outils/des.py` :
|
|
|
|
```python
|
|
import random
|
|
|
|
|
|
def lancer_de(faces=6):
|
|
return random.randint(1, faces)
|
|
```
|
|
|
|
`outils/affichage.py` :
|
|
|
|
```python
|
|
def cadre(texte):
|
|
bordure = "+" + "-" * (len(texte) + 2) + "+"
|
|
return f"{bordure}\n| {texte} |\n{bordure}"
|
|
```
|
|
|
|
`main.py` :
|
|
|
|
```python
|
|
from outils.des import lancer_de
|
|
from outils import affichage
|
|
|
|
resultat = lancer_de()
|
|
print(affichage.cadre(f"Tu as fait {resultat}"))
|
|
```
|
|
|
|
Exemple de sortie (le nombre change à chaque exécution) :
|
|
|
|
```
|
|
+--------------+
|
|
| Tu as fait 4 |
|
|
+--------------+
|
|
```
|
|
|
|
On accède à un module d'un paquet avec un **point** : `outils.des`, comme un chemin de dossier. Tu peux imbriquer des paquets dans des paquets. La structure complète d'un projet est détaillée au [chapitre 13](13-tests-pytest-bonnes-pratiques.md).
|
|
|
|
### 7. `random` : le hasard
|
|
|
|
Le module `random` génère des nombres **pseudo-aléatoires** (calculés par un algorithme, mais imprévisibles en pratique).
|
|
|
|
```python
|
|
import random
|
|
|
|
print(random.randint(1, 6)) # entier entre 1 et 6, bornes INCLUSES
|
|
print(random.random()) # décimal dans [0, 1[
|
|
print(random.uniform(1.5, 3.5)) # décimal entre 1.5 et 3.5
|
|
|
|
couleurs = ["rouge", "vert", "bleu", "jaune"]
|
|
print(random.choice(couleurs)) # un élément au hasard
|
|
print(random.choices(couleurs, k=5)) # 5 tirages AVEC remise (doublons possibles)
|
|
print(random.sample(range(1, 50), 6)) # 6 tirages SANS remise (loto)
|
|
|
|
cartes = ["As", "Roi", "Dame", "Valet", "10"]
|
|
random.shuffle(cartes) # mélange la liste SUR PLACE (renvoie None)
|
|
print(cartes)
|
|
```
|
|
|
|
Exemple de sortie (différente à chaque exécution) :
|
|
|
|
```
|
|
6
|
|
0.16931005030681068
|
|
2.6574891618278063
|
|
bleu
|
|
['jaune', 'bleu', 'jaune', 'jaune', 'jaune']
|
|
[7, 34, 25, 47, 17, 40]
|
|
['Dame', 'As', '10', 'Valet', 'Roi']
|
|
```
|
|
|
|
> ⚠️ Contrairement à `range(1, 6)` qui s'arrête à 5, **`randint(1, 6)` inclut le 6**. C'est une exception à la règle habituelle de Python.
|
|
|
|
#### Tirage pondéré
|
|
|
|
`choices` accepte des poids : ici « pile » a 9 fois plus de chances de sortir que « face ».
|
|
|
|
```python
|
|
import random
|
|
|
|
print(random.choices(["pile", "face"], weights=[9, 1], k=10))
|
|
```
|
|
|
|
#### Rendre le hasard reproductible : `seed`
|
|
|
|
Pour déboguer ou tester, on veut parfois **le même hasard** à chaque exécution. `random.seed(n)` fixe le point de départ de l'algorithme :
|
|
|
|
```python
|
|
import random
|
|
|
|
random.seed(2024)
|
|
print([random.randint(1, 100) for _ in range(5)])
|
|
random.seed(2024)
|
|
print([random.randint(1, 100) for _ in range(5)])
|
|
```
|
|
|
|
```
|
|
[61, 24, 94, 75, 39]
|
|
[61, 24, 94, 75, 39]
|
|
```
|
|
|
|
Même graine, mêmes nombres. Très pratique pour écrire des tests.
|
|
|
|
> ⚠️ **Sécurité** : `random` est prévisible si on connaît la graine. Pour des **mots de passe** ou des jetons secrets, utilise le module **`secrets`**, conçu pour la cryptographie : `secrets.choice(...)`, `secrets.randbelow(n)`, `secrets.token_hex(16)`. On s'en servira dans le mini-projet.
|
|
|
|
### 8. `math` : les mathématiques
|
|
|
|
```python
|
|
import math
|
|
|
|
print(math.pi, math.e)
|
|
print(math.sqrt(2)) # racine carrée
|
|
print(math.floor(3.7), math.ceil(3.2)) # arrondi inférieur / supérieur
|
|
print(math.floor(-3.7), int(-3.7)) # attention aux négatifs !
|
|
print(math.factorial(5)) # 5! = 120
|
|
print(math.gcd(12, 18), math.lcm(4, 6)) # PGCD et PPCM
|
|
print(math.hypot(3, 4)) # hypoténuse : racine de 3² + 4²
|
|
print(math.dist((0, 0), (3, 4))) # distance entre deux points
|
|
print(math.log10(1000), math.log2(8)) # logarithmes
|
|
print(math.cos(math.pi)) # trigonométrie (en radians)
|
|
print(math.degrees(math.pi / 2), math.radians(180))
|
|
```
|
|
|
|
```
|
|
3.141592653589793 2.718281828459045
|
|
1.4142135623730951
|
|
3 4
|
|
-4 -3
|
|
120
|
|
6 12
|
|
5.0
|
|
5.0
|
|
3.0 3.0
|
|
-1.0
|
|
90.0 3.141592653589793
|
|
```
|
|
|
|
`math.floor` arrondit **vers le bas** (vers moins l'infini) alors que `int()` **tronque** (supprime la partie décimale) : pour `-3.7`, on obtient `-4` et `-3`.
|
|
|
|
#### Comparer des décimaux : `math.isclose`
|
|
|
|
Tu te souviens de l'imprécision des `float` ([chapitre 01](01-variables-types-operateurs.md)) ? `math.isclose` permet de comparer deux décimaux « à peu près » :
|
|
|
|
```python
|
|
import math
|
|
|
|
print(0.1 + 0.2 == 0.3)
|
|
print(math.isclose(0.1 + 0.2, 0.3))
|
|
```
|
|
|
|
```
|
|
False
|
|
True
|
|
```
|
|
|
|
#### En bonus : `statistics`
|
|
|
|
Pour les calculs statistiques simples, inutile de tout recoder :
|
|
|
|
```python
|
|
import statistics
|
|
|
|
notes = [12, 15, 9, 18]
|
|
print(statistics.mean(notes)) # moyenne
|
|
print(statistics.median(notes)) # médiane
|
|
print(round(statistics.stdev(notes), 2)) # écart-type
|
|
print(statistics.mode([1, 2, 2, 3])) # valeur la plus fréquente
|
|
```
|
|
|
|
```
|
|
13.5
|
|
13.5
|
|
3.87
|
|
2
|
|
```
|
|
|
|
### 9. `datetime` : dates et heures
|
|
|
|
Le module `datetime` contient plusieurs **types** (attention, l'un d'eux porte le même nom que le module !) :
|
|
|
|
| Type | Représente | Exemple |
|
|
|---|---|---|
|
|
| `date` | une date (jour, mois, année) | 14 juillet 2025 |
|
|
| `datetime` | une date **et** une heure | 31/12/2025 à 23:59:30 |
|
|
| `timedelta` | une **durée** | 30 jours, 2 heures |
|
|
|
|
On les importe généralement ainsi :
|
|
|
|
```python
|
|
from datetime import date, datetime, timedelta
|
|
```
|
|
|
|
#### Créer et lire une date
|
|
|
|
```python
|
|
from datetime import date, datetime
|
|
|
|
fete = date(2025, 7, 14) # année, mois, jour
|
|
print(fete)
|
|
print(fete.year, fete.month, fete.day)
|
|
print(fete.weekday()) # 0 = lundi, 6 = dimanche
|
|
|
|
reveillon = datetime(2025, 12, 31, 23, 59, 30)
|
|
print(reveillon)
|
|
print(reveillon.hour, reveillon.minute)
|
|
|
|
print(type(date.today()).__name__) # la date du jour
|
|
print(type(datetime.now()).__name__) # la date et l'heure actuelles
|
|
```
|
|
|
|
```
|
|
2025-07-14
|
|
2025 7 14
|
|
0
|
|
2025-12-31 23:59:30
|
|
23 59
|
|
date
|
|
datetime
|
|
```
|
|
|
|
#### Calculer avec les dates : `timedelta`
|
|
|
|
Additionner une durée à une date, ou soustraire deux dates, c'est là que `datetime` brille. Il gère pour toi les mois de 28, 30 ou 31 jours et les années bissextiles :
|
|
|
|
```python
|
|
from datetime import date, datetime, timedelta
|
|
|
|
fete = date(2025, 7, 14)
|
|
print(fete + timedelta(days=30)) # dans 30 jours
|
|
print(fete - timedelta(weeks=2)) # il y a 2 semaines
|
|
|
|
ecart = date(2025, 12, 25) - fete # date - date = timedelta
|
|
print(ecart)
|
|
print(ecart.days)
|
|
|
|
print(date(2024, 2, 28) + timedelta(days=1)) # 2024 est bissextile
|
|
print(date(2025, 2, 28) + timedelta(days=1))
|
|
|
|
duree = datetime(2026, 1, 1, 10, 0) - datetime(2025, 12, 31, 22, 30)
|
|
print(duree, "soit", duree.total_seconds(), "secondes")
|
|
```
|
|
|
|
```
|
|
2025-08-13
|
|
2025-06-30
|
|
164 days, 0:00:00
|
|
164
|
|
2024-02-29
|
|
2025-03-01
|
|
11:30:00 soit 41400.0 secondes
|
|
```
|
|
|
|
#### Formater et lire du texte : `strftime` / `strptime`
|
|
|
|
- **`strftime`** (*string format time*) : date → texte, selon un **format**.
|
|
- **`strptime`** (*string parse time*) : texte → date, selon un format.
|
|
|
|
| Code | Signification | Exemple |
|
|
|---|---|---|
|
|
| `%d` | jour sur 2 chiffres | `03` |
|
|
| `%m` | mois sur 2 chiffres | `02` |
|
|
| `%Y` | année sur 4 chiffres | `2026` |
|
|
| `%H` | heure (00-23) | `14` |
|
|
| `%M` | minutes | `30` |
|
|
| `%S` | secondes | `05` |
|
|
| `%A` / `%B` | nom du jour / du mois (en anglais par défaut) | `Monday` / `July` |
|
|
|
|
```python
|
|
from datetime import date, datetime
|
|
|
|
fete = date(2025, 7, 14)
|
|
print(fete.strftime("%d/%m/%Y"))
|
|
|
|
rdv = datetime.strptime("03/02/2026 14:30", "%d/%m/%Y %H:%M")
|
|
print(rdv)
|
|
print(rdv.strftime("Rendez-vous le %d/%m à %Hh%M"))
|
|
|
|
print(date.fromisoformat("2026-02-03")) # format international AAAA-MM-JJ
|
|
```
|
|
|
|
```
|
|
14/07/2025
|
|
2026-02-03 14:30:00
|
|
Rendez-vous le 03/02 à 14h30
|
|
2026-02-03
|
|
```
|
|
|
|
Les noms de jours et de mois (`%A`, `%B`) sortent en anglais par défaut. La façon la plus simple et la plus fiable d'avoir le français est d'utiliser ta propre liste :
|
|
|
|
```python
|
|
from datetime import date
|
|
|
|
JOURS = ["lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi", "dimanche"]
|
|
MOIS = ["janvier", "février", "mars", "avril", "mai", "juin", "juillet",
|
|
"août", "septembre", "octobre", "novembre", "décembre"]
|
|
|
|
fete = date(2025, 7, 14)
|
|
print(f"{JOURS[fete.weekday()]} {fete.day} {MOIS[fete.month - 1]} {fete.year}")
|
|
```
|
|
|
|
```
|
|
lundi 14 juillet 2025
|
|
```
|
|
|
|
> 💡 Pour stocker une date dans un fichier JSON ou CSV, utilise le format ISO (`date.isoformat()` → `"2025-07-14"`) et relis-le avec `date.fromisoformat()`. Ce format se trie correctement par ordre alphabétique !
|
|
|
|
### 10. `os` et `sys` : parler au système
|
|
|
|
#### `os` : le système d'exploitation
|
|
|
|
```python
|
|
import os
|
|
|
|
print(os.getcwd()) # dossier de travail actuel
|
|
print(os.listdir(".")) # contenu d'un dossier
|
|
print(os.environ.get("HOME")) # variable d'environnement (None si absente)
|
|
print(os.sep) # séparateur de chemin : / ou \
|
|
```
|
|
|
|
La sortie dépend de ton ordinateur. Par exemple sous Linux :
|
|
|
|
```
|
|
/home/toi/cours
|
|
['mon_script.py', 'notes.txt']
|
|
/home/toi
|
|
/
|
|
```
|
|
|
|
Le module `os` contient aussi des fonctions pour créer ou supprimer des dossiers (`os.makedirs`, `os.remove`, `os.rename`…). Mais pour manipuler des **chemins et fichiers**, préfère **`pathlib`** (vu au [chapitre 07](07-fichiers-csv-json.md)), plus moderne et plus lisible :
|
|
|
|
| Avec `os` | Avec `pathlib` |
|
|
|---|---|
|
|
| `os.getcwd()` | `Path.cwd()` |
|
|
| `os.listdir(d)` | `Path(d).iterdir()` |
|
|
| `os.path.exists(c)` | `Path(c).exists()` |
|
|
| `os.path.join(d, "a.txt")` | `Path(d) / "a.txt"` |
|
|
| `os.makedirs(d, exist_ok=True)` | `Path(d).mkdir(parents=True, exist_ok=True)` |
|
|
|
|
`os` reste utile pour les **variables d'environnement** (`os.environ`), très utilisées pour stocker des réglages ou des mots de passe en dehors du code.
|
|
|
|
#### `sys` : l'interpréteur Python
|
|
|
|
```python
|
|
import sys
|
|
|
|
print(sys.version_info >= (3, 12)) # vérifier la version de Python
|
|
print(sys.argv) # arguments de la ligne de commande
|
|
```
|
|
|
|
**`sys.argv`** est une liste contenant le nom du script suivi des **arguments** tapés dans le terminal. Fichier `bonjour.py` :
|
|
|
|
```python
|
|
import sys
|
|
|
|
if len(sys.argv) < 2:
|
|
print("Usage : python bonjour.py PRENOM")
|
|
sys.exit(1) # arrête le programme avec un code d'erreur
|
|
|
|
prenom = sys.argv[1]
|
|
print(f"Bonjour {prenom} !")
|
|
```
|
|
|
|
```
|
|
$ python bonjour.py
|
|
Usage : python bonjour.py PRENOM
|
|
$ python bonjour.py Léa
|
|
Bonjour Léa !
|
|
```
|
|
|
|
`sys.exit()` arrête immédiatement le programme. Par convention, le code `0` signifie « tout va bien » et tout autre nombre signale une erreur. C'est la base des scripts d'automatisation du [chapitre 14](14-specialisations.md).
|
|
|
|
### 11. `collections` : des structures de données en plus
|
|
|
|
Le module `collections` offre des versions « améliorées » des listes et dictionnaires du [chapitre 04](04-structures-de-donnees.md).
|
|
|
|
#### `Counter` : compter
|
|
|
|
Compter des éléments est si fréquent qu'il existe un outil dédié :
|
|
|
|
```python
|
|
from collections import Counter
|
|
|
|
lettres = Counter("abracadabra")
|
|
print(lettres)
|
|
print(lettres["a"], lettres["z"]) # pas de KeyError : 0 si absent
|
|
print(lettres.most_common(2)) # les 2 plus fréquents
|
|
|
|
mots = "le chat et le chien et le lapin".split()
|
|
print(Counter(mots).most_common(3))
|
|
```
|
|
|
|
```
|
|
Counter({'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1})
|
|
5 0
|
|
[('a', 5), ('b', 2)]
|
|
[('le', 3), ('et', 2), ('chat', 1)]
|
|
```
|
|
|
|
Compare avec la version « à la main » du chapitre 04 : une boucle, un `if mot in compteur`, une incrémentation… `Counter` fait tout en une ligne.
|
|
|
|
#### `defaultdict` : un dictionnaire avec valeur par défaut
|
|
|
|
Pour regrouper des éléments, on écrit souvent : « si la clé n'existe pas, crée une liste vide, puis ajoute ». `defaultdict` le fait automatiquement :
|
|
|
|
```python
|
|
from collections import defaultdict
|
|
|
|
eleves = [("Alice", "A"), ("Bob", "B"), ("Chloé", "A"), ("David", "C")]
|
|
|
|
par_classe = defaultdict(list) # valeur par défaut : une liste vide
|
|
for nom, classe in eleves:
|
|
par_classe[classe].append(nom) # pas besoin de vérifier si la clé existe
|
|
|
|
print(dict(par_classe))
|
|
```
|
|
|
|
```
|
|
{'A': ['Alice', 'Chloé'], 'B': ['Bob'], 'C': ['David']}
|
|
```
|
|
|
|
On passe à `defaultdict` **le type** de la valeur par défaut, sans parenthèses : `list` (liste vide), `int` (0), `set` (ensemble vide), `str` (chaîne vide).
|
|
|
|
#### `namedtuple` : des tuples avec des noms
|
|
|
|
```python
|
|
from collections import namedtuple
|
|
|
|
Point = namedtuple("Point", ["x", "y"])
|
|
p = Point(3, 4)
|
|
print(p)
|
|
print(p.x, p.y) # accès par nom : plus lisible que p[0]
|
|
print(p[0]) # l'accès par indice marche toujours
|
|
```
|
|
|
|
```
|
|
Point(x=3, y=4)
|
|
3 4
|
|
3
|
|
```
|
|
|
|
C'est un premier pas vers les **classes** du [chapitre 10](10-poo-classes-objets.md) et les *dataclasses* du [chapitre 11](11-poo-avancee-heritage-typage.md), qui feront la même chose en plus puissant.
|
|
|
|
#### `deque` : une file à double entrée
|
|
|
|
`deque` (prononcé « dèque ») est une liste optimisée pour ajouter et retirer **aux deux bouts**. Avec `maxlen`, elle ne garde que les N derniers éléments, idéal pour un historique :
|
|
|
|
```python
|
|
from collections import deque
|
|
|
|
derniers = deque(maxlen=3)
|
|
for numero in range(1, 6):
|
|
derniers.append(numero)
|
|
print(list(derniers))
|
|
```
|
|
|
|
```
|
|
[1]
|
|
[1, 2]
|
|
[1, 2, 3]
|
|
[2, 3, 4]
|
|
[3, 4, 5]
|
|
```
|
|
|
|
### 12. D'autres modules utiles à connaître
|
|
|
|
Tu n'as pas besoin de tout apprendre par cœur. Retiens surtout qu'**ils existent**, pour penser à les chercher le jour venu :
|
|
|
|
| Module | Pour quoi faire | Exemple |
|
|
|---|---|---|
|
|
| `time` | pauses, mesurer une durée | `time.sleep(1)`, `time.perf_counter()` |
|
|
| `string` | constantes de caractères | `string.ascii_letters`, `string.digits` |
|
|
| `secrets` | hasard sécurisé | `secrets.choice(...)`, `secrets.token_hex(8)` |
|
|
| `statistics` | moyenne, médiane… | `statistics.median(...)` |
|
|
| `json`, `csv` | formats de fichiers | vus au [chapitre 07](07-fichiers-csv-json.md) |
|
|
| `pathlib`, `shutil` | fichiers, copies de dossiers | `shutil.copy(...)` |
|
|
| `itertools` | combinaisons, permutations | `itertools.permutations("abc")` |
|
|
| `textwrap` | mise en forme de texte | `textwrap.wrap(texte, 40)` |
|
|
| `urllib.request` | télécharger une page web | (on préférera `requests`, chapitre 14) |
|
|
|
|
```python
|
|
import string
|
|
import time
|
|
|
|
print(string.ascii_lowercase)
|
|
print(string.digits)
|
|
|
|
debut = time.perf_counter()
|
|
total = sum(range(1_000_000))
|
|
duree = time.perf_counter() - debut
|
|
print(f"Calcul effectué en {duree:.4f} s")
|
|
```
|
|
|
|
Exemple de sortie (la durée varie selon l'ordinateur) :
|
|
|
|
```
|
|
abcdefghijklmnopqrstuvwxyz
|
|
0123456789
|
|
Calcul effectué en 0.0123 s
|
|
```
|
|
|
|
Et quand la bibliothèque standard ne suffit pas, il existe plus de 500 000 bibliothèques supplémentaires sur PyPI, qu'on installe avec `pip` : ce sera le sujet du [chapitre 12](12-outils-venv-pip-git.md).
|
|
|
|
---
|
|
|
|
## Pièges fréquents
|
|
|
|
### Piège 1 — Nommer son fichier comme un module de la bibliothèque standard
|
|
|
|
C'est **le** piège classique. Tu veux tester le module `random`, alors tu crées un fichier… `random.py` :
|
|
|
|
```python
|
|
# fichier : random.py
|
|
import random
|
|
|
|
print(random.randint(1, 6))
|
|
```
|
|
|
|
```
|
|
Traceback (most recent call last):
|
|
File "/home/toi/cours/random.py", line 1, in <module>
|
|
import random
|
|
File "/home/toi/cours/random.py", line 3, in <module>
|
|
print(random.randint(1, 6))
|
|
^^^^^^^^^^^^^^
|
|
AttributeError: module 'random' has no attribute 'randint' (consider renaming '/home/toi/cours/random.py' since it has the same name as the standard library module named 'random' and prevents importing that standard library module)
|
|
```
|
|
|
|
Pourquoi ? Python cherche d'abord dans **le dossier du script** (section 4) : `import random` importe donc… ton propre fichier, qui n'a pas de fonction `randint`. Python 3.13 te donne même la solution dans le message (*consider renaming*). En Python 3.12, le message est moins clair : `AttributeError: partially initialized module 'random' has no attribute 'randint' (most likely due to a circular import)`.
|
|
|
|
✅ **Correction** : renomme ton fichier (`test_hasard.py`, `mon_random.py`…) **et supprime le dossier `__pycache__`** s'il a été créé à côté. Noms à ne jamais donner à tes fichiers : `random.py`, `math.py`, `json.py`, `csv.py`, `string.py`, `time.py`, `datetime.py`, `email.py`, `test.py`, `turtle.py`…
|
|
|
|
### Piège 2 — L'import circulaire
|
|
|
|
Deux modules qui s'importent **mutuellement** :
|
|
|
|
```python
|
|
# fichier : joueurs.py
|
|
from scores import meilleur_score
|
|
|
|
|
|
def creer_joueur(nom):
|
|
return {"nom": nom, "score": 0}
|
|
```
|
|
|
|
```python
|
|
# fichier : scores.py
|
|
from joueurs import creer_joueur
|
|
|
|
|
|
def meilleur_score(joueurs):
|
|
return max(joueur["score"] for joueur in joueurs)
|
|
```
|
|
|
|
En lançant un `main.py` qui contient `from joueurs import creer_joueur`, en Python 3.12 :
|
|
|
|
```
|
|
Traceback (most recent call last):
|
|
File "/home/toi/cours/main.py", line 1, in <module>
|
|
from joueurs import creer_joueur
|
|
File "/home/toi/cours/joueurs.py", line 1, in <module>
|
|
from scores import meilleur_score
|
|
File "/home/toi/cours/scores.py", line 1, in <module>
|
|
from joueurs import creer_joueur
|
|
ImportError: cannot import name 'creer_joueur' from partially initialized module 'joueurs' (most likely due to a circular import) (/home/toi/cours/joueurs.py)
|
|
```
|
|
|
|
(En Python 3.13, la dernière ligne est formulée autrement : `ImportError: cannot import name 'creer_joueur' from 'joueurs' (consider renaming ...)`. Ne te laisse pas tromper : il ne s'agit pas d'un conflit de nom ici, mais bien d'un import circulaire. Le signe qui ne trompe pas : dans le traceback, le même fichier `joueurs.py` apparaît au début **et** est réimporté à la fin.)
|
|
|
|
Python commence à exécuter `joueurs.py`, qui demande `scores.py`, qui redemande `joueurs.py`… lequel n'est pas encore fini de charger (*partially initialized*) : `creer_joueur` n'existe pas encore.
|
|
|
|
✅ **Corrections**, de la meilleure à la moins bonne :
|
|
|
|
1. **Réorganiser** : souvent, l'un des deux modules n'a pas vraiment besoin de l'autre. Ici `joueurs.py` n'utilise même pas `meilleur_score` : on supprime l'import.
|
|
2. Déplacer le code commun dans un **troisième module** que les deux importent.
|
|
3. En dernier recours, déplacer l'`import` **à l'intérieur** de la fonction qui en a besoin.
|
|
|
|
### Piège 3 — Confondre le module `datetime` et le type `datetime`
|
|
|
|
```python
|
|
import datetime
|
|
|
|
maintenant = datetime.now()
|
|
```
|
|
|
|
```
|
|
AttributeError: module 'datetime' has no attribute 'now'
|
|
```
|
|
|
|
Ici, `datetime` désigne le **module** ; le type est à l'intérieur : `datetime.datetime.now()`. ✅ Plus lisible :
|
|
|
|
```python
|
|
from datetime import datetime
|
|
|
|
maintenant = datetime.now()
|
|
```
|
|
|
|
### Piège 4 — Oublier le préfixe du module (ou l'import)
|
|
|
|
```python
|
|
import math
|
|
|
|
print(sqrt(16))
|
|
```
|
|
|
|
```
|
|
NameError: name 'sqrt' is not defined
|
|
```
|
|
|
|
Avec `import math`, il faut écrire `math.sqrt(16)`. ✅ Ou bien `from math import sqrt`.
|
|
|
|
### Piège 5 — Mettre l'extension ou un tiret dans l'import
|
|
|
|
```python
|
|
import outils.py
|
|
```
|
|
|
|
```
|
|
ModuleNotFoundError: No module named 'outils.py'; 'outils' is not a package
|
|
```
|
|
|
|
Python croit que `outils` est un paquet contenant un module `py` ! ✅ `import outils`. De même, un fichier `mon-module.py` ne peut pas être importé (le tiret est lu comme une soustraction) : nomme-le `mon_module.py`.
|
|
|
|
### Piège 6 — `ModuleNotFoundError` parce qu'on n'est pas dans le bon dossier
|
|
|
|
```
|
|
ModuleNotFoundError: No module named 'geometrie'
|
|
```
|
|
|
|
Le fichier existe pourtant bien ! Causes fréquentes :
|
|
|
|
- `geometrie.py` n'est **pas dans le même dossier** que le script lancé ;
|
|
- faute de frappe dans le nom (`geometrie` / `geometry`) ;
|
|
- pour une bibliothèque externe : elle n'est pas installée dans l'environnement utilisé (voir [chapitre 12](12-outils-venv-pip-git.md)).
|
|
|
|
✅ Vérifie avec `print(sys.path)` où Python cherche, et place tes modules à côté de ton script principal.
|
|
|
|
### Piège 7 — `random.shuffle` renvoie `None`
|
|
|
|
```python
|
|
import random
|
|
|
|
cartes = ["As", "Roi", "Dame"]
|
|
cartes = random.shuffle(cartes)
|
|
print(cartes)
|
|
```
|
|
|
|
```
|
|
None
|
|
```
|
|
|
|
`shuffle` mélange la liste **sur place** et ne renvoie rien (comme `liste.sort()`). En réaffectant, on a écrasé la liste par `None`. ✅ Écris juste `random.shuffle(cartes)`, ou utilise `random.sample(cartes, len(cartes))` pour obtenir une **nouvelle** liste mélangée.
|
|
|
|
### Piège 8 — Utiliser `random` pour des mots de passe
|
|
|
|
`random` est conçu pour les simulations et les jeux, pas pour la sécurité : ses tirages sont reproductibles par quelqu'un qui connaît son état interne. ✅ Pour tout ce qui est secret (mots de passe, jetons, codes de validation), utilise `secrets`.
|
|
|
|
---
|
|
|
|
## Exercices
|
|
|
|
### Exercice 1 ⭐ — Lancer de dés
|
|
|
|
Écris un programme qui simule le lancer de **deux dés à six faces**, affiche chaque dé et leur somme, et affiche `Double !` si les deux dés sont identiques.
|
|
|
|
```
|
|
Dé 1 : 4
|
|
Dé 2 : 4
|
|
Somme : 8
|
|
Double !
|
|
```
|
|
|
|
### Exercice 2 ⭐ — Calculs géométriques
|
|
|
|
En utilisant le module `math`, écris trois fonctions :
|
|
|
|
- `aire_disque(rayon)` ;
|
|
- `hypotenuse(a, b)` : la longueur de l'hypoténuse d'un triangle rectangle ;
|
|
- `nombre_de_dalles(surface_m2, surface_dalle_m2)` : le nombre de dalles à acheter (on ne peut pas acheter une fraction de dalle, donc on arrondit **au-dessus**).
|
|
|
|
```python
|
|
print(f"{aire_disque(3):.2f}") # 28.27
|
|
print(hypotenuse(6, 8)) # 10.0
|
|
print(nombre_de_dalles(10.5, 0.36)) # 30
|
|
```
|
|
|
|
### Exercice 3 ⭐ — Combien de jours ?
|
|
|
|
Écris une fonction `jours_avant(jour_cible, aujourd_hui)` qui reçoit deux objets `date` et renvoie le nombre de jours qui les séparent. Puis écris une fonction `prochain_anniversaire(naissance, aujourd_hui)` qui renvoie le nombre de jours avant le prochain anniversaire (0 si c'est aujourd'hui).
|
|
|
|
```python
|
|
aujourd_hui = date(2026, 3, 10)
|
|
print(jours_avant(date(2026, 12, 25), aujourd_hui)) # 290
|
|
print(prochain_anniversaire(date(1998, 5, 1), aujourd_hui)) # 52
|
|
print(prochain_anniversaire(date(2001, 1, 15), aujourd_hui)) # 311
|
|
print(prochain_anniversaire(date(1990, 3, 10), aujourd_hui)) # 0
|
|
```
|
|
|
|
(On ignore le cas des personnes nées un 29 février.)
|
|
|
|
### Exercice 4 ⭐⭐ — Analyse d'un texte avec `Counter`
|
|
|
|
Écris une fonction `analyser(texte)` qui affiche :
|
|
|
|
- le nombre total de mots ;
|
|
- le nombre de mots différents ;
|
|
- les 3 mots les plus fréquents (en minuscules, ponctuation `.,;:!?` retirée) ;
|
|
- la lettre la plus fréquente (on ne compte que les lettres).
|
|
|
|
```python
|
|
analyser("Le petit chat boit du lait. Le chat dort. Le chien aboie !")
|
|
```
|
|
|
|
```
|
|
Mots : 12
|
|
Mots différents : 9
|
|
Top 3 : le (3), chat (2), petit (1)
|
|
Lettre la plus fréquente : t
|
|
```
|
|
|
|
### Exercice 5 ⭐⭐ — Ton premier module
|
|
|
|
Crée un module `conversions.py` contenant :
|
|
|
|
- `km_vers_miles(km)` (1 mile = 1,609344 km) ;
|
|
- `celsius_vers_fahrenheit(c)` ;
|
|
- `secondes_vers_hms(secondes)` qui renvoie une chaîne `"HH:MM:SS"`.
|
|
|
|
Le module doit contenir un bloc `if __name__ == "__main__":` qui vérifie les trois fonctions avec des `assert` et affiche `Tous les tests sont passés.`
|
|
|
|
Crée ensuite un fichier `principal.py` qui importe le module et affiche :
|
|
|
|
```
|
|
42.195 km = 26.22 miles
|
|
37 °C = 98.6 °F
|
|
5000 s = 01:23:20
|
|
```
|
|
|
|
Vérifie que lancer `principal.py` n'affiche **pas** le message des tests.
|
|
|
|
### Exercice 6 ⭐⭐ — Répertoire par initiale
|
|
|
|
Avec `defaultdict`, écris une fonction `regrouper_par_initiale(noms)` qui renvoie un dictionnaire associant chaque initiale (en majuscule) à la liste **triée** des noms qui commencent par cette lettre. Les clés doivent elles aussi être triées.
|
|
|
|
```python
|
|
noms = ["léa", "Hugo", "lucas", "Emma", "hugo", "Inès", "Ethan", "Louise"]
|
|
print(regrouper_par_initiale(noms))
|
|
```
|
|
|
|
```
|
|
{'E': ['Emma', 'Ethan'], 'H': ['Hugo', 'Hugo'], 'I': ['Inès'], 'L': ['Louise', 'Lucas', 'Léa']}
|
|
```
|
|
|
|
(Les noms sont remis en forme avec `.capitalize()`.)
|
|
|
|
### Exercice 7 ⭐⭐⭐ — Simulation statistique
|
|
|
|
Simule **10 000 lancers** de deux dés et compte, avec `Counter`, combien de fois chaque somme (2 à 12) apparaît. Affiche un histogramme horizontal, où chaque `#` représente 50 lancers, avec le pourcentage. Utilise `random.seed(42)` pour obtenir des résultats reproductibles.
|
|
|
|
```
|
|
2 : 2.7 % #####
|
|
3 : 5.4 % ##########
|
|
...
|
|
7 : 17.0 % ##################################
|
|
...
|
|
```
|
|
|
|
Question bonus : pourquoi le 7 est-il la somme la plus fréquente ?
|
|
|
|
### Exercice 8 ⭐⭐⭐ — Un outil en ligne de commande
|
|
|
|
Écris un script `compter.py` qui s'utilise ainsi dans le terminal :
|
|
|
|
```
|
|
$ python compter.py
|
|
Usage : python compter.py FICHIER [NOMBRE]
|
|
$ python compter.py absent.txt
|
|
Erreur : le fichier 'absent.txt' n'existe pas.
|
|
$ python compter.py poeme.txt 3
|
|
poeme.txt : 6 lignes, 26 mots
|
|
Les 3 mots les plus fréquents :
|
|
la : 4
|
|
mer : 3
|
|
le : 2
|
|
```
|
|
|
|
- Le premier argument est le chemin d'un fichier texte, le second (optionnel, 5 par défaut) le nombre de mots à afficher.
|
|
- Utilise `sys.argv`, `sys.exit`, `pathlib` et `Counter`.
|
|
- Si le second argument n'est pas un entier, affiche une erreur claire.
|
|
- Organise ton code avec une fonction `main()` et `if __name__ == "__main__":`.
|
|
|
|
Fichier `poeme.txt` de test :
|
|
|
|
```
|
|
La mer, la mer, toujours recommencée.
|
|
Le vent se lève, il faut tenter de vivre.
|
|
La mer brille et le ciel
|
|
s'endort et
|
|
la vague
|
|
chante.
|
|
```
|
|
|
|
---
|
|
|
|
## Mini-projet — Générateur de mots de passe et module utilitaire maison
|
|
|
|
### Cahier des charges
|
|
|
|
Tu vas construire un petit projet sur **deux fichiers** :
|
|
|
|
```
|
|
generateur_mdp/
|
|
├── mdp_outils.py ← ton module utilitaire réutilisable
|
|
└── generateur.py ← le programme principal (menu)
|
|
```
|
|
|
|
**Le module `mdp_outils.py`** doit fournir :
|
|
|
|
1. `generer_mot_de_passe(longueur=12, majuscules=True, chiffres=True, symboles=True)` : renvoie un mot de passe aléatoire **sécurisé** (module `secrets`), contenant **au moins un caractère de chaque catégorie demandée** (les minuscules sont toujours incluses). Lève une `ValueError` si la longueur est inférieure à 4 ou au nombre de catégories.
|
|
2. `generer_phrase_de_passe(nombre_mots=4, separateur="-")` : assemble des mots tirés d'une liste (au moins 20 mots) et ajoute un nombre à 2 chiffres à la fin. Exemple : `tigre-nuage-velo-orange-42`.
|
|
3. `evaluer_force(mot_de_passe)` : renvoie un tuple `(score, verdict)` où le score (0 à 5) compte un point pour : longueur ≥ 8, longueur ≥ 12, présence de majuscules, de chiffres, de symboles. Verdict : `"faible"` (0-2), `"moyen"` (3), `"fort"` (4-5).
|
|
4. Un bloc `if __name__ == "__main__":` avec des tests (`assert`).
|
|
|
|
**Le programme `generateur.py`** affiche un menu en boucle :
|
|
|
|
```
|
|
=== Générateur de mots de passe ===
|
|
1. Mot de passe aléatoire
|
|
2. Phrase de passe
|
|
3. Tester la force d'un mot de passe
|
|
4. Voir l'historique de la session
|
|
5. Quitter
|
|
Ton choix :
|
|
```
|
|
|
|
- Le choix 1 demande la longueur et les options (o/n) ; les saisies invalides sont gérées (chapitre 08 !).
|
|
- Les choix 1 et 2 affichent le résultat avec sa force, et l'ajoutent à l'historique avec l'heure (`datetime`).
|
|
- L'historique ne garde que les **5 dernières** générations (`deque`).
|
|
|
|
### Étapes suggérées
|
|
|
|
1. Commence par `mdp_outils.py` et sa fonction `evaluer_force` (la plus simple), avec des `assert` dans le bloc `__main__`. Lance le module seul pour tester.
|
|
2. Écris `generer_mot_de_passe` : construis l'alphabet autorisé avec `string.ascii_lowercase`, `string.ascii_uppercase`, `string.digits`, `string.punctuation`. Tire d'abord **un caractère obligatoire** par catégorie, complète avec des caractères tirés dans l'alphabet complet, puis **mélange** le tout (`secrets.SystemRandom().shuffle`).
|
|
3. Écris `generer_phrase_de_passe`.
|
|
4. Écris `generateur.py` : une fonction par choix du menu, une fonction `demander_entier(message, minimum, maximum)` et une fonction `demander_oui_non(message)`.
|
|
5. Ajoute l'historique avec `deque(maxlen=5)` et `datetime.now().strftime("%H:%M:%S")`.
|
|
|
|
### Pistes d'amélioration
|
|
|
|
- Option « éviter les caractères ambigus » (`l`, `1`, `I`, `O`, `0`).
|
|
- Copier automatiquement le mot de passe dans le presse-papiers (bibliothèque externe `pyperclip`, voir [chapitre 12](12-outils-venv-pip-git.md)).
|
|
- Lire la liste de mots de la phrase de passe dans un fichier texte.
|
|
- Accepter des arguments en ligne de commande (`python generateur.py --longueur 20`) avec le module `argparse`.
|
|
|
|
---
|
|
|
|
## Corrigés
|
|
|
|
<details><summary>Corrigé de l'exercice 1</summary>
|
|
|
|
```python
|
|
import random
|
|
|
|
de1 = random.randint(1, 6)
|
|
de2 = random.randint(1, 6)
|
|
|
|
print(f"Dé 1 : {de1}")
|
|
print(f"Dé 2 : {de2}")
|
|
print(f"Somme : {de1 + de2}")
|
|
if de1 == de2:
|
|
print("Double !")
|
|
```
|
|
|
|
Exemple de sortie (différente à chaque exécution) :
|
|
|
|
```
|
|
Dé 1 : 3
|
|
Dé 2 : 5
|
|
Somme : 8
|
|
```
|
|
|
|
`randint(1, 6)` inclut bien le 1 **et** le 6. Pour tester le cas « Double ! », tu peux temporairement ajouter `random.seed(...)` en essayant plusieurs graines, ou forcer `de2 = de1`.
|
|
|
|
</details>
|
|
|
|
<details><summary>Corrigé de l'exercice 2</summary>
|
|
|
|
```python
|
|
import math
|
|
|
|
|
|
def aire_disque(rayon):
|
|
return math.pi * rayon**2
|
|
|
|
|
|
def hypotenuse(a, b):
|
|
return math.hypot(a, b) # ou math.sqrt(a**2 + b**2)
|
|
|
|
|
|
def nombre_de_dalles(surface_m2, surface_dalle_m2):
|
|
return math.ceil(surface_m2 / surface_dalle_m2)
|
|
|
|
|
|
print(f"{aire_disque(3):.2f}")
|
|
print(hypotenuse(6, 8))
|
|
print(nombre_de_dalles(10.5, 0.36))
|
|
```
|
|
|
|
```
|
|
28.27
|
|
10.0
|
|
30
|
|
```
|
|
|
|
10,5 / 0,36 = 29,17 : avec 29 dalles, il manquerait un morceau, d'où `math.ceil` (arrondi supérieur). `round` aurait donné 29, et `int` aussi.
|
|
|
|
</details>
|
|
|
|
<details><summary>Corrigé de l'exercice 3</summary>
|
|
|
|
```python
|
|
from datetime import date
|
|
|
|
|
|
def jours_avant(jour_cible, aujourd_hui):
|
|
return (jour_cible - aujourd_hui).days
|
|
|
|
|
|
def prochain_anniversaire(naissance, aujourd_hui):
|
|
anniversaire = date(aujourd_hui.year, naissance.month, naissance.day)
|
|
if anniversaire < aujourd_hui: # déjà passé cette année
|
|
anniversaire = date(aujourd_hui.year + 1, naissance.month, naissance.day)
|
|
return jours_avant(anniversaire, aujourd_hui)
|
|
|
|
|
|
aujourd_hui = date(2026, 3, 10)
|
|
print(jours_avant(date(2026, 12, 25), aujourd_hui))
|
|
print(prochain_anniversaire(date(1998, 5, 1), aujourd_hui))
|
|
print(prochain_anniversaire(date(2001, 1, 15), aujourd_hui))
|
|
print(prochain_anniversaire(date(1990, 3, 10), aujourd_hui))
|
|
```
|
|
|
|
```
|
|
290
|
|
52
|
|
311
|
|
0
|
|
```
|
|
|
|
Pourquoi passer `aujourd_hui` en paramètre plutôt que d'appeler `date.today()` dans la fonction ? Pour pouvoir **tester** la fonction avec une date fixe : le résultat est alors toujours le même. Dans le programme réel, on appellera `prochain_anniversaire(naissance, date.today())`. Les dates se comparent directement avec `<`.
|
|
|
|
</details>
|
|
|
|
<details><summary>Corrigé de l'exercice 4</summary>
|
|
|
|
```python
|
|
from collections import Counter
|
|
|
|
|
|
def analyser(texte):
|
|
mots = [mot.strip(".,;:!?").lower() for mot in texte.split()]
|
|
mots = [mot for mot in mots if mot] # retire les « mots » vides (ex : « ! » seul)
|
|
compteur_mots = Counter(mots)
|
|
|
|
lettres = Counter(c for c in texte.lower() if c.isalpha())
|
|
lettre, _ = lettres.most_common(1)[0]
|
|
|
|
top = ", ".join(f"{mot} ({n})" for mot, n in compteur_mots.most_common(3))
|
|
print(f"Mots : {len(mots)}")
|
|
print(f"Mots différents : {len(compteur_mots)}")
|
|
print(f"Top 3 : {top}")
|
|
print(f"Lettre la plus fréquente : {lettre}")
|
|
|
|
|
|
analyser("Le petit chat boit du lait. Le chat dort. Le chien aboie !")
|
|
```
|
|
|
|
```
|
|
Mots : 12
|
|
Mots différents : 9
|
|
Top 3 : le (3), chat (2), petit (1)
|
|
Lettre la plus fréquente : t
|
|
```
|
|
|
|
Le `!` isolé devient une chaîne vide après `strip` : sans le filtre, on compterait 13 « mots ». `len(compteur_mots)` donne le nombre de clés, donc de mots **différents**. `most_common(1)` renvoie une liste contenant un tuple : `[('t', 6)]`, d'où le `[0]` puis le dépaquetage. À égalité, `most_common` garde l'ordre de première apparition (c'est pourquoi `petit` sort avant les autres mots vus une seule fois).
|
|
|
|
</details>
|
|
|
|
<details><summary>Corrigé de l'exercice 5</summary>
|
|
|
|
Fichier `conversions.py` :
|
|
|
|
```python
|
|
"""Fonctions de conversion d'unités."""
|
|
|
|
KM_PAR_MILE = 1.609344
|
|
|
|
|
|
def km_vers_miles(km):
|
|
return km / KM_PAR_MILE
|
|
|
|
|
|
def celsius_vers_fahrenheit(c):
|
|
return c * 9 / 5 + 32
|
|
|
|
|
|
def secondes_vers_hms(secondes):
|
|
heures, reste = divmod(secondes, 3600)
|
|
minutes, secondes = divmod(reste, 60)
|
|
return f"{heures:02d}:{minutes:02d}:{secondes:02d}"
|
|
|
|
|
|
if __name__ == "__main__":
|
|
assert round(km_vers_miles(1.609344), 6) == 1
|
|
assert celsius_vers_fahrenheit(100) == 212
|
|
assert celsius_vers_fahrenheit(-40) == -40
|
|
assert secondes_vers_hms(3661) == "01:01:01"
|
|
assert secondes_vers_hms(0) == "00:00:00"
|
|
print("Tous les tests sont passés.")
|
|
```
|
|
|
|
Fichier `principal.py`, dans le **même dossier** :
|
|
|
|
```python
|
|
import conversions
|
|
|
|
print(f"42.195 km = {conversions.km_vers_miles(42.195):.2f} miles")
|
|
print(f"37 °C = {conversions.celsius_vers_fahrenheit(37):.1f} °F")
|
|
print(f"5000 s = {conversions.secondes_vers_hms(5000)}")
|
|
```
|
|
|
|
`python principal.py` :
|
|
|
|
```
|
|
42.195 km = 26.22 miles
|
|
37 °C = 98.6 °F
|
|
5000 s = 01:23:20
|
|
```
|
|
|
|
`python conversions.py` :
|
|
|
|
```
|
|
Tous les tests sont passés.
|
|
```
|
|
|
|
`divmod(a, b)` renvoie à la fois le quotient et le reste (`a // b`, `a % b`). Le format `:02d` affiche un entier sur 2 chiffres en complétant par des zéros. La constante `KM_PAR_MILE` est en majuscules : c'est la convention pour une valeur qui ne change jamais.
|
|
|
|
</details>
|
|
|
|
<details><summary>Corrigé de l'exercice 6</summary>
|
|
|
|
```python
|
|
from collections import defaultdict
|
|
|
|
|
|
def regrouper_par_initiale(noms):
|
|
groupes = defaultdict(list)
|
|
for nom in noms:
|
|
nom = nom.capitalize()
|
|
groupes[nom[0]].append(nom)
|
|
return {initiale: sorted(groupes[initiale]) for initiale in sorted(groupes)}
|
|
|
|
|
|
noms = ["léa", "Hugo", "lucas", "Emma", "hugo", "Inès", "Ethan", "Louise"]
|
|
print(regrouper_par_initiale(noms))
|
|
```
|
|
|
|
```
|
|
{'E': ['Emma', 'Ethan'], 'H': ['Hugo', 'Hugo'], 'I': ['Inès'], 'L': ['Louise', 'Lucas', 'Léa']}
|
|
```
|
|
|
|
La compréhension de dictionnaire finale ([chapitre 06](06-chaines-et-comprehensions.md)) trie à la fois les clés et chaque liste, et transforme le `defaultdict` en `dict` ordinaire. Remarque que `Léa` arrive **après** `Lucas` : le tri compare les codes des caractères, et `é` a un code plus grand que toutes les lettres non accentuées. Trier « à la française » demanderait le module `locale` ou une clé de tri qui retire les accents.
|
|
|
|
</details>
|
|
|
|
<details><summary>Corrigé de l'exercice 7</summary>
|
|
|
|
```python
|
|
import random
|
|
from collections import Counter
|
|
|
|
NOMBRE_LANCERS = 10_000
|
|
LANCERS_PAR_DIESE = 50
|
|
|
|
random.seed(42)
|
|
sommes = Counter(
|
|
random.randint(1, 6) + random.randint(1, 6) for _ in range(NOMBRE_LANCERS)
|
|
)
|
|
|
|
for somme in range(2, 13):
|
|
nombre = sommes[somme]
|
|
pourcentage = nombre / NOMBRE_LANCERS * 100
|
|
barre = "#" * (nombre // LANCERS_PAR_DIESE)
|
|
print(f"{somme:2} : {pourcentage:5.1f} % {barre}")
|
|
```
|
|
|
|
```
|
|
2 : 2.7 % #####
|
|
3 : 5.4 % ##########
|
|
4 : 8.2 % ################
|
|
5 : 10.9 % #####################
|
|
6 : 13.6 % ###########################
|
|
7 : 17.0 % ##################################
|
|
8 : 13.9 % ###########################
|
|
9 : 11.2 % ######################
|
|
10 : 8.4 % ################
|
|
11 : 5.6 % ###########
|
|
12 : 3.1 % ######
|
|
```
|
|
|
|
On parcourt `range(2, 13)` plutôt que le `Counter` directement, pour avoir les sommes **dans l'ordre**. `{somme:2}` aligne à droite sur 2 caractères, `{pourcentage:5.1f}` sur 5 caractères avec 1 décimale.
|
|
|
|
**Bonus** : il y a 36 combinaisons possibles de deux dés. Le 7 s'obtient de 6 façons (1+6, 2+5, 3+4, 4+3, 5+2, 6+1), soit 6/36 ≈ 16,7 %, alors que le 2 ne s'obtient que d'une façon (1+1), soit 1/36 ≈ 2,8 %. La simulation retrouve bien ces valeurs théoriques.
|
|
|
|
</details>
|
|
|
|
<details><summary>Corrigé de l'exercice 8</summary>
|
|
|
|
```python
|
|
"""Compte les lignes et les mots d'un fichier texte."""
|
|
|
|
import sys
|
|
from collections import Counter
|
|
from pathlib import Path
|
|
|
|
PONCTUATION = ".,;:!?\"'()"
|
|
|
|
|
|
def compter_mots(texte):
|
|
mots = (mot.strip(PONCTUATION).lower() for mot in texte.split())
|
|
return Counter(mot for mot in mots if mot)
|
|
|
|
|
|
def main():
|
|
if len(sys.argv) < 2:
|
|
print("Usage : python compter.py FICHIER [NOMBRE]")
|
|
sys.exit(1)
|
|
|
|
chemin = Path(sys.argv[1])
|
|
nombre = 5
|
|
if len(sys.argv) >= 3:
|
|
try:
|
|
nombre = int(sys.argv[2])
|
|
except ValueError:
|
|
print(f"Erreur : {sys.argv[2]!r} n'est pas un nombre entier.")
|
|
sys.exit(1)
|
|
|
|
try:
|
|
texte = chemin.read_text(encoding="utf-8")
|
|
except FileNotFoundError:
|
|
print(f"Erreur : le fichier '{chemin}' n'existe pas.")
|
|
sys.exit(1)
|
|
|
|
compteur = compter_mots(texte)
|
|
nb_lignes = len(texte.splitlines())
|
|
nb_mots = compteur.total()
|
|
print(f"{chemin.name} : {nb_lignes} lignes, {nb_mots} mots")
|
|
print(f"Les {nombre} mots les plus fréquents :")
|
|
for mot, occurrences in compteur.most_common(nombre):
|
|
print(f" {mot} : {occurrences}")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|
|
```
|
|
|
|
```
|
|
$ python compter.py
|
|
Usage : python compter.py FICHIER [NOMBRE]
|
|
$ python compter.py absent.txt
|
|
Erreur : le fichier 'absent.txt' n'existe pas.
|
|
$ python compter.py poeme.txt trois
|
|
Erreur : 'trois' n'est pas un nombre entier.
|
|
$ python compter.py poeme.txt 3
|
|
poeme.txt : 6 lignes, 26 mots
|
|
Les 3 mots les plus fréquents :
|
|
la : 4
|
|
mer : 3
|
|
le : 2
|
|
```
|
|
|
|
`Counter.total()` (Python 3.10+) renvoie la somme de tous les compteurs, c'est-à-dire le nombre total de mots. `le` et `et` apparaissent tous deux 2 fois : à égalité, `most_common` garde l'ordre de première apparition, donc `le` (ligne 2) passe avant `et` (ligne 3). Attention : `s'endort` reste un seul mot, car l'apostrophe n'est retirée qu'aux extrémités. Les messages d'erreur et `sys.exit(1)` permettent à d'autres scripts de savoir que quelque chose s'est mal passé.
|
|
|
|
</details>
|
|
|
|
<details><summary>Corrigé du mini-projet</summary>
|
|
|
|
Fichier `mdp_outils.py` :
|
|
|
|
```python
|
|
"""Outils de génération et d'évaluation de mots de passe."""
|
|
|
|
import secrets
|
|
import string
|
|
|
|
MOTS = [
|
|
"tigre", "nuage", "velo", "orange", "piano", "cactus", "fusee", "galaxie",
|
|
"pirate", "volcan", "biscuit", "dragon", "lune", "marmotte", "tornade",
|
|
"citron", "baleine", "chateau", "domino", "glacier", "hibou", "jungle",
|
|
"kayak", "licorne", "mangue", "neige", "olive", "pingouin", "requin", "tulipe",
|
|
]
|
|
|
|
_aleatoire = secrets.SystemRandom() # générateur sécurisé, avec les méthodes de random
|
|
|
|
|
|
def generer_mot_de_passe(longueur=12, majuscules=True, chiffres=True, symboles=True):
|
|
"""Renvoie un mot de passe aléatoire sécurisé.
|
|
|
|
Il contient toujours des minuscules, et au moins un caractère
|
|
de chaque catégorie demandée.
|
|
"""
|
|
categories = [string.ascii_lowercase]
|
|
if majuscules:
|
|
categories.append(string.ascii_uppercase)
|
|
if chiffres:
|
|
categories.append(string.digits)
|
|
if symboles:
|
|
categories.append(string.punctuation)
|
|
|
|
if longueur < max(4, len(categories)):
|
|
raise ValueError(f"longueur trop courte : {longueur} (minimum 4)")
|
|
|
|
alphabet = "".join(categories)
|
|
caracteres = [secrets.choice(categorie) for categorie in categories]
|
|
caracteres += [secrets.choice(alphabet) for _ in range(longueur - len(caracteres))]
|
|
_aleatoire.shuffle(caracteres) # sinon les caractères obligatoires seraient au début
|
|
return "".join(caracteres)
|
|
|
|
|
|
def generer_phrase_de_passe(nombre_mots=4, separateur="-"):
|
|
"""Renvoie une phrase de passe du type tigre-nuage-velo-orange-42."""
|
|
mots = [secrets.choice(MOTS) for _ in range(nombre_mots)]
|
|
nombre = secrets.randbelow(90) + 10 # entre 10 et 99
|
|
return separateur.join(mots) + separateur + str(nombre)
|
|
|
|
|
|
def evaluer_force(mot_de_passe):
|
|
"""Renvoie (score sur 5, verdict)."""
|
|
criteres = [
|
|
len(mot_de_passe) >= 8,
|
|
len(mot_de_passe) >= 12,
|
|
any(c.isupper() for c in mot_de_passe),
|
|
any(c.isdigit() for c in mot_de_passe),
|
|
any(c in string.punctuation for c in mot_de_passe),
|
|
]
|
|
score = sum(criteres) # True compte pour 1, False pour 0
|
|
if score <= 2:
|
|
verdict = "faible"
|
|
elif score == 3:
|
|
verdict = "moyen"
|
|
else:
|
|
verdict = "fort"
|
|
return score, verdict
|
|
|
|
|
|
if __name__ == "__main__":
|
|
assert evaluer_force("abc") == (0, "faible")
|
|
assert evaluer_force("Abcdefgh1") == (3, "moyen")
|
|
assert evaluer_force("Abcdefgh1!xyz") == (5, "fort")
|
|
|
|
for _ in range(100):
|
|
mdp = generer_mot_de_passe(10)
|
|
assert len(mdp) == 10
|
|
assert any(c.isupper() for c in mdp)
|
|
assert any(c.isdigit() for c in mdp)
|
|
assert any(c in string.punctuation for c in mdp)
|
|
|
|
mdp = generer_mot_de_passe(6, majuscules=False, chiffres=False, symboles=False)
|
|
assert mdp.islower() and len(mdp) == 6
|
|
|
|
try:
|
|
generer_mot_de_passe(3)
|
|
except ValueError:
|
|
pass
|
|
else:
|
|
raise AssertionError("une ValueError était attendue")
|
|
|
|
phrase = generer_phrase_de_passe(3, "_")
|
|
assert phrase.count("_") == 3
|
|
print("mdp_outils : tous les tests sont passés.")
|
|
print("Exemple :", generer_mot_de_passe(), "/", generer_phrase_de_passe())
|
|
```
|
|
|
|
Fichier `generateur.py` :
|
|
|
|
```python
|
|
"""Menu interactif de génération de mots de passe."""
|
|
|
|
from collections import deque
|
|
from datetime import datetime
|
|
|
|
import mdp_outils
|
|
|
|
historique = deque(maxlen=5)
|
|
|
|
|
|
def demander_entier(message, minimum, maximum):
|
|
while True:
|
|
try:
|
|
valeur = int(input(message))
|
|
except ValueError:
|
|
print("Merci d'entrer un nombre entier.")
|
|
continue
|
|
if minimum <= valeur <= maximum:
|
|
return valeur
|
|
print(f"Le nombre doit être entre {minimum} et {maximum}.")
|
|
|
|
|
|
def demander_oui_non(message):
|
|
while True:
|
|
reponse = input(f"{message} (o/n) : ").strip().lower()
|
|
if reponse in ("o", "oui"):
|
|
return True
|
|
if reponse in ("n", "non"):
|
|
return False
|
|
print("Réponds par o ou n.")
|
|
|
|
|
|
def afficher_et_memoriser(secret):
|
|
score, verdict = mdp_outils.evaluer_force(secret)
|
|
print(f"\n → {secret} (force : {verdict}, {score}/5)\n")
|
|
heure = datetime.now().strftime("%H:%M:%S")
|
|
historique.append(f"[{heure}] {secret}")
|
|
|
|
|
|
def choix_mot_de_passe():
|
|
longueur = demander_entier("Longueur (4 à 64) : ", 4, 64)
|
|
majuscules = demander_oui_non("Majuscules ?")
|
|
chiffres = demander_oui_non("Chiffres ?")
|
|
symboles = demander_oui_non("Symboles ?")
|
|
secret = mdp_outils.generer_mot_de_passe(longueur, majuscules, chiffres, symboles)
|
|
afficher_et_memoriser(secret)
|
|
|
|
|
|
def choix_phrase():
|
|
nombre_mots = demander_entier("Nombre de mots (3 à 8) : ", 3, 8)
|
|
afficher_et_memoriser(mdp_outils.generer_phrase_de_passe(nombre_mots))
|
|
|
|
|
|
def choix_tester():
|
|
mot_de_passe = input("Mot de passe à tester : ")
|
|
score, verdict = mdp_outils.evaluer_force(mot_de_passe)
|
|
print(f"Force : {verdict} ({score}/5)")
|
|
|
|
|
|
def choix_historique():
|
|
if not historique:
|
|
print("Aucune génération pour l'instant.")
|
|
for ligne in historique:
|
|
print(ligne)
|
|
|
|
|
|
def main():
|
|
actions = {
|
|
"1": choix_mot_de_passe,
|
|
"2": choix_phrase,
|
|
"3": choix_tester,
|
|
"4": choix_historique,
|
|
}
|
|
while True:
|
|
print("=== Générateur de mots de passe ===")
|
|
print("1. Mot de passe aléatoire")
|
|
print("2. Phrase de passe")
|
|
print("3. Tester la force d'un mot de passe")
|
|
print("4. Voir l'historique de la session")
|
|
print("5. Quitter")
|
|
choix = input("Ton choix : ").strip()
|
|
if choix == "5":
|
|
print("À bientôt !")
|
|
break
|
|
action = actions.get(choix)
|
|
if action is None:
|
|
print("Choix invalide.")
|
|
else:
|
|
action()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|
|
```
|
|
|
|
Exemple de session (les mots de passe changent à chaque exécution) :
|
|
|
|
```
|
|
=== Générateur de mots de passe ===
|
|
1. Mot de passe aléatoire
|
|
2. Phrase de passe
|
|
3. Tester la force d'un mot de passe
|
|
4. Voir l'historique de la session
|
|
5. Quitter
|
|
Ton choix : 1
|
|
Longueur (4 à 64) : 2
|
|
Le nombre doit être entre 4 et 64.
|
|
Longueur (4 à 64) : 16
|
|
Majuscules ? (o/n) : o
|
|
Chiffres ? (o/n) : peut-être
|
|
Réponds par o ou n.
|
|
Chiffres ? (o/n) : o
|
|
Symboles ? (o/n) : n
|
|
|
|
→ uJbMEcdEOm7yrS9X (force : fort, 4/5)
|
|
|
|
=== Générateur de mots de passe ===
|
|
...
|
|
Ton choix : 3
|
|
Mot de passe à tester : soleil
|
|
Force : faible (0/5)
|
|
...
|
|
Ton choix : 4
|
|
[14:02:31] uJbMEcdEOm7yrS9X
|
|
...
|
|
Ton choix : 5
|
|
À bientôt !
|
|
```
|
|
|
|
Points importants :
|
|
|
|
- **Séparation des rôles** : `mdp_outils.py` ne fait **aucun** `print` ni `input` (hors tests). Il est donc réutilisable dans un autre programme, une application web, des tests… `generateur.py` ne s'occupe que du dialogue avec l'utilisateur.
|
|
- Le **dictionnaire de fonctions** `actions` évite une longue chaîne de `if/elif` : les fonctions sont des valeurs comme les autres, qu'on peut ranger dans un dictionnaire puis appeler avec `action()`.
|
|
- `secrets.SystemRandom()` donne accès aux méthodes habituelles de `random` (comme `shuffle`), mais avec la source de hasard sécurisée du système.
|
|
- `sum(criteres)` fonctionne car `True` vaut 1 et `False` vaut 0.
|
|
- `deque(maxlen=5)` oublie automatiquement les générations les plus anciennes.
|
|
- La variable `_aleatoire` commence par un tiret bas : c'est la convention pour dire « usage interne au module, ne pas l'utiliser de l'extérieur ».
|
|
|
|
</details>
|
|
|
|
---
|
|
|
|
## Récapitulatif
|
|
|
|
- Un **module** est un fichier `.py` ; un **paquet** est un dossier de modules (avec un `__init__.py`). La **bibliothèque standard** est l'ensemble des modules livrés avec Python.
|
|
- `import module` puis `module.nom` (forme par défaut) ; `from module import nom` pour quelques noms fréquents ; `as` pour un alias ; jamais `import *`.
|
|
- Python cherche les modules **d'abord dans le dossier du script** : ne nomme jamais un fichier comme un module existant (`random.py`, `math.py`…).
|
|
- Un module est exécuté **une fois**, au premier import. Le code de test se place sous `if __name__ == "__main__":`, souvent dans une fonction `main()`.
|
|
- `random` : `randint` (bornes incluses), `choice`, `choices`, `sample`, `shuffle` (sur place), `seed`. Pour la sécurité : `secrets`.
|
|
- `math` : `sqrt`, `pi`, `floor`, `ceil`, `hypot`, `isclose`… et `statistics` pour moyenne, médiane, écart-type.
|
|
- `datetime` : `date`, `datetime`, `timedelta` ; `strftime` (date → texte), `strptime` (texte → date), `isoformat` / `fromisoformat`.
|
|
- `os` (variables d'environnement, système), `sys` (`argv`, `exit`, `path`) ; préfère `pathlib` pour les fichiers.
|
|
- `collections` : `Counter` (compter), `defaultdict` (regrouper), `namedtuple` (tuples nommés), `deque` (file, historique limité).
|
|
- Pour explorer : `dir()`, `help()`, et la documentation officielle <https://docs.python.org/fr/3/library/>.
|
|
|
|
### Checklist de validation
|
|
|
|
- [ ] Je connais les différentes façons d'importer et je sais laquelle utiliser par défaut.
|
|
- [ ] J'ai créé un module à moi et je l'ai importé depuis un autre fichier.
|
|
- [ ] Je sais expliquer à quoi sert `if __name__ == "__main__":`.
|
|
- [ ] Je sais tirer un nombre au hasard, piocher dans une liste et rendre le hasard reproductible.
|
|
- [ ] Je sais calculer le nombre de jours entre deux dates et formater une date en `JJ/MM/AAAA`.
|
|
- [ ] Je sais compter des éléments avec `Counter` et regrouper avec `defaultdict`.
|
|
- [ ] Je sais lire les arguments de la ligne de commande avec `sys.argv`.
|
|
- [ ] Je sais pourquoi mon fichier ne doit jamais s'appeler `random.py`.
|
|
|
|
---
|
|
|
|
[← Chapitre précédent](08-erreurs-et-debogage.md) | [Sommaire](README.md) | [Chapitre suivant →](10-poo-classes-objets.md)
|