L’installateur Windows classique est déprécié depuis 3.14 ; il ne sera plus produit à partir de 3.16.

• >>> invite ; ... suite d’un bloc — une ligne vide le termine.
• _ rappelle le dernier résultat affiché.
• ↑ ↓ historique ; Tab complète les noms.
• help(len) · help("for") : aide ; dir(x) : attributs de x ; type(x) : son type.
• 3.13+ couleurs, F1 aide, F2 historique, F3 mode collage.

"""Aire d'un disque."""      1
import math                  2

RAYON = 2.5                  3

def aire(r):                 4
    """Renvoie l'aire du disque."""
    return math.pi * r ** 2  5

if __name__ == "__main__":   6
    print(f"{aire(RAYON):.2f}")  → 19.63

• 1 docstring : documentation du module, lue par help() ;
• 2 import d’un module de la bibliothèque standard ;
• 3 constante : nom en majuscules (simple convention) ;
• 4 définition de fonction : def, nom, paramètres, deux-points ;
• 5 le bloc est délimité par l’indentation : 4 espaces ;
• 6 exécuté seulement si le fichier est lancé, pas s’il est importé.

• Un bloc s’ouvre par : et se délimite par l’indentation : 4 espaces, sans mélange avec des tabulations.
• Une instruction par ligne, sans ; final.
• # commente jusqu’à la fin de la ligne.
• Ligne trop longue : la couper à l’intérieur de ( ), [ ] ou { } plutôt qu’avec \.
• La casse compte : nom ≠ Nom.
• pass : bloc vide, à compléter plus tard.

Une variable est un nom attaché à un objet. Le type appartient à l’objet, pas au nom : c’est le typage dynamique.

Nommage (PEP 8)

Un nom : lettres, chiffres et _, sans chiffre en tête ni mot réservé.

Dans le doute : des parenthèses. 2 + 3 * 4 → 14 ; (2 + 3) * 4 → 20.

nom, age = "Alice", 36
print("Bonjour", nom)
→ Bonjour Alice
print(nom, age, sep=" | ")
→ Alice | 36
print(f"{nom} a {age} ans")
→ Alice a 36 ans
print(f"{age=}")          → age=36
print("fin", end="!\n")   → fin!

texte = input("Âge ? ")  # une chaîne
age = int(texte)         # conversion

input() renvoie du texte : convertir avec int() ou float() avant de calculer.

Valent faux : False, None, 0, 0.0, "", [], (), {}, set(), range(0). Tout le reste vaut vrai.

D’où l’usage : if liste: plutôt que if len(liste) > 0:

0.1 + 0.2         → 0.30000000000000004
0.1 + 0.2 == 0.3  → False !
import math
math.isclose(0.1 + 0.2, 0.3)  → True
from decimal import Decimal
Decimal("0.1") + Decimal("0.2")
→ Decimal('0.3')
from fractions import Fraction
Fraction(1, 3) + Fraction(1, 6)
→ Fraction(1, 2)

Les float sont stockés en binaire : 0,1 n’y a pas de valeur exacte. Comparer avec math.isclose ; pour de l’argent, Decimal construit à partir d’une chaîne (Decimal(0.1) hérite de l’erreur).

Elles renvoient une nouvelle chaîne : s.upper() ne modifie pas s.

Après :, dans l’ordre : remplissage, alignement (< ^ >), signe, largeur, séparateur (, ou _), précision (.2), type (f d % e x b).

Anciennes syntaxes, encore rencontrées : "{:.2f}".format(x) et "%.2f" % x. 3.14+ t"…" crée un gabarit (Template), pas une chaîne : il sert aux bibliothèques qui doivent traiter les valeurs insérées.

str : des caractères ; fichiers et réseau : des octets (bytes).

* ordre d’insertion, garanti depuis 3.7. Modif. : modifiable ; Doubl. : doublons admis. frozenset : ensemble non modifiable, donc hachable.

• list : suite d’éléments qu’on ajoute, retire, trie.
• tuple : enregistrement fixe (coordonnées, retour multiple) ; peut servir de clé.
• dict : retrouver une valeur par sa clé, en temps constant.
• set : tester l’appartenance, dédoublonner, comparer des groupes.

! {} est un dict vide ; ensemble vide : set(). Tuple d’un seul élément : (1,) — c’est la virgule qui fait le tuple.

Chaque ligne part de L = [3, 1, 4].

Trier avec une clé

mots = ["Kiwi", "ail", "pomme", "figue"]
sorted(mots)           # A-Z avant a-z
→ ['Kiwi', 'ail', 'figue', 'pomme'] !
sorted(mots, key=str.lower)
→ ['ail', 'figue', 'Kiwi', 'pomme']
sorted(mots, key=len)
→ ['ail', 'Kiwi', 'pomme', 'figue']

Le tri est stable : à clé égale, l’ordre d’origine est conservé (pomme avant figue).

Chaque ligne part de d = {"a": 1, "b": 2}.

for cle, valeur in d.items():
    print(cle, valeur)      → a 1 ⏎ b 2

Clés : objets hachables, donc immuables (str, int, tuple…).

Avec a = {1, 2, 3} et b = {3, 4} :

Pas d’indice, ordre non garanti ; éléments hachables seulement.

Les indices désignent les bords des cases ; comptés depuis la fin, ils sont négatifs. Syntaxe : s[début:fin:pas], fin exclue.

Valable pour toute séquence : chaînes, listes, tuples.

point = (3, 4)
x, y = point                # déballage
x                           → 3
premier, *reste = [1, 2, 3, 4]
reste                       → [2, 3, 4]
*debut, dernier = "abc"
debut                       → ['a', 'b']
a, _ = (10, "x")            # _ : ignoré
def bornes(L):
    return min(L), max(L)   # un tuple
bas, haut = bornes([4, 1, 7])
bas, haut                   → (1, 7)

[x ** 2 for x in range(5)]
→ [0, 1, 4, 9, 16]
[x for x in range(10) if x % 3 == 0]
→ [0, 3, 6, 9]
[x if x > 0 else 0 for x in [-2, 5, -1]]
→ [0, 5, 0]
{m: len(m) for m in ["un", "deux"]}
→ {'un': 2, 'deux': 4}
{x % 3 for x in range(10)}
→ {0, 1, 2}
sum(x ** 2 for x in range(4))      → 14
[f"{i}{j}" for i in "ab" for j in "12"]
→ ['a1', 'a2', 'b1', 'b2']

if après for : filtre. … if … else … avant for : transforme chaque élément. Sans crochets, entre parenthèses : une expression génératrice, calculée à la demande, sans liste en mémoire.

a = [1, 2]
b = a             # deux noms, UN objet
b.append(3)
a                 → [1, 2, 3] !
c = a.copy()      # ou list(a), a[:]
c == a, c is a    → (True, False)
m = [[0] * 2] * 2 # 2 fois la même ligne
m[0][0] = 1
m                 → [[1, 0], [1, 0]] !
# correct : une ligne par tour
m = [[0] * 2 for _ in range(2)]
import copy
m2 = copy.deepcopy(m)  # copie profonde

== compare les valeurs, is l’identité. Immuables : int, float, str, tuple, frozenset, bytes. Modifiables : list, dict, set, la plupart des objets. copy() ne copie qu’un niveau.

note = 13
if note >= 16:
    mention = "très bien"
elif note >= 14:
    mention = "bien"
elif note >= 12:
    mention = "assez bien"
else:
    mention = "aucune"
mention             → 'assez bien'
age = 20
s = "majeur" if age >= 18 else "mineur"
s                   → 'majeur'

Tests idiomatiques

def analyser(cmd):
    match cmd.split():
        case ["aller", direction]:
            return f"vers {direction}"
        case ["prendre", *obj]:
            return f"{len(obj)} objets"
        case ["quitter" | "q"]:
            return "fin"
        case [n] if n.isdigit():
            return f"code {n}"
        case _:
            return "inconnu"

analyser("aller nord")   → 'vers nord'
analyser("prendre a b")  → '2 objets'
analyser("q")            → 'fin'
analyser("42")           → 'code 42'
analyser("")             → 'inconnu'

• Motifs : littéral case 0:, alternative |, capture x, séquence [a, *reste], dictionnaire {"type": t}, classe Point(x=0), garde if.
• case _: attrape tout le reste.
• ! Un nom seul capture, il ne compare pas : case ROUGE: attrape tout. Comparer à une constante : nom pointé, case Couleur.ROUGE:

mots = "un deux trois quatre".split()
# affecte n, puis le compare
if (n := len(mots)) > 3:
    print(n, "mots")     → 4 mots

Utile dans while (ligne := f.readline()): ; à réserver aux cas où il évite une répétition.

while True:
    texte = input("Note (0-20) ? ")
    try:                  # voir page 7
        note = int(texte)
    except ValueError:
        print("Un entier, svp.")
        continue          # redemander
    if 0 <= note <= 20:
        break             # valide
    print("Hors limites.")

for lettre in "abc":
    print(lettre, end=" ")   → a b c

Outils de parcours

noms = ["Ana", "Léo"]
notes = [15, 12]
for nom, note in zip(noms, notes):
    print(nom, note)  → Ana 15 ⏎ Léo 12

n = 0
while n < 3:     # tant que c'est vrai
    n += 1       # sinon : sans fin
n                → 3
for x in [4, 9, 15, 7]:
    if x % 2 == 0:
        continue # tour suivant
    if x > 10:
        break    # sortie de boucle
    print(x)     → 9
else:
    print("fini")  # si aucun break

• Boucle sans fin volontaire : while True: … if condition: break.
• Ctrl+C interrompt un programme bloqué (KeyboardInterrupt).
• ! Ne pas modifier une liste pendant qu’on la parcourt : parcourir une copie (for x in L[:]) ou construire une nouvelle liste.

if x = 5: → SyntaxError : = affecte, == compare.

L = [3, 1, 3, 2]
d = {"a": 3, "b": 7, "c": 5}
M = [[1, 2], [3, 4]]
# compter les occurrences
from collections import Counter
Counter("abracadabra").most_common(2)
→ [('a', 5), ('b', 2)]
# clé de la plus grande valeur
max(d, key=d.get)            → 'b'
# trier un dict par valeur
sorted(d.items(), key=lambda kv: kv[1])
→ [('a', 3), ('c', 5), ('b', 7)]
# inverser un dict
{v: k for k, v in d.items()}
→ {3: 'a', 7: 'b', 5: 'c'}
# aplatir une liste de listes
[x for ligne in M for x in ligne]
→ [1, 2, 3, 4]
# transposer une matrice
list(zip(*M))       → [(1, 3), (2, 4)]
# dédoublonner en gardant l'ordre
list(dict.fromkeys(L))       → [3, 1, 2]
# compter à la main
cpt = {}
for c in "abca":
    cpt[c] = cpt.get(c, 0) + 1
cpt
→ {'a': 2, 'b': 1, 'c': 1}
# indice du maximum
L.index(max(L))              → 0
# découper en paquets (3.12+)
from itertools import batched
list(batched("abcde", 2))
→ [('a', 'b'), ('c', 'd'), ('e',)]

notes = [12, 8, 15, 9]
total = 0             # accumulateur
for n in notes:
    total += n
total                 → 44
nb = 0                # compteur
for n in notes:
    if n >= 10:
        nb += 1
nb                    → 2
m = None              # meilleur vu
for n in notes:
    if m is None or n > m:
        m = n
m                     → 15

Formes courtes : sum(notes), sum(n >= 10 for n in notes), max(notes).

it = iter([10, 20])
next(it), next(it)     → (10, 20)
next(it)               → StopIteration

def rebours(n):        # génératrice
    while n > 0:
        yield n        # donne, attend
        n -= 1
list(rebours(3))       → [3, 2, 1]
# expression génératrice :
# rien n'est calculé d'avance
carres = (x * x for x in range(10**9))
next(carres), next(carres)  → (0, 1)

for appelle iter(), puis next() jusqu’à StopIteration. Un générateur fournit ses valeurs à la demande : mémoire constante, mais un seul parcours. yield from autre délègue à un autre itérable.

def prix_ttc(ht, taux=0.20):                       1
    """Renvoie le prix TTC arrondi au centime."""  2
    return round(ht * (1 + taux), 2)               3

prix_ttc(100)                  → 120.0
prix_ttc(100, 0.055)           → 105.5
prix_ttc(taux=0.1, ht=50)      → 55.0

• 1 def, nom, paramètres ; taux a une valeur par défaut ;
• 2 docstring : ce que fait la fonction, affichée par help(prix_ttc) ;
• 3 return renvoie la valeur et termine la fonction ; sans return, elle renvoie None.

À l’appel : arguments positionnels (par rang) d’abord, puis nommés (taux=0.1), dans n’importe quel ordre.

def f(a, b=2, *args, c, d=4, **kwargs):
    return a, b, args, c, d, kwargs

f(1, c=3)                  → (1, 2, (), 3, 4, {})
f(1, 5, 6, 7, c=3, e=8)    → (1, 5, (6, 7), 3, 4, {'e': 8})
nombres, options = [1, 5], {"c": 3}
f(*nombres, **options)     → (1, 5, (), 3, 4, {})
f(1)                       → TypeError !

Un nom est cherché dans l’ordre Local → fonction Englobante → Global (module) → Built-in (fonctions natives) : règle LEGB.

compteur = 0
def incrementer():
    global compteur       # sans cela : UnboundLocalError
    compteur += 1
incrementer()
compteur                  → 1

def fabrique():
    total = 0
    def ajouter(n):
        nonlocal total    # variable de la fonction englobante
        total += n
        return total
    return ajouter        # une « fermeture » (closure)
acc = fabrique()
acc(5), acc(3)            → (5, 8)

Préférer paramètres et valeurs de retour à global : le code reste lisible et testable.

import math                   # puis : math.sqrt(2)
from math import sqrt, pi     # puis : sqrt(2)
import datetime as dt         # alias : dt.date(2026, 1, 15)

• Un module est un fichier .py : import outils charge outils.py ; un paquet est un dossier de modules.
• Imports en tête de fichier : bibliothèque standard, puis paquets tiers, puis modules du projet.
• Éviter from module import * : on ne sait plus d’où viennent les noms.
• ! Ne pas nommer un fichier comme un module existant (random.py, csv.py…) : il masque le vrai.
• if __name__ == "__main__": protège le code à n’exécuter qu’au lancement direct (page 1).
• Python cherche les modules dans le dossier du script, puis dans sys.path.

double = lambda x: 2 * x          # fonction anonyme
double(4)                         → 8
mots = ["kiwi", "Ail", "banane"]
sorted(mots, key=str.lower)       → ['Ail', 'banane', 'kiwi']
sorted(mots, key=lambda m: m[-1]) → ['banane', 'kiwi', 'Ail']
ops = {"+": lambda a, b: a + b, "*": lambda a, b: a * b}
ops["*"](3, 4)                    → 12

Une fonction est un objet : on peut la ranger dans une variable, un dict, la passer en argument. PEP 8 : lambda pour une expression courte passée en argument, def sinon.

def ajouter(x, L=[]):     # liste créée UNE fois
    L.append(x)
    return L
ajouter(1)                → [1]
ajouter(2)                → [1, 2] !

def ajouter(x, L=None):   # la bonne forme
    if L is None:
        L = []            # nouvelle liste à chaque appel
    L.append(x)
    return L
ajouter(1), ajouter(2)    → ([1], [2])

La valeur par défaut est évaluée une seule fois, à la définition de la fonction.

def factorielle(n):
    if n <= 1:                 # cas de base : indispensable
        return 1
    return n * factorielle(n - 1)
factorielle(5)                 → 120
import sys
sys.getrecursionlimit()        → 1000

Au-delà de la limite (1 000 appels imbriqués par défaut) : RecursionError. Une boucle est souvent plus sûre.

import functools, time

def chronometrer(f):
    @functools.wraps(f)            # conserve nom et docstring
    def enveloppe(*args, **kwargs):
        t0 = time.perf_counter()
        resultat = f(*args, **kwargs)
        duree = time.perf_counter() - t0
        print(f"{f.__name__} : {duree:.3f} s")
        return resultat
    return enveloppe

@chronometrer               # somme = chronometrer(somme)
def somme(n):
    return sum(range(n))

@functools.cache                   # mémorise les résultats
def fib(n):
    return n if n < 2 else fib(n - 1) + fib(n - 2)
fib(80)                            → 23416728348467685

Un décorateur prend une fonction et en renvoie une autre qui l’enveloppe : chronométrer, journaliser, mettre en cache, contrôler l’accès. @functools.lru_cache(maxsize=128) : cache de taille bornée.

def moyenne(notes: list[float]) -> float:
    return sum(notes) / len(notes)
moyenne([12.0, 15.0])              → 13.5

age: int = 36
nom: str | None = None             # « ou » entre types (3.10+)
type Point = tuple[float, float]   # alias de type (3.12+)
moyenne("abc")                     → TypeError

Python ne vérifie pas les annotations à l’exécution (l’erreur ci-dessus vient de sum) : elles documentent et servent aux outils externes (mypy, pyright) et aux éditeurs.

class Compte:
    """Compte bancaire simple."""
    nb_comptes = 0                      # attribut de classe

    def __init__(self, titulaire, solde=0):
        self.titulaire = titulaire      # attributs d'instance
        self.solde = solde
        Compte.nb_comptes += 1

    def deposer(self, montant):         # méthode
        if montant <= 0:
            raise ValueError("montant positif attendu")
        self.solde += montant
        return self.solde

    def __repr__(self):                 # affichage technique
        return f"Compte({self.titulaire!r}, {self.solde})"

c = Compte("Alice", 100)    # crée l'objet, puis appelle __init__
c.deposer(50)               → 150
c.solde                     → 150
c                           → Compte('Alice', 150)
Compte.nb_comptes           → 1

class CompteEpargne(Compte):            # hérite de Compte
    def __init__(self, titulaire, solde=0, plafond=10_000):
        super().__init__(titulaire, solde)   # le parent d'abord
        self.plafond = plafond

    def deposer(self, montant):         # redéfinition
        if self.solde + montant > self.plafond:
            raise ValueError("plafond dépassé")
        return super().deposer(montant)

e = CompteEpargne("Bob", 9_900)
e.deposer(50)               → 9950
e.deposer(100)              → ValueError: plafond dépassé
isinstance(e, Compte)       → True
[k.__name__ for k in CompteEpargne.__mro__]
→ ['CompteEpargne', 'Compte', 'object']

super() appelle la version de la classe parente, selon l’ordre de résolution des méthodes (__mro__). Héritage = relation « est un » ; pour « a un », préférer la composition : un attribut qui contient un autre objet.

Typage canard : peu importe la classe d’un objet, pourvu qu’il possède les méthodes attendues.

from enum import Enum, auto
class Couleur(Enum):
    ROUGE = auto()
    VERT = auto()
Couleur.VERT                  → <Couleur.VERT: 2>
Couleur.VERT.name             → 'VERT'
Couleur(1)                    → <Couleur.ROUGE: 1>
[c.name for c in Couleur]     → ['ROUGE', 'VERT']

class Temperature:
    def __init__(self, celsius):
        self.celsius = celsius          # passe par le setter

    @property                           # lecture : t.celsius
    def celsius(self):
        return self._celsius

    @celsius.setter                     # écriture
    def celsius(self, valeur):
        if valeur < -273.15:
            raise ValueError("sous le zéro absolu")
        self._celsius = valeur

    @property
    def fahrenheit(self):               # attribut calculé
        return self._celsius * 9 / 5 + 32

    @classmethod                        # autre constructeur
    def depuis_fahrenheit(cls, f):
        return cls((f - 32) * 5 / 9)

    @staticmethod                       # ni self ni cls
    def gele(celsius):
        return celsius <= 0

Temperature(25).fahrenheit              → 77.0
Temperature.depuis_fahrenheit(212).celsius   → 100.0
Temperature.gele(-3)                    → True
Temperature(-300)   → ValueError: sous le zéro absolu

Elles branchent un objet sur la syntaxe du langage.

from dataclasses import dataclass, field, asdict

@dataclass(frozen=True)       # frozen : immuable, hachable
class Point:
    x: float
    y: float = 0.0

p = Point(1.5)
p                             → Point(x=1.5, y=0.0)
p == Point(1.5, 0)            → True
asdict(p)                     → {'x': 1.5, 'y': 0.0}
p.x = 2                       → FrozenInstanceError !

@dataclass(order=True)        # order : <, >, sorted()
class Tache:
    priorite: int
    titre: str = ""
    tags: list[str] = field(default_factory=list)
sorted([Tache(2, "b"), Tache(1, "a")])[0].titre   → 'a'

@dataclass écrit pour vous __init__, __repr__ et __eq__. Valeur par défaut modifiable : field(default_factory=list).

def diviser(texte):
    try:
        n = int(texte)          # peut lever ValueError
        r = 100 / n             # peut lever ZeroDivisionError
    except ValueError:
        print("pas un entier")
    except ZeroDivisionError as e:   # e : l'objet exception
        print("erreur :", e)
    else:                       # seulement si aucune exception
        print("résultat :", r)
    finally:                    # dans tous les cas
        print("fin")

diviser("4")        → résultat : 25.0 ⏎ fin
diviser("0")        → erreur : division by zero ⏎ fin
diviser("x")        → pas un entier ⏎ fin

Lever une exception

class SoldeInsuffisant(Exception):     # exception personnalisée
    """Le solde ne couvre pas le retrait."""

def retirer(solde, montant):
    if montant > solde:
        raise SoldeInsuffisant(f"il manque {montant - solde} €")
    return solde - montant

try:
    retirer(50, 70)
except SoldeInsuffisant as e:
    print("Refusé :", e)        → Refusé : il manque 20 €

• Attraper des exceptions précises ; jamais de except: nu, qui avale tout, même Ctrl+C.
• raise seul, dans un except : relance l’exception en cours ; raise Autre("…") from e : nouvelle exception, cause conservée.
• except (ValueError, TypeError): plusieurs types ; 3.14+ parenthèses facultatives sans as.
• assert x > 0, "message" : contrôle de développement, ignoré avec python -O.

BaseException
 +-- KeyboardInterrupt      Ctrl+C
 +-- SystemExit             sys.exit()
 +-- Exception              celles qu'on attrape
      +-- ArithmeticError
      |    +-- ZeroDivisionError
      +-- LookupError
      |    +-- IndexError   indice hors limites
      |    +-- KeyError     clé absente
      +-- NameError
      |    +-- UnboundLocalError
      +-- ImportError
      |    +-- ModuleNotFoundError
      +-- OSError           système, fichiers
      |    +-- FileNotFoundError
      |    +-- PermissionError
      +-- RuntimeError
      |    +-- RecursionError
      +-- AttributeError, TypeError, ValueError…

except LookupError: attrape à la fois IndexError et KeyError.

def moyenne(notes):
    return sum(notes) / len(notes)
print(moyenne([]))

Traceback (most recent call last):
  File "moyenne.py", line 3, in <module>
    print(moyenne([]))
          ~~~~~~~^^^^
  File "moyenne.py", line 2, in moyenne
    return sum(notes) / len(notes)
           ~~~~~~~~~~~^~~~~~~~~~~~
ZeroDivisionError: division by zero

• 1 lire d’abord la dernière ligne : le type d’erreur et son message ;
• 2 remonter : chaque « File … line … » est un appel ; le plus bas est l’endroit où l’erreur s’est produite ;
• 3 les ~ et ^ soulignent l’expression fautive 3.11+.

Chemin du fichier abrégé ; la dernière ligne se copie telle quelle dans un moteur de recherche.

# écrire : le fichier est créé, ou ÉCRASÉ s'il existe
with open("notes.txt", "w", encoding="utf-8") as f:
    f.write("12\n")
    print("15", file=f)            # print vers un fichier
# ajouter à la fin
with open("notes.txt", "a", encoding="utf-8") as f:
    f.write("18\n")
# lire ligne à ligne ; fermeture automatique en fin de bloc
with open("notes.txt", encoding="utf-8") as f:
    notes = [int(ligne) for ligne in f]
notes                              → [12, 15, 18]

Toujours préciser encoding="utf-8" : jusqu’à 3.14, le défaut sous Windows dépend du système (souvent cp1252) ; UTF-8 devient le défaut avec Python 3.15 (PEP 686).

from pathlib import Path
p = Path("donnees") / "notes.txt"   # / assemble les chemins
p.name, p.stem, p.suffix    → ('notes.txt', 'notes', '.txt')
p.parent.name               → 'donnees'
p.parent.mkdir(parents=True, exist_ok=True)
p.write_text("12\n15\n", encoding="utf-8")        → 6
p.read_text(encoding="utf-8").split()             → ['12', '15']
p.exists()                  → True
[f.name for f in Path("donnees").glob("*.txt")]   → ['notes.txt']

Aussi : Path.cwd() dossier courant, Path.home() dossier personnel, p.resolve() chemin absolu, rglob("*.py") recherche récursive, p.rename(q), p.unlink() suppression !. Sous Windows : Path(r"C:\Users\…") ou barres obliques "C:/Users/…".

• Un environnement par projet : les versions ne se contredisent pas d’un projet à l’autre.
• python -m pip installe pour ce Python-là, sans ambiguïté.
• ! Vérifier le nom exact d’un paquet sur pypi.org : des paquets malveillants imitent les noms connus.
• Si PowerShell refuse l’activation : Get-Help about_Execution_Policies.
• Outils tiers répandus : uv, Poetry, pipx.

! random ne convient pas à la sécurité : pour un mot de passe ou un jeton, secrets.

import json
d = {"nom": "Élise", "notes": [12, 15]}
s = json.dumps(d, ensure_ascii=False)
s
→ '{"nom": "Élise", "notes": [12, 15]}'
json.loads(s) == d              → True
with open("d.json", "w",
          encoding="utf-8") as f:
    json.dump(d, f, ensure_ascii=False,
              indent=2)
with open("d.json",
          encoding="utf-8") as f:
    d = json.load(f)

import csv
with open("n.csv", "w", newline="",
          encoding="utf-8") as f:
    w = csv.writer(f, delimiter=";")
    w.writerow(["nom", "note"])
    w.writerow(["Élise", 15])
with open("n.csv", newline="",
          encoding="utf-8") as f:
    lignes = list(csv.DictReader(
        f, delimiter=";"))
lignes[0]
→ {'nom': 'Élise', 'note': '15'}

JSON ↔ Python : objet ↔ dict, tableau ↔ list, true / null ↔ True / None. CSV : tout est lu comme texte ('15') ; newline="" obligatoire. Excel en français attend souvent ; et lit mieux les accents en encoding="utf-8-sig".

from collections import Counter
Counter([1, 2, 2, 3, 2]).most_common(1)
→ [(2, 3)]
from collections import defaultdict
groupes = defaultdict(list)
groupes["a"].append(1)    # clé créée
dict(groupes)             → {'a': [1]}
from collections import deque
q = deque([1, 2], maxlen=3)
q.appendleft(0)
q.append(3)               # 3 au plus
q
→ deque([1, 2, 3], maxlen=3)
q.popleft()               → 1
from itertools import combinations
list(combinations("abc", 2))
→ [('a', 'b'), ('a', 'c'), ('b', 'c')]
from itertools import permutations
len(list(permutations("abcd")))  → 24
from itertools import product
list(product([0, 1], repeat=2))
→ [(0, 0), (0, 1), (1, 0), (1, 1)]
from itertools import accumulate
list(accumulate([1, 2, 3, 4]))
→ [1, 3, 6, 10]

from datetime import date, datetime
from datetime import timedelta
d = date(2026, 1, 15)
d + timedelta(days=30)
→ datetime.date(2026, 2, 14)
(date(2026, 12, 25) - d).days  → 344
d.weekday()          → 3
d.strftime("%d/%m/%Y")  → '15/01/2026'
d.isoformat()           → '2026-01-15'
datetime.strptime("15/01/2026 14:30",
                  "%d/%m/%Y %H:%M")
→ datetime.datetime(2026, 1, 15, 14, 30)

weekday() : lundi = 0. date.today(), datetime.now() : aujourd’hui, maintenant. Codes : %Y année, %m mois, %d jour, %H %M %S heure, minute, seconde, %A nom du jour (anglais par défaut).

Fuseaux : ZoneInfo("Europe/Paris") du module zoneinfo ; sous Windows, installer d’abord le paquet tzdata.

import re
re.findall(r"\d+", "a1b22c333")
→ ['1', '22', '333']
re.sub(r"\s+", " ", "a  b\t c")
→ 'a b c'
motif = r"(\d\d)/(\d\d)/(\d{4})"
m = re.search(motif, "le 15/01/2026")
m.group(3)                   → '2026'
bool(re.fullmatch(r"[A-Z]\d+", "B123"))
→ True

Toujours des chaînes brutes r"…". search cherche partout, match au début, fullmatch sur toute la chaîne.

# fichier test_calcul.py
# lancer : python -m pytest
from calcul import moyenne

def test_moyenne():
    assert moyenne([10, 20]) == 15

• 4 espaces par niveau ; lignes de 79 caractères au plus.
• snake_case pour variables et fonctions, CapWords pour les classes, MAJUSCULES pour les constantes.
• Deux lignes vides entre fonctions et classes de premier niveau.
• is None plutôt que == None ; if liste: plutôt que if len(liste) > 0:
• with pour les fichiers ; f-strings pour mettre en forme.
• Fonctions courtes, noms explicites, docstrings.
• Formatage et analyse automatiques : Ruff, Black ; types : mypy (outils tiers).
• import this : les principes de Python (PEP 20).