Modules et importation en Python

Importer un module

import

Un module est un fichier Python qui contient des fonctions, des classes, des constantes. import les rend disponibles dans ton programme.

import math

Importer le module entier (recommandé)

import math as m

Importer sous un alias

from math import sqrt

Importer des noms précis (recommandé)

from math import sqrt, pi

Plusieurs noms d'un même module

from math import *

Tout importer (déconseillé)

import os, sys

Plusieurs modules (une ligne par module est plus lisible)

import_base.py

import math
from math import sqrt, pi
import statistics as st

print(math.floor(3.7), sqrt(16), round(pi, 3))
print(st.mean([1, 2, 3, 4]))

Affichage

3 4.0 3.142
2.5

Bibliothèque standard et tierces

pip

La bibliothèque standard est livrée avec Python (rien à installer) ; les bibliothèques tierces s'installent avec pip.

import math, random, time

Standard : calcul, hasard, temps

import datetime, json, re, collections

Standard : dates, JSON, expressions régulières, structures

pip install numpy

Installer une bibliothèque tierce (dans un terminal)

import numpy as np

Alias de convention : np, pd, plt

python -m venv .venv

Environnement virtuel : isole les dépendances d'un projet

from mon_module import saluer

Importer l'un de ses propres fichiers

exemple.py

import math
from collections import Counter

print(math.sqrt(16))
print(Counter("abracadabra").most_common(2))

Affichage

4.0
[('a', 5), ('b', 2)]

✓ Bonne pratique

Crée un environnement virtuel (python -m venv .venv) pour chaque projet : ses bibliothèques restent séparées de celles des autres.

📦 Le cours : modules et importation

Un programme de quelques lignes tient dans un seul fichier. Dès qu'il grandit, on le découpe en modules : des fichiers .py que l'on importe les uns dans les autres. Python fournit aussi des centaines de modules prêts à l'emploi (sa bibliothèque standard) : « batteries included ». Savoir importer, c'est ne plus rien réécrire de ce qui existe déjà.

Mot	Signification	Exemple
module	un fichier `.py` qui définit des noms (fonctions, classes, constantes)	`math`, `mon_module.py`
paquet (package)	un dossier de modules qui contient un fichier `__init__.py`	`urllib.request`
bibliothèque	un ensemble de modules et de paquets distribué ensemble	`numpy`, la bibliothèque standard
espace de noms	l'ensemble des noms accessibles : chaque module a le sien	`math.pi` ≠ `pi`

Les formes de l'import

Instruction	Ce qu'elle fait	Appel
`import math`	charge le module et ajoute le nom `math`	`math.sqrt(2)`
`import math as m`	même chose, avec un nom plus court	`m.sqrt(2)`
`from math import sqrt`	n'ajoute que le nom `sqrt`	`sqrt(2)`
`from math import sqrt as racine`	importe `sqrt` sous un autre nom	`racine(2)`
`from math import *`	ajoute tous les noms publics du module (à éviter)	`sqrt(2)`

formes.py

import math
import math as m
from math import sqrt
from math import sqrt as racine, pi

print(math.sqrt(9), m.sqrt(9), sqrt(9), racine(9))
print(round(pi, 4), math.pi == m.pi)

Affichage

3.0 3.0 3.0 3.0
3.1416 True

Une instruction import n'est exécutée qu'une seule fois : Python charge le module, l'enregistre dans sys.modules, et les imports suivants réutilisent cet objet. Un module est lui-même un objet : on peut l'explorer avec dir(module) et help(module).

module_objet.py

import sys
import math

print(type(math).__name__, math.__name__)
print("sqrt" in dir(math), callable(math.sqrt), math.pi > 3)
print(type(sys.path).__name__, len(sys.path) > 0)
print("math" in sys.modules, sys.modules["math"] is math)

Affichage

module math
True True True
list True
True True

Où Python cherche-t-il les modules ?

Quand on écrit import nom, Python regarde dans l'ordre : les modules déjà chargés (sys.modules), puis les dossiers de la liste sys.path : le dossier du script, ceux de la bibliothèque standard, ceux des bibliothèques installées. Il prend le premier qui convient : c'est pourquoi un fichier à toi qui s'appelle random.py ou math.py masque le vrai module (voir les erreurs fréquentes).

Un tour de la bibliothèque standard

Quelques modules qui reviennent sans cesse. La référence détaillée de chacun est en bas de page.

math_stats.py

import math
import statistics

print(math.sqrt(2), math.floor(-2.5), math.ceil(2.1))
print(math.gcd(12, 18), math.factorial(5), math.comb(5, 2))
print(round(math.sin(math.pi / 2), 3), round(math.log(math.e), 3), math.hypot(3, 4))
print(math.isclose(0.1 + 0.2, 0.3), math.inf > 10 ** 100)

notes = [12, 15, 9, 14, 15]
print(statistics.mean(notes), statistics.median(notes), statistics.mode(notes))
print(round(statistics.stdev(notes), 2))

Affichage

1.4142135623730951 -3 3
6 120 10
1.0 1.0 5.0
True True
13 14 15
2.55

collections_itertools.py

from collections import Counter, defaultdict, deque
from itertools import permutations, combinations, product

print(Counter("abracadabra").most_common(2))
groupes = defaultdict(list)
for mot in ["chat", "chien", "oiseau", "cheval"]:
    groupes[mot[0]].append(mot)
print(dict(groupes))
file = deque([1, 2, 3])
file.append(4)
print(file.popleft(), list(file))

print(list(permutations("ABC", 2))[:3], len(list(permutations("ABC"))))
print(list(combinations([1, 2, 3], 2)))
print(list(product([0, 1], repeat=2)))

Affichage

[('a', 5), ('b', 2)]
{'c': ['chat', 'chien', 'cheval'], 'o': ['oiseau']}
1 [2, 3, 4]
[('A', 'B'), ('A', 'C'), ('B', 'A')] 6
[(1, 2), (1, 3), (2, 3)]
[(0, 0), (0, 1), (1, 0), (1, 1)]

dates_json_re.py

from datetime import date, timedelta
import json
import re

jour = date(2026, 10, 4)
print(jour.year, jour.weekday(), jour.strftime("%d/%m/%Y"))
print(jour + timedelta(days=30), (date(2026, 12, 25) - jour).days)

eleve = {"nom": "Ada", "notes": [18, 15], "actif": True, "note_finale": None}
texte = json.dumps(eleve)
print(texte)
print(json.loads(texte)["notes"][1])

contacts = "Contact : ada@exemple.fr ou lin@test.org"
print(re.findall(r"[\w.]+@[\w.]+\.\w+", contacts))
print(re.search(r"(\d+)h(\d+)", "RDV à 14h30").groups())

Affichage

2026 6 04/10/2026
2026-11-03 82
{"nom": "Ada", "notes": [18, 15], "actif": true, "note_finale": null}
15
['ada@exemple.fr', 'lin@test.org']
('14', '30')

Le hasard et le temps donnent des résultats différents à chaque exécution. On fixe la graine avec random.seed(n) pour rendre une suite de tirages reproductible (utile pour tester). time.perf_counter() sert à mesurer la durée d'un calcul.

hasard_temps.py

import random
import time

random.seed(7)
de = random.randint(1, 6)
couleur = random.choice(["rouge", "vert", "bleu"])
mots = ["a", "b", "c", "d"]
random.shuffle(mots)
debut = time.perf_counter()
duree = time.perf_counter() - debut
print(1 <= de <= 6, couleur in ["rouge", "vert", "bleu"], sorted(mots), duree >= 0)

Affichage

True True ['a', 'b', 'c', 'd'] True

chemins.py

import os

chemin = "/home/eleve/rapport.final.pdf"
print(os.path.basename(chemin), os.path.dirname(chemin))
print(os.path.splitext(chemin))
print(os.path.exists("fichier_introuvable.txt"))

Affichage

rapport.final.pdf /home/eleve
('/home/eleve/rapport.final', '.pdf')
False

Écrire et importer son propre module

Tout fichier Python est un module : son nom de fichier (sans .py) est le nom à importer. Il suffit que les deux fichiers soient dans le même dossier. Les noms qui commencent par _ sont considérés comme internes au module.

mon_module.py

PI = 3.14159

def aire_disque(rayon):
    return PI * rayon ** 2

def _outil_interne(x):
    return x * 2

if __name__ == "__main__":
    print("test :", aire_disque(1))

main.py

import mon_module
from mon_module import aire_disque

print(mon_module.PI)
print(aire_disque(2))

En lançant main.py

3.14159
12.56636

Quand on lance un fichier directement (python mon_module.py), Python met __name__ à "__main__" ; quand le même fichier est importé, __name__ vaut son nom ("mon_module"). Le bloc if __name__ == "__main__": ne s'exécute donc que lors d'un lancement direct : il sert à ranger des tests ou un petit programme de démonstration dans un module, sans qu'ils se déclenchent à chaque import.

Les paquets : des dossiers de modules

Un dossier qui contient un fichier __init__.py (même vide) est un paquet : on importe ses modules avec des points. À l'intérieur d'un paquet, un import relatif (from . import carre, from .cercle import aire) désigne un module voisin sans répéter le nom du paquet.

mon_projet/
├── main.py
└── geometrie/
    ├── __init__.py
    ├── cercle.py
    └── carre.py

main.py

from geometrie.cercle import aire
from geometrie import carre

print(aire(2), carre.aire(3))

Installer des bibliothèques avec pip

pip est l'installateur de bibliothèques tierces (il se tape dans un terminal, pas dans Python). Un environnement virtuel isole les bibliothèques d'un projet, et requirements.txt garde la liste des versions pour pouvoir tout réinstaller ailleurs.

pip install numpy                  installer une bibliothèque
pip install numpy==1.26.4          une version précise
pip list                           bibliothèques installées
pip freeze > requirements.txt      noter les versions utilisées
pip install -r requirements.txt    tout réinstaller

python -m venv .venv               créer un environnement virtuel
.venv\Scripts\activate             l'activer (Windows)
source .venv/bin/activate          l'activer (Linux, macOS)

Bibliothèque	Usage	Import usuel
`numpy`	calcul numérique, tableaux	`import numpy as np`
`pandas`	données tabulaires, analyse	`import pandas as pd`
`matplotlib`	graphiques et visualisation	`import matplotlib.pyplot as plt`
`requests`	requêtes HTTP (API, pages web)	`import requests`
`pygame`	jeux 2D	`import pygame`
`flask`	sites web et API	`from flask import Flask`

Les alias np, pd et plt sont des conventions que toute la communauté Python respecte : les suivre rend ton code immédiatement lisible.

Bonnes pratiques d'import

Place tous les import en haut du fichier, regroupés : d'abord la bibliothèque standard, puis les bibliothèques tierces, puis tes propres modules.
Un import par ligne pour la lisibilité ; jamais from module import * dans un vrai programme (on ne sait plus d'où vient chaque nom).
Importe seulement ce qui sert, et préfère des alias courts et conventionnels.
Évite les imports circulaires (A importe B qui importe A) : réorganise le code pour qu'une des deux dépendances disparaisse.

⚠️ Erreurs fréquentes

ModuleNotFoundError : le module est introuvable

Trois causes principales : une faute de frappe dans le nom, une bibliothèque tierce pas installée (pip install ...), ou un pip qui a installé la bibliothèque dans un autre Python/environnement que celui qui exécute ton programme.

introuvable.py

import modulequinexistepas

Erreur

ModuleNotFoundError: No module named 'modulequinexistepas'

Oublier le préfixe du module

Après import math, la fonction s'appelle math.sqrt, pas sqrt. Pour utiliser sqrt seul, écris from math import sqrt.

À éviter

faux.py

import math

print(sqrt(16))

Erreur

NameError: name 'sqrt' is not defined

Correct

correct.py

import math

print(math.sqrt(16))

Affichage

4.0

from module import * : les noms se télescopent

from math import * apporte la fonction math.pow, qui remplace la fonction intégrée pow : le programme change de comportement sans que rien ne l'indique dans le code. Avec import math, chaque nom reste à sa place.

À éviter

faux.py

from math import *

print(pow(2, 10, 1000))

Erreur

TypeError: pow expected 2 arguments, got 3

Correct

correct.py

import math

print(pow(2, 10, 1000), math.pow(2, 10))

Affichage

24 1024.0

Donner à son fichier le nom d'un module existant

Le dossier du script est le premier endroit où Python cherche : un fichier random.py, math.py, json.py ou test.py dans ton projet est importé à la place du vrai module. Les symptômes sont étranges (AttributeError: partially initialized module 'random' has no attribute 'randint'). Choisis des noms qui ne ressemblent à aucun module standard.

À éviter

random.py

import random

print(random.randint(1, 6))

Correct

tirage.py

import random

print(random.randint(1, 6))

randint ou randrange ?

random.randint(1, 3) peut donner 3 (bornes incluses), alors que random.randrange(1, 3) s'arrête avant 3, comme range.

bornes.py

import random

random.seed(1)
avec_randint = {random.randint(1, 3) for _ in range(200)}
avec_randrange = {random.randrange(1, 3) for _ in range(200)}
print(sorted(avec_randint), sorted(avec_randrange))

Affichage

[1, 2, 3] [1, 2]

L'import relatif d'un script lancé directement

from . import carre n'a de sens que dans un paquet importé : si tu lances le fichier directement avec python carre.py, Python répond ImportError: attempted relative import with no known parent package. Lance ton programme depuis le fichier principal du projet, ou avec python -m paquet.module.

Un import circulaire

Si a.py fait import b et que b.py fait import a, l'un des deux est importé avant d'être entièrement chargé : certains noms n'existent pas encore (ImportError, AttributeError). La solution est d'extraire ce qu'ils partagent dans un troisième module, ou d'importer à l'intérieur de la fonction qui en a besoin.

Modifier un module sans le recharger

Un module n'est exécuté qu'une fois par programme : si tu modifies son fichier pendant que Python tourne (console, notebook), l'ancienne version reste en mémoire. Redémarre l'interpréteur, ou appelle importlib.reload(module).

Un module qui marche chez toi et pas ailleurs

Le programme dépend peut-être d'une bibliothèque installée seulement sur ton poste. Note les dépendances dans un fichier requirements.txt (pip freeze > requirements.txt) et fournis-le avec ton projet.

📋 Aide-mémoire

Besoin	Syntaxe
Importer un module	`import math` puis `math.sqrt(2)`
Avec un alias	`import numpy as np`
Des noms précis	`from math import sqrt, pi`
Renommer un nom importé	`from math import sqrt as racine`
Un module à soi	`mon_module.py` dans le même dossier, puis `import mon_module`
Un paquet	dossier avec `__init__.py` : `from geometrie.cercle import aire`
Lancement direct seulement	`if __name__ == "__main__":`
Explorer un module	`dir(module)` `help(module)` `module.__name__`
Recharger	`import importlib` puis `importlib.reload(module)`
Installer (terminal)	`pip install nom` `pip list` `pip freeze > requirements.txt` `pip install -r requirements.txt`
Environnement virtuel	`python -m venv .venv` puis l'activer

Imports en haut du fichier : standard, tiers, puis locaux ; jamais d'import * dans un vrai programme.
Un fichier à soi ne doit pas porter le nom d'un module standard (random.py, math.py, json.py…).
Une bibliothèque tierce s'installe avec pip dans le bon environnement ; requirements.txt garde la liste.

📚 Référence par bibliothèque

Chaque module est replié par défaut : clique sur son titre pour afficher ses fonctions (math, random, datetime, re, json, turtle, tkinter…).

🔢 Module math

Fonctions mathématiques - le module math fournit les fonctions et constantes mathématiques usuelles.

import math - Importer le module

math.pi - Constante π (3.14159…)

math.e - Constante e (2.71828…)

math.inf - Infini positif

math.sqrt(16) - Racine carrée (renvoie un décimal)

math.pow(2, 3) - 2 puissance 3, en décimal

math.exp(2) - Exponentielle : e² (7.389…)

math.log(math.e) - Logarithme népérien

math.log2(8) - Logarithme en base 2

math.log10(100) - Logarithme en base 10

math.sin(math.pi / 2) - Sinus (en radians)

math.cos(0) - Cosinus (en radians)

round(math.tan(math.pi / 4), 6) - Tangente : le résultat brut vaut 0.9999999999999999, d'où l'arrondi

math.asin(1) - Arc sinus (π/2)

math.acos(1) - Arc cosinus

math.atan(1) - Arc tangente (π/4)

math.degrees(math.pi) - Radians vers degrés

math.radians(180) - Degrés vers radians (π)

math.floor(-2.5) - Arrondi vers le bas

math.ceil(2.1) - Arrondi vers le haut

math.trunc(-2.7) - Partie entière (vers zéro)

math.fabs(-5) - Valeur absolue, en décimal

math.factorial(5) - Factorielle

math.gcd(12, 8) - PGCD

math.lcm(4, 6) - PPCM (Python 3.9+)

math.hypot(3, 4) - Hypoténuse (distance à l'origine)

math.isclose(0.1 + 0.2, 0.3) - Égalité à une petite tolérance près

math.isfinite(1.0) - Le nombre est fini ?

math.isinf(float('inf')) - Le nombre est infini ?

math.isnan(float('nan')) - Le nombre est NaN (« pas un nombre ») ?

math.comb(5, 2) - Combinaisons : « 2 parmi 5 »

math.perm(5, 2) - Arrangements de 2 parmi 5

🎲 Module random

Nombres pseudo-aléatoires - les résultats changent à chaque exécution, sauf si on fixe la graine avec random.seed.

import random - Importer le module

random.random() - Décimal dans [0, 1)

random.randint(1, 10) - Entier entre 1 et 10, bornes incluses

random.randrange(0, 10, 2) - Entier de range(0, 10, 2) : la borne de fin est exclue

random.uniform(1.0, 10.0) - Décimal entre 1.0 et 10.0

random.choice(['a', 'b', 'c']) - Un élément au hasard

random.choices(['a', 'b'], k=3) - 3 éléments avec remise (doublons possibles)

random.sample(['a', 'b', 'c'], 2) - 2 éléments distincts (sans remise)

random.shuffle(liste) - Mélanger une liste, en place

random.seed(42) - Fixer la graine : la suite de tirages devient reproductible

random.getrandbits(4) - Entier aléatoire de 4 bits (0 à 15)

random.gauss(0, 1) - Tirage selon une loi normale (moyenne, écart-type)

random.triangular(0, 1) - Loi triangulaire

random.expovariate(1.5) - Loi exponentielle

⏱️ Module time

Mesure du temps - horloge, pauses, durées.

import time - Importer le module

time.time() - Secondes écoulées depuis le 1er janvier 1970 (époque Unix)

time.sleep(2) - Pause de 2 secondes

time.perf_counter() - Compteur de haute précision pour mesurer une durée

time.monotonic() - Horloge qui ne revient jamais en arrière

time.process_time() - Temps CPU consommé par le processus

time.ctime() - Date et heure actuelles sous forme de texte lisible

time.localtime() - Date et heure locales (struct_time)

time.gmtime() - Date et heure UTC (struct_time)

time.mktime(t) - Convertir un struct_time local en secondes Unix

time.strftime('%Y-%m-%d') - Formater la date actuelle selon un modèle

time.strptime('2024-01-01', '%Y-%m-%d') - Lire une date écrite dans un texte

time.timezone - Décalage du fuseau horaire, en secondes

time.tzname - Noms du fuseau horaire

📅 Module datetime

Dates et heures - calculs sur des dates, durées, formats d'affichage.

from datetime import datetime, date, timedelta - Importer les classes principales

datetime.now() - Date et heure actuelles

date.today() - Date du jour

date(2026, 10, 4) - Créer une date

datetime(2026, 10, 4, 12, 30) - Créer une date avec l'heure

date(2026, 10, 4).year - Année (de même .month, .day, et .hour, .minute, .second pour un datetime)

date(2026, 10, 4).strftime('%d/%m/%Y') - Formater en texte (%Y année, %m mois, %d jour, %H heure, %M minute)

datetime.strptime('2026-10-04', '%Y-%m-%d') - Lire une date écrite dans un texte

date(2026, 12, 25) - date(2026, 10, 4) - Différence de deux dates : un timedelta

(date(2026, 12, 25) - date(2026, 10, 4)).days - Nombre de jours d'un timedelta

date(2026, 10, 4) + timedelta(days=30) - Ajouter une durée à une date

timedelta(days=1, hours=2).total_seconds() - Durée totale en secondes

date(2026, 10, 4).replace(year=2027) - Remplacer une partie de la date

date(2026, 10, 4).weekday() - Jour de la semaine : 0 = lundi, 6 = dimanche

date(2026, 10, 4).isoweekday() - Jour de la semaine ISO : 1 = lundi, 7 = dimanche

date(2026, 10, 4).isocalendar()[1] - Numéro de semaine ISO

📁 Module os et os.path

Système d'exploitation - dossiers, fichiers, chemins, variables d'environnement. (Pour un code portable, pathlib est une alternative moderne.)

import os - Importer le module

os.getcwd() - Dossier de travail actuel

os.chdir('/chemin') - Changer de dossier de travail

os.listdir('.') - Lister le contenu d'un dossier

os.mkdir('dossier') - Créer un dossier

os.makedirs('a/b/c') - Créer un dossier et ses parents

os.rmdir('dossier') - Supprimer un dossier vide

os.remove('fichier.txt') - Supprimer un fichier

os.rename('ancien', 'nouveau') - Renommer ou déplacer

os.path.exists('chemin') - Le chemin existe-t-il ?

os.path.isfile('chemin') - C'est un fichier ?

os.path.isdir('chemin') - C'est un dossier ?

os.path.join('a', 'b') - Assembler des morceaux de chemin avec le bon séparateur

os.path.basename('/a/b/c.txt') - Nom du fichier

os.path.dirname('/a/b/c.txt') - Dossier qui contient le fichier

os.path.splitext('rapport.pdf') - Séparer le nom et l'extension

os.path.abspath('f.txt') - Chemin absolu

os.path.getsize('f.txt') - Taille du fichier, en octets

os.environ.get('HOME') - Lire une variable d'environnement

os.name - Famille du système ('posix' ou 'nt')

💻 Module sys

Interpréteur Python - arguments du programme, version, sortie.

import sys - Importer le module

sys.argv - Arguments de la ligne de commande (argv[0] : nom du script)

sys.exit(0) - Quitter le programme (0 : tout va bien)

sys.path - Dossiers où Python cherche les modules

sys.platform - Plateforme : 'win32', 'linux', 'darwin'

sys.version - Version de Python, sous forme de texte

sys.version_info >= (3, 8) - Version de Python, sous forme comparable

sys.maxsize - Plus grand indice possible d'une séquence (2⁶³ − 1 sur un système 64 bits)

sys.stdin, sys.stdout, sys.stderr - Entrée standard, sortie standard, sortie d'erreurs

sys.getrecursionlimit() - Profondeur maximale de récursion (1000 par défaut)

sys.setrecursionlimit(2000) - Changer cette limite

sys.modules - Dictionnaire des modules déjà chargés

📝 Module json

Données JSON - le format d'échange le plus répandu (API, fichiers de configuration).

import json - Importer le module

json.dumps({'a': 1, 'b': [True, None]}) - Dictionnaire Python → texte JSON

json.loads('{"a": 1}') - Texte JSON → dictionnaire Python

json.dump(donnees, fichier) - Écrire en JSON dans un fichier ouvert

json.load(fichier) - Lire du JSON depuis un fichier ouvert

json.dumps({'a': 1}, indent=2) - JSON mis en forme (indenté)

json.dumps({'b': 1, 'a': 2}, sort_keys=True) - Clés triées

json.dumps('é', ensure_ascii=False) - Garder les caractères non ASCII tels quels

🔍 Module re (expressions régulières)

Motifs de texte - chercher, extraire ou remplacer des textes qui suivent un modèle. Les motifs s'écrivent en *raw string* : r"\d+".

import re - Importer le module

re.search(r'\d+', 'a12b').group() - Première correspondance n'importe où dans le texte

re.match(r'\d+', 'a12b') - Correspondance au début du texte seulement (None ici)

re.fullmatch(r'\d+', '2026').group() - Tout le texte doit correspondre

re.findall(r'\d+', 'a12b345') - Toutes les correspondances, en liste

[m.start() for m in re.finditer(r'\d', 'a1b2')] - Parcourir les correspondances (positions de début)

re.sub(r'\s+', ' ', 'a b c') - Remplacer chaque correspondance

re.sub(r'\d', '#', 'a1b2', count=1) - Remplacer seulement la première

re.split(r'[;,]', 'a;b,c') - Découper selon un motif

re.compile(r'\d+').findall('1 22') - Compiler un motif réutilisé souvent

re.search(r'(\d+)h(\d+)', '14h30').groups() - Groupes capturés par des parenthèses

re.search(r'(?P<h>\d+)h', '14h30').group('h') - Groupe nommé

re.findall(r'[a-z]+', 'ABC def', re.IGNORECASE) - Ignorer la casse

\d \w \s - Un chiffre ; une lettre, un chiffre ou _ ; un espace

[a-z] [A-Z0-9] [^abc] - Une lettre minuscule ; une majuscule ou un chiffre ; tout sauf a, b, c

^debut fin$ - Commence par ; finit par

. * + ? - Un caractère quelconque ; 0 ou plus ; 1 ou plus ; 0 ou 1

{3} {3,5} - Exactement 3 fois ; entre 3 et 5 fois

(a|b) - a ou b (groupe)

🌐 Module urllib

Requêtes HTTP - lire une page web ou une API sans bibliothèque tierce. (Pour des usages plus riches, la bibliothèque requests est plus confortable.)

from urllib.request import urlopen - Importer l'ouverture d'URL

urlopen('https://example.com') - Ouvrir une URL (renvoie une réponse)

reponse.read() - Lire le contenu (en octets)

reponse.status - Code de statut HTTP (200 : succès)

from urllib.parse import urlparse, quote, unquote - Importer les outils d'adresses

urlparse('https://example.com/chemin?x=1') - Découper une adresse en morceaux

quote('à b') - Encoder un texte pour une adresse ('%C3%A0%20b')

unquote('%C3%A0%20b') - Décoder un texte encodé

📊 Module statistics

Statistiques de base - moyenne, médiane, dispersion.

import statistics - Importer le module

statistics.mean([1, 2, 3, 6]) - Moyenne

statistics.median([1, 2, 3, 6]) - Médiane

statistics.mode([1, 2, 2, 3]) - Valeur la plus fréquente

statistics.stdev([1, 2, 3]) - Écart-type d'un échantillon

statistics.pstdev([1, 2, 3]) - Écart-type d'une population entière

statistics.variance([1, 2, 3]) - Variance d'un échantillon

statistics.harmonic_mean([1, 2]) - Moyenne harmonique

statistics.geometric_mean([1, 4]) - Moyenne géométrique

🧺 Module collections

Structures de données supplémentaires - compter, regrouper, files d'attente, enregistrements.

from collections import Counter, defaultdict, deque, namedtuple - Importer les structures principales

Counter('abracadabra') - Compter les éléments

Counter('abracadabra').most_common(2) - Les éléments les plus fréquents

defaultdict(list) - Dictionnaire qui crée une valeur par défaut pour une clé absente

deque([1, 2, 3]) - File à deux bouts : append, appendleft, pop, popleft en O(1)

namedtuple('Point', 'x y')(3, 4) - Tuple dont les éléments ont un nom

🔁 Module itertools

Itérateurs combinatoires - arrangements, combinaisons, produits cartésiens.

import itertools - Importer le module

list(itertools.permutations('ABC', 2))[:3] - Arrangements de 2 éléments (l'ordre compte)

list(itertools.combinations([1, 2, 3], 2)) - Combinaisons de 2 éléments (l'ordre ne compte pas)

list(itertools.product([0, 1], repeat=2)) - Produit cartésien (tous les couples)

list(itertools.chain([1, 2], [3])) - Enchaîner plusieurs suites

list(itertools.accumulate([1, 2, 3, 4])) - Sommes cumulées

list(itertools.islice(itertools.count(10), 3)) - Les 3 premiers éléments d'une suite infinie

🔐 Module secrets

Hasard sûr - pour les mots de passe et jetons : contrairement à random, les tirages sont imprévisibles.

import secrets - Importer le module

secrets.randbelow(10) - Entier aléatoire de 0 à 9

secrets.choice(['a', 'b']) - Un élément au hasard

secrets.token_hex(16) - Jeton aléatoire en hexadécimal

secrets.token_urlsafe(16) - Jeton utilisable dans une adresse web

secrets.compare_digest(a, b) - Comparaison à temps constant (pour des secrets)

🖼️ Module tkinter

Interfaces graphiques - fenêtres, boutons et champs de saisie (bibliothèque standard, souvent importée avec import tkinter as tk).

import tkinter as tk - Importer le module

fenetre = tk.Tk() - Créer la fenêtre principale

fenetre.title('Mon appli') - Titre de la fenêtre

fenetre.geometry('400x300') - Taille de la fenêtre, en pixels

label = tk.Label(fenetre, text='Bonjour') - Texte affiché

label.pack() - Placer le composant dans la fenêtre

bouton = tk.Button(fenetre, text='OK', command=action) - Bouton qui appelle une fonction

champ = tk.Entry(fenetre) - Champ de saisie ; champ.get() lit ce qui est saisi

fenetre.mainloop() - Lancer la boucle d'affichage

🎨 Module turtle

Dessin avec une tortue - un crayon qui avance, tourne et trace des figures (très utilisé pour apprendre à programmer).

import turtle - Importer le module

turtle.forward(100) - Avancer de 100 pixels

turtle.backward(100) - Reculer de 100 pixels

turtle.right(90) - Tourner à droite de 90°

turtle.left(90) - Tourner à gauche de 90°

turtle.penup() - Lever le crayon (déplacements sans tracé)

turtle.pendown() - Baisser le crayon

turtle.goto(0, 0) - Aller aux coordonnées (0, 0)

turtle.circle(50) - Dessiner un cercle de rayon 50

turtle.color('red') - Changer la couleur du tracé

turtle.begin_fill() / turtle.end_fill() - Commencer / terminer le remplissage d'une forme

turtle.done() - Terminer et garder la fenêtre ouverte