Automatiser mon quotidien — 4 semaines pour confier vos tâches répétitives à un script que vous savez corriger

La boucle : écrire une fois, répéter autant de fois que nécessaire

Répéter pour chaque valeur : for. Une suite de valeurs s'écrit entre crochets, séparées par des virgules (on l'appelle une liste ; vous l'étudierez en semaine 2). La boucle for prend les valeurs une par une :

total = 0
for montant in [1250.50, 89.90, 45.00, 320.00, 210.40, 1480.00]:
    total = total + montant
print("Total du mois :", round(total, 2), "euros")

Affiche Total du mois : 3395.8 euros. Lisez la deuxième ligne comme une phrase : « pour chaque montant dans cette liste ». À chaque tour (on dit aussi une itération), la variable montant prend la valeur suivante, et les lignes décalées de 4 espaces s'exécutent. Après le dernier tour, Python passe à la ligne qui n'est plus décalée.

L'accumulateur. total est créé avant la boucle, à zéro, puis augmenté à chaque tour : c'est un accumulateur, comme la cellule « Total » au bas d'une colonne. Un compteur fonctionne de la même façon, en ajoutant 1 :

nombre = 0
for montant in [1250.50, 89.90, 45.00, 320.00, 210.40, 1480.00]:
    if montant > 1000:
        nombre = nombre + 1
        print("Grosse facture :", montant)
print(nombre, "factures au-dessus de 1000 euros")

Affiche Grosse facture : 1250.5, Grosse facture : 1480.0, puis 2 factures au-dessus de 1000 euros. Une condition peut se trouver dans une boucle : ce qui dépend du if est décalé une fois de plus.

Répéter un nombre de fois : range.

for i in range(3):
    print("Tour", i)
for numero in range(412, 415):
    print("Facture", numero)

Affiche Tour 0, Tour 1, Tour 2, puis Facture 412, Facture 413, Facture 414. range(3) donne 3 valeurs en commençant à 0 : 0, 1, 2. range(412, 415) va de 412 à 414 : la valeur de fin n'est jamais atteinte.

Répéter tant qu'une condition est vraie : while. Votre calculateur du Boost s'arrêtait sur un délai impossible ; une boucle while (« tant que ») le redemande :

delai = int(input("Délai de paiement en jours (1 à 28) : "))
while delai < 1 or delai > 28:
    print("Le délai doit être compris entre 1 et 28 jours.")
    delai = int(input("Délai de paiement en jours (1 à 28) : "))
print("Délai enregistré :", delai, "jours")

Essai réel :

Tant que le délai est hors limites, on le redemande. Attention : si rien ne change dans la boucle, la condition reste vraie pour toujours. C'est une boucle infinie : arrêtez le programme avec le bouton Stop de votre environnement (ou Ctrl + C). Rien n'est cassé.

« D'abord pour une, puis pour toutes »

Rappels : la boucle et l'accumulateur (voir épisode 1), une étape, un test, un cas connu (voir Boost, épisode 4).

1. Pour une : le calcul marche pour une facture, vérifié sur un cas connu (c'est votre calculateur du Boost).
2. Dans la boucle : on le place sous for i in range(nb_factures):, tout décalé de 4 espaces.
3. Ce qui ne doit pas repartir à zéro (le total du mois) est créé avant la boucle ; ce qui change à chaque facture est dans la boucle.
4. On teste sur 2 factures, puis sur toutes ; on vérifie le nombre de résultats affichés et le total.

Le calculateur pour plusieurs factures (année fixée à 2026, une année non bissextile, pour alléger) :

ANNEE = 2026
TAUX_ANNUEL = 12.40
nb_factures = int(input("Nombre de factures : "))
total_penalites = 0
for i in range(nb_factures):
    print("--- Facture", i + 1, "---")
    jour = int(input("Jour de la facture : "))
    mois = int(input("Mois de la facture (1 à 12) : "))
    delai = int(input("Délai de paiement en jours (1 à 28) : "))
    montant = float(input("Montant en euros (avec un point) : "))
    jours_retard = int(input("Jours de retard (0 si payée à temps) : "))
    if mois == 2:
        jours_du_mois = 28
    elif mois == 4 or mois == 6 or mois == 9 or mois == 11:
        jours_du_mois = 30
    else:
        jours_du_mois = 31
    jour_echeance = jour + delai
    mois_echeance = mois
    annee_echeance = ANNEE
    if jour_echeance > jours_du_mois:
        jour_echeance = jour_echeance - jours_du_mois
        mois_echeance = mois + 1
    if mois_echeance == 13:
        mois_echeance = 1
        annee_echeance = ANNEE + 1
    print("Échéance :", str(jour_echeance) + "/" + str(mois_echeance) + "/" + str(annee_echeance))
    if jours_retard > 0:
        penalites = round(montant * TAUX_ANNUEL / 100 * jours_retard / 365, 2)
        print("Pénalités :", penalites, "euros + 40 euros d'indemnité")
        total_penalites = total_penalites + penalites + 40
print("Total à réclamer ce mois-ci :", round(total_penalites, 2), "euros")

ANNEE et TAUX_ANNUEL sont écrits en majuscules : ce sont des réglages qui ne changent pas pendant le programme (on les appelle des constantes ; vous y reviendrez en semaine 2). Essai réel avec 3 factures (le taux est celui de l'exemple du Boost) :

Les trois échéances sont celles des cas de référence du Boost ; le total se vérifie à la main : 12,23 + 40 + 7,54 + 40 = 99,77 €.

Le bug du premier essai (sortie réelle, avec les montants 100, 250 et 50) :

nb_factures = 3
for i in range(nb_factures):
    total = 0
    montant = float(input("Montant en euros : "))
    total = total + montant
print("Total :", total)

Affiche Total : 50.0 au lieu de 400 : total = 0 est dans la boucle, il repart de zéro à chaque facture. On le remonte d'une ligne, avant le for.

Un calcul vérifié une fois reste juste quand on le répète : la boucle ne change pas le calcul, elle le refait. Les erreurs viennent presque toujours de ce qui est placé au mauvais niveau : un accumulateur remis à zéro dans la boucle, ou un print final décalé dans la boucle (qui s'affiche alors à chaque tour). Vérifier le nombre de lignes affichées et un total calculé à la main suffit à les repérer.

Bon réflexe ou piège ?

Les chaînes de caractères et les f-strings

Une chaîne, c'est une suite de caractères numérotés. Le texte s'appelle une chaîne de caractères (str). Chaque caractère a un indice, en commençant à 0 ; les indices négatifs comptent depuis la fin.

nom = "F00412 papeterie MARTIN 03-10-2026.pdf"
print(len(nom))
print(nom[0], nom[-1])
print(nom[:6])
print(nom[-4:])
print(nom[-14:-4])
print(nom[7:-15])

Affiche 38, puis F f, F00412, .pdf, 03-10-2026 et papeterie MARTIN. len(nom) donne le nombre de caractères. nom[:6] est une tranche : du début jusqu'à l'indice 6, non compris (les 6 premiers caractères). nom[-4:] : les 4 derniers. nom[-14:-4] : du 14e caractère avant la fin jusqu'au 4e avant la fin, non compris : la date.

Remettre la date à l'endroit. Avec des tranches et + (qui colle des chaînes, vu au Boost) :

date = "03-10-2026"
date_iso = date[6:] + "-" + date[3:5] + "-" + date[:2]
print(date_iso)

Affiche 2026-10-03. Cette écriture année-mois-jour est celle de la norme internationale ISO 8601 ; triés par ordre alphabétique, les fichiers se rangent alors par date.

Les méthodes : des outils attachés au texte. On les appelle avec un point :

brut = "  PAPETERIE martin "
print(brut.strip())
print(brut.strip().lower())
print(brut.strip().title())
print(brut.strip().title().replace(" ", "-"))
print(brut)

Affiche PAPETERIE martin, papeterie martin, Papeterie Martin, Papeterie-Martin, puis PAPETERIE martin (inchangé).

On peut les enchaîner : elles s'appliquent de gauche à droite. Et in teste si un texte en contient un autre :

nom = "F00417 transports rapides 25-10-2026.PDF"
print(nom.endswith(".pdf"), nom.lower().endswith(".pdf"))
print(nom.startswith("F"), "rapides" in nom, "Rapides" in nom)
print("412".zfill(6), "1250,50".replace(",", "."), float("1250,50".replace(",", ".")))

Affiche False True, puis True True False, puis 000412 1250.50 1250.5. Les comparaisons de texte tiennent compte des majuscules : on passe en minuscules avant de comparer. Et voici la solution à la ValueError du Boost (Boost, épisode 5) : remplacer la virgule par un point avant float.

Un texte ne se modifie pas. Une méthode renvoie un nouveau texte ; la variable d'origine ne change pas, sauf si on y range le résultat :

nom = "papeterie martin"
nom.title()
print(nom)
nom = nom.title()
print(nom)

Affiche papeterie martin, puis Papeterie Martin.

Les f-strings : assembler du texte et des valeurs. Un f devant les guillemets, et les valeurs entre accolades :

montant = 1250.5
fournisseur = "Papeterie-Martin"
print(f"{fournisseur} : {montant} euros")
print(f"{fournisseur} : {montant:.2f} euros")
print(f"[{fournisseur:<20}][{montant:>10.2f}]")
print(f"{montant=}")

Affiche Papeterie-Martin : 1250.5 euros, puis Papeterie-Martin : 1250.50 euros, puis [Papeterie-Martin ][ 1250.50], puis montant=1250.5. Après les deux-points : .2f = 2 chiffres après la virgule ; <20 = aligné à gauche sur 20 caractères ; >10 = aligné à droite sur 10. {montant=} affiche le nom et la valeur : très utile pour vérifier (jeudi). Un récapitulatif aligné :

print(f"{'Fournisseur':<20}{'Montant':>12}")
for fournisseur in ["  PAPETERIE martin ", "imprimerie LEROY", " café du coin"]:
    print(f"{fournisseur.strip().title():<20}{'à saisir':>12}")
total = 1250.5 + 89.9 + 45
print(f"{'Total':<20}{total:>10.2f} €")

Sortie réelle :

Un nom de fichier n'est pas un texte comme les autres. Sous Windows, il ne peut pas contenir < > : " / \ | ? *, et certains noms sont réservés (CON, PRN, NUL…) ; Windows ne distingue pas Facture.pdf de facture.pdf. La règle de la PME (chiffres, lettres, tirets, _) les évite tous.

« Reproduire, afficher, réduire, corriger, retester »

Rappel : lire un message d'erreur en 3 questions (voir Boost, épisode 2). Ici, il n'y a pas de message : c'est un bug silencieux (un « bug » est une erreur dans un programme).

1. Reproduire avec un cas dont vous connaissez la réponse : " Imprimerie leroy " doit donner Imprimerie-Leroy.
2. Afficher les valeurs intermédiaires avec un print de contrôle : print(f"CONTRÔLE {date=}") (le = de mercredi).
3. Réduire : isoler la plus petite partie du code qui montre encore le bug (une seule ligne, une seule valeur).
4. Suivre pas à pas avec le débogueur de Thonny (un débogueur exécute le programme ligne par ligne en montrant les variables) : Ctrl + F5 pour lancer en mode débogage, F6 pour avancer d'un grand pas, F7 d'un petit pas, menu View → Variables (Affichage → Variables si Thonny est en français) pour voir les valeurs. Basthon n'a pas de débogueur : on y utilise les print de contrôle.
5. Corriger une seule chose, puis retester tous les cas connus.

Bug 1 : l'ordre des méthodes.

brut = "  Imprimerie leroy "
propre = brut.replace(" ", "-").strip().title()
print(propre)

Affiche --Imprimerie-Leroy-. Réduit à une ligne et relu dans l'ordre : replace change tous les espaces en tirets, y compris ceux du début et de la fin ; ensuite, strip ne trouve plus d'espaces à enlever. Correction : brut.strip().title().replace(" ", "-") → Imprimerie-Leroy.

Bug 2 : la tranche décalée.

nom = "F00412 papeterie MARTIN 03-10-2026.pdf"
date = nom[-13:-4]
print(f"{date=}")
date_iso = date[6:] + "-" + date[3:5] + "-" + date[:2]
print(date_iso)

Affiche date='3-10-2026', puis 026-0--3-. Le print de contrôle montre tout de suite le problème : il manque le premier chiffre, la tranche commence un caractère trop tard. Correction : nom[-14:-4] → date='03-10-2026', puis 2026-10-03.

Bug 3 : l'accumulateur qui oublie.

total = 0
for montant in [1250.50, 89.90, 45.00, 320.00]:
    total = montant
print("Total :", total)

Affiche Total : 320.0 au lieu de 1705.4. Avec un print(f"CONTRÔLE {montant=} {total=}") dans la boucle, on voit à chaque tour que total vaut le montant du tour, et non la somme (sortie réelle) :

Correction : total = total + montant → Total : 1705.4.

Un bug silencieux, c'est un écart entre ce que vous croyez que le programme fait et ce qu'il fait vraiment. Relire le code ne montre que ce que vous croyez ; afficher les valeurs, ou les suivre au débogueur, montre ce qui se passe. Réduire le problème évite de chercher dans cinquante lignes ce qui tient en une. Et corriger une seule chose à la fois permet de savoir laquelle a réglé le problème.

Bon réflexe ou piège ?

« for ou while ? »

🎨 Carrousel récapitulatif — Semaine 1

La liste : plusieurs valeurs, un seul nom

Créer et lire une liste. Vous avez déjà parcouru des suites de valeurs entre crochets (épisode 1) : ce sont des listes. On peut les ranger dans une variable et lire chaque élément par sa position, son indice, en commençant à 0, comme pour les caractères d'un texte (épisode 3) :

montants = [1250.50, 89.90, 45.00, 320.00, 210.40, 1480.00]
print(montants[0], montants[-1])
print(montants[1:3], montants[-3:])
print(len(montants), round(sum(montants), 2), min(montants), max(montants))

Affiche 1250.5 1480.0, puis [89.9, 45.0] [320.0, 210.4, 1480.0], puis 6 3395.8 45.0 1480.0. Les tranches marchent comme pour le texte. len donne le nombre d'éléments ; sum, min et max font le total, le plus petit et le plus grand, comme SOMME, MIN et MAX dans un tableur.

Un indice qui n'existe pas. Avec trois éléments, les indices vont de 0 à 2 ; montants[3] provoque une erreur (sortie réelle) :

« Erreur d'indice : indice de liste hors limites. » Lisez-la avec la méthode du Boost (Boost, épisode 2) : la ligne, le type, la cause.

Trier.

montants = [1250.50, 89.90, 45.00, 320.00, 210.40, 1480.00]
print(sorted(montants))
print(sorted(montants, reverse=True)[:3])
print(montants)

Affiche [45.0, 89.9, 210.4, 320.0, 1250.5, 1480.0], puis [1480.0, 1250.5, 320.0] (les trois plus grosses factures), puis la liste d'origine, inchangée. sorted renvoie une nouvelle liste triée ; reverse=True trie du plus grand au plus petit.

Compléter et modifier. Contrairement au texte, une liste se modifie :

montants = [1250.50, 89.90, 45.00]
montants.append(99.99)
montants[1] = 98.90
print(montants)
print(45.00 in montants, 50 in montants)

Affiche [1250.5, 98.9, 45.0, 99.99], puis True False. .append(valeur) ajoute à la fin ; liste[indice] = valeur remplace un élément ; in teste la présence.

Parcourir.

noms = ["Papeterie-Martin", "Imprimerie-Leroy", "Café-Du-Coin"]
for nom in noms:
    print(nom)
for i in range(len(noms)):
    print(i + 1, noms[i])

La première boucle affiche les trois noms ; la seconde affiche 1 Papeterie-Martin, 2 Imprimerie-Leroy, 3 Café-Du-Coin. for nom in noms suffit le plus souvent ; range(len(noms)) sert quand on a besoin de la position (pour numéroter, ou pour lire au même rang dans deux listes).

Construire une liste dans une boucle. On part d'une liste vide [] et on ajoute ce qui nous intéresse :

grosses = []
for montant in [1250.50, 89.90, 320.00, 45.00]:
    if montant > 200:
        grosses.append(montant)
print(grosses, len(grosses))

Affiche [1250.5, 320.0] 2.

Du texte à la liste, et retour. split découpe un texte à chaque séparateur et renvoie une liste ; join fait l'inverse :

morceaux = "FACT-00418_Papeterie Martin_19-10-2026".split("_")
print(morceaux)
print(len(morceaux), morceaux[1])
print("-".join(["Papeterie", "Martin"]))
print("03-10-2026".split("-"))

Affiche ['FACT-00418', 'Papeterie Martin', '19-10-2026'], puis 3 Papeterie Martin, puis Papeterie-Martin, puis ['03', '10', '2026']. C'est l'outil qui manquait la semaine dernière : un nom de fichier dont les parties sont séparées par _ se découpe sans compter les caractères.

« Une liste en entrée, une liste en sortie »

Rappels : la boucle et la condition (voir épisode 1), la liste, append, sorted et in (voir épisode 6).

1. Une liste vide pour le résultat : martin = [].
2. Une boucle sur la liste d'entrée ; une condition ; append si elle est vraie.
3. Trier avec sorted : comme les noms commencent par la date AAAA-MM-JJ, l'ordre alphabétique est l'ordre chronologique.
4. Les doublons : une liste des noms déjà vus ; un nom déjà présent est un doublon.
5. Vérifier avec des comptages : combien en entrée, combien en sortie, combien de différents.

noms = ["2026-10-18_Papeterie-Martin_F00416.pdf", "2026-10-05_Imprimerie-Leroy_F00413.pdf",
        "2026-10-03_Papeterie-Martin_F00412.pdf", "2026-10-25_Transports-Rapides_F00417.pdf",
        "2026-10-12_Nettoyage-Pro_F00415.pdf", "2026-10-19_Papeterie-Martin_F00418.pdf",
        "2026-10-07_Café-Du-Coin_F00414.pdf", "2026-10-21_Nettoyage-Pro_F00419.pdf",
        "2026-10-03_Papeterie-Martin_F00412.pdf", "2026-10-28_Imprimerie-Leroy_F00420.pdf",
        "2026-10-30_Café-Du-Coin_F00421.pdf", "2026-10-31_Transports-Rapides_F00422.pdf"]
martin = []
for nom in noms:
    if "_Papeterie-Martin_" in nom:
        martin.append(nom)
print(len(martin), "factures Papeterie Martin")
for nom in sorted(martin):
    print(nom)
deja_vus = []
doublons = []
for nom in noms:
    if nom in deja_vus:
        doublons.append(nom)
    else:
        deja_vus.append(nom)
print("Doublons :", doublons)
print(len(noms), "noms,", len(deja_vus), "différents")

Sortie réelle :

Le doublon apparaît deux fois dans la liste triée, et le comptage le confirme : 12 noms, 11 différents. On cherche "_Papeterie-Martin_" avec ses _ pour ne pas attraper, un jour, une « Papeterie-Martinez ».

Pourquoi la date à l'envers. Triées comme du texte, les dates à la française se mélangent ; à l'envers, elles se rangent (sortie réelle) :

print(sorted(["03-10-2026", "25-09-2026", "12-10-2026"]))
print(sorted(["2026-10-03", "2026-09-25", "2026-10-12"]))

Affiche ['03-10-2026', '12-10-2026', '25-09-2026'] (le 25 septembre se retrouve après le 12 octobre), puis ['2026-09-25', '2026-10-03', '2026-10-12'].

Le piège : modifier une liste pendant qu'on la parcourt.

montants = [50.0, 80.0, 1250.5, 30.0, 320.0]
for m in montants:
    if m < 100:
        montants.remove(m)
print(montants)

Affiche [80.0, 1250.5, 320.0] : le 80 est resté ! En retirant le 50, la liste s'est décalée sous la boucle, qui a sauté l'élément suivant. La solution est la méthode du jour : construire une nouvelle liste avec ce qu'on garde.

montants = [50.0, 80.0, 1250.5, 30.0, 320.0]
gros = []
for m in montants:
    if m >= 100:
        gros.append(m)
print(gros)

Affiche [1250.5, 320.0].

Construire une nouvelle liste laisse la liste d'origine intacte : on peut toujours recompter, comparer, recommencer. C'est la même prudence que celle que vous appliquerez aux fichiers en semaine 3 : on ne touche pas aux données d'origine, on produit un résultat à côté. Et les comptages (entrée, sortie, différents) transforment une impression (« ça a l'air juste ») en vérification.

Bon réflexe ou piège ?

La fonction : une tâche, un nom

Définir et appeler.

def nettoyer(texte):
    """Renvoie le nom de fournisseur propre : sans espaces autour, majuscules aux mots, tirets."""
    return texte.strip().title().replace(" ", "-")


print(nettoyer("  PAPETERIE martin "))
print(nettoyer("imprimerie LEROY"))
propre = nettoyer(" café du coin")
print(propre, len(propre))

Affiche Papeterie-Martin, Imprimerie-Leroy, puis Café-Du-Coin 12.

• def (de define, définir) crée la fonction ; nettoyer est son nom ; texte est son paramètre : une variable qui reçoit la valeur donnée à l'appel.
• Le corps est décalé de 4 espaces. La première ligne entre triples guillemets est la docstring : une phrase qui dit ce que fait la fonction.
• return (renvoyer) donne le résultat à celui qui a appelé la fonction.
• À l'appel, nettoyer(" PAPETERIE martin "), la valeur entre parenthèses est l'argument. Le résultat peut être affiché, rangé dans une variable (propre), ou utilisé dans un calcul.
• Python lit le def sans rien exécuter ; le corps ne s'exécute qu'à l'appel. Deux lignes vides séparent la fonction du reste du programme.

Afficher ou renvoyer : la différence qui compte.

def nettoyer_affiche(texte):
    print(texte.strip().title())


def nettoyer_renvoie(texte):
    return texte.strip().title()


a = nettoyer_affiche("  leroy ")
b = nettoyer_renvoie("  leroy ")
print("a vaut", a)
print("b vaut", b)

Affiche Leroy, puis a vaut None, puis b vaut Leroy. La première fonction affiche, mais ne renvoie rien : une fonction sans return renvoie None (« rien »). On ne peut pas réutiliser son résultat. Règle : une fonction qui calcule renvoie ; c'est le programme qui décide d'afficher.

Plusieurs paramètres, une valeur par défaut, des fonctions qui s'appellent.

def date_iso(date_fr):
    """Transforme une date JJ-MM-AAAA en AAAA-MM-JJ."""
    return date_fr[6:] + "-" + date_fr[3:5] + "-" + date_fr[:2]


def nettoyer(texte):
    """Renvoie le nom de fournisseur propre : sans espaces autour, majuscules aux mots, tirets."""
    return texte.strip().title().replace(" ", "-")


def nouveau_nom(date_fr, fournisseur, numero, extension=".pdf"):
    """Assemble le nom de fichier selon la règle de la PME."""
    return date_iso(date_fr) + "_" + nettoyer(fournisseur) + "_" + numero + extension


assert date_iso("03-10-2026") == "2026-10-03"
assert nettoyer("  PAPETERIE martin ") == "Papeterie-Martin"
assert nouveau_nom("03-10-2026", "papeterie MARTIN", "F00412") == "2026-10-03_Papeterie-Martin_F00412.pdf"
print(nouveau_nom("05-10-2026", " Imprimerie leroy ", "F00413"))
print(nouveau_nom("31-10-2026", "transports rapides", "F00422", ".PDF".lower()))
print("Les 3 vérifications passent.")

Affiche 2026-10-05_Imprimerie-Leroy_F00413.pdf, puis 2026-10-31_Transports-Rapides_F00422.pdf, puis Les 3 vérifications passent. Les arguments sont reçus dans l'ordre des paramètres. extension=".pdf" est une valeur par défaut : si on ne la donne pas, c'est .pdf. Une fonction peut en appeler une autre : nouveau_nom utilise date_iso et nettoyer.

Vérifier une fonction : assert. assert condition (« affirmer ») ne dit rien si la condition est vraie, et arrête le programme si elle est fausse. C'est une vérification sur un cas connu, écrite une fois et refaite à chaque lancement. Avec une erreur dans date_iso (date_fr[0:1] au lieu de date_fr[:2]), le programme s'arrête dès la vérification (sortie réelle) :

« Erreur d'affirmation » : la fonction ne donne pas ce qu'on attend, et on le sait avant d'avoir renommé quoi que ce soit.

Les variables d'une fonction restent dans la fonction.

def total_du_mois(montants):
    total = 0
    for m in montants:
        total = total + m
    return total


print(total_du_mois([100, 250]))
print(total)

Affiche 350, puis s'arrête sur NameError: name 'total' is not defined. total est une variable locale : elle n'existe que pendant l'exécution de la fonction. Pour récupérer un résultat, on utilise return. C'est une protection : une fonction ne peut pas modifier par accident les variables du reste du programme.

Nommer une fonction par une action (un verbe ou ce qu'elle fabrique) : nettoyer, date_iso, nouveau_nom, et pas f1 ni traitement.

« Relire comme si c'était le code d'une autre »

Rappels : fonctions et docstrings (voir épisode 8), listes et range(len(...)) (voir épisode 6).

1. Des noms qui disent ce qu'ils contiennent : fournisseurs, montants, total, pas l2, x3, t.
2. Des fonctions nommées par une action, avec une docstring.
3. Des commentaires qui expliquent pourquoi, pas ce que fait la ligne (# euros : au-dessus, la facture doit être validée par la direction). Un commentaire commence par # ; Python l'ignore.
4. Des constantes en majuscules en haut du script pour les réglages : SEUIL_ALERTE = 100. On les modifie à un seul endroit.
5. Une présentation régulière (règles de la PEP 8, le guide de style officiel) : 4 espaces de retrait, des lignes courtes, deux lignes vides entre les fonctions, des noms en minuscules avec _, des espaces autour de = et après les virgules.
6. Même résultat avant et après : on relance et on compare la sortie.

Avant :

l2 = ["  PAPETERIE martin ", "imprimerie LEROY", " café du coin"]
x3 = [1250.5, 89.9, 45.0]
t = 0
for i in range(len(l2)):
    tmp = l2[i].strip().title()
    if x3[i] > 100:
        print(tmp, "!!")
    else:
        print(tmp)
    t = t + x3[i]
print(t)

Après :

"""Affiche les fournisseurs du mois, signale les factures au-dessus du seuil et calcule le total."""

SEUIL_ALERTE = 100  # euros : au-dessus, la facture doit être validée par la direction


def nettoyer(texte):
    """Renvoie le nom de fournisseur sans espaces autour, avec une majuscule à chaque mot."""
    return texte.strip().title()


fournisseurs = ["  PAPETERIE martin ", "imprimerie LEROY", " café du coin"]
montants = [1250.5, 89.9, 45.0]
total = 0
for i in range(len(fournisseurs)):
    nom = nettoyer(fournisseurs[i])
    if montants[i] > SEUIL_ALERTE:
        print(nom, "!!")
    else:
        print(nom)
    total = total + montants[i]
print(total)

Les deux versions affichent exactement la même chose (sortie réelle) :

La docstring en tête de fichier dit à quoi sert le script ; le commentaire explique enfin le 100 ; range(len(fournisseurs)) sert ici à lire le montant au même rang que le fournisseur.

Un script de fin de mois s'écrit une fois et se relit chaque mois, souvent dans l'urgence, parfois par quelqu'un d'autre. Un nom clair évite d'avoir à remonter le code pour comprendre une variable ; une constante évite de chercher un nombre perdu au milieu des lignes ; une présentation régulière laisse voir la structure d'un coup d'œil. Comparer la sortie avant et après garantit qu'en rendant le code lisible, on ne l'a pas cassé.

Bon réflexe ou piège ?

« Faut-il en faire une fonction ? »

🎨 Carrousel récapitulatif — Semaine 2

Les modules de la bibliothèque standard

Un module, c'est une boîte à outils livrée avec Python. La bibliothèque standard contient des centaines de modules, déjà installés. On les charge avec import :

• import datetime charge le module ; on écrit ensuite datetime.date(…) ;
• from datetime import date, timedelta charge seulement deux outils, qu'on utilise directement : date(…), timedelta(…).

Les import se placent en haut du script.

Les dates : date et timedelta.

from datetime import date, timedelta

facture = date(2026, 10, 3)
echeance = facture + timedelta(days=60)
print(facture, echeance)
print(echeance.day, echeance.month, echeance.year)
paiement = date(2026, 12, 14)
retard = paiement - echeance
print(retard.days, "jours de retard")

Affiche 2026-10-03 2026-12-02, puis 2 12 2026, puis 12 jours de retard. date(année, mois, jour) crée une date ; timedelta(days=60) est une durée ; date + durée = date ; date − date = durée, dont .days donne le nombre de jours. Le module connaît la longueur des mois et les années bissextiles.

La promesse du Boost tenue. Les quatre cas de référence du Boost, recalculés en une ligne chacun :

from datetime import date, timedelta

print(date(2026, 3, 5) + timedelta(days=20))
print(date(2026, 4, 15) + timedelta(days=28))
print(date(2028, 2, 15) + timedelta(days=20))
print(date(2026, 12, 20) + timedelta(days=28))
print(date(2026, 1, 30) + timedelta(days=30))

Affiche 2026-03-25, 2026-05-13, 2028-03-06, 2027-01-17 : les mêmes échéances que votre calculateur. Et le cas qui piégeait la règle du Boost, le 30 janvier + 30 jours, donne 2026-03-01, et non un « 29 février » qui n'existe pas. Pourquoi avoir appris la règle d'abord ? Parce que c'est elle qui vous permet de vérifier ce que fait le module.

La fin du mois et les « 45 jours fin de mois ». Le dernier jour d'un mois, c'est la veille du 1er du mois suivant :

from datetime import date, timedelta


def fin_de_mois(jour):
    """Renvoie le dernier jour du mois de la date donnée."""
    if jour.month == 12:
        premier_suivant = date(jour.year + 1, 1, 1)
    else:
        premier_suivant = date(jour.year, jour.month + 1, 1)
    return premier_suivant - timedelta(days=1)


facture = date(2026, 3, 1)
print("45 jours fin de mois :", fin_de_mois(facture + timedelta(days=45)))
print("fin de mois 45 jours :", fin_de_mois(facture) + timedelta(days=45))
print(fin_de_mois(date(2028, 2, 10)), fin_de_mois(date(2026, 12, 31)))

Affiche 45 jours fin de mois : 2026-04-30, puis fin de mois 45 jours : 2026-05-15, puis 2028-02-29 2026-12-31. Il existe deux façons de compter : ajouter 45 jours puis aller à la fin du mois, ou aller à la fin du mois puis ajouter 45 jours. Pour une facture du 1er mars, elles donnent le 30 avril et le 15 mai : ce sont les deux résultats de l'exemple de la DGCCRF. C'est le contrat qui dit laquelle s'applique.

Lire et écrire une date sous forme de texte.

from datetime import datetime

facture = datetime.strptime("03-10-2026", "%d-%m-%Y").date()
print(facture, type(facture))
print(facture.strftime("%Y-%m-%d"), facture.strftime("%d/%m/%Y"), facture.isoformat())

Affiche 2026-10-03 <class 'datetime.date'>, puis 2026-10-03 03/10/2026 2026-10-03. strptime (string parse time, lire une date dans un texte) a besoin du format : %d le jour, %m le mois, %Y l'année sur 4 chiffres ; .date() garde la date sans l'heure. strftime (string format time) fait l'inverse. isoformat() donne directement le format AAAA-MM-JJ de la règle de la PME. (Depuis Python 3.14, on peut aussi écrire date.strptime(…) ; la forme ci-dessus marche dès Python 3.12.)

Les chemins : pathlib. Un chemin indique où se trouve un fichier ou un dossier. Path le représente, et l'opérateur / assemble les morceaux, quel que soit le système (Windows écrit \, macOS et Linux /) :

from pathlib import Path

FACTURES = Path("entrainement") / "factures"
print(FACTURES, FACTURES.exists())
nombre = 0
for fichier in sorted(FACTURES.iterdir()):
    nombre = nombre + 1
    if nombre <= 3:
        print(fichier.name, "|", fichier.stem, "|", fichier.suffix)
print(nombre, "fichiers dans", FACTURES)

Sortie réelle (sous macOS ou Linux ; Windows affiche entrainement\factures) :

exists() dit si le chemin existe ; iterdir() donne le contenu du dossier, dans un ordre qui n'est pas garanti (d'où sorted) ; .name est le nom complet, .stem le nom sans extension, .suffix l'extension. Lire un dossier ne modifie rien.

Un piège selon le système : les majuscules. glob("*.pdf") trouve les fichiers dont le nom correspond au motif (* = n'importe quels caractères) :

from pathlib import Path

FACTURES = Path("entrainement") / "factures"
minuscules = 0
for fichier in FACTURES.glob("*.pdf"):
    minuscules = minuscules + 1
pdf = 0
for fichier in FACTURES.iterdir():
    if fichier.suffix.lower() == ".pdf":
        pdf = pdf + 1
print(minuscules, "trouvés avec glob(\"*.pdf\") ;", pdf, "avec suffix.lower()")

Sous macOS et Linux, affiche 34 trouvés avec glob("*.pdf") ; 40 avec suffix.lower() : les 6 fichiers en .PDF échappent au motif, qui y respecte les majuscules ; sous Windows, les deux comptes donnent 40. Comparer fichier.suffix.lower() marche partout.

Ne donnez jamais à votre script le nom d'un module. Un fichier datetime.py dans votre dossier de travail cache le vrai module (sortie réelle sous Python 3.15) :

« Impossible d'importer date depuis datetime (pensez à renommer datetime.py, qui porte le même nom qu'un module de la bibliothèque standard). » Python 3.12 affiche seulement ImportError: cannot import name 'date' from 'datetime' (datetime.py) : le nom du fichier, entre parenthèses, est l'indice.

« Chercher, lire la fiche, essayer l'exemple, adapter »

Rappel : les modules et strptime (voir épisode 11).

1. Chercher au bon endroit : la documentation officielle, docs.python.org, existe en français (menu des langues en haut de page) ; choisissez la version de Python que vous utilisez. Une page par module ; la recherche se fait par mot (« strptime »).
2. Lire la fiche : la signature (le nom et les paramètres, par exemple datetime.strptime(date_string, format)), une phrase qui dit ce que fait l'outil, puis les détails et les cas limites. Repérez les mentions « Ajouté dans la version… » : un outil récent peut manquer à une version plus ancienne.
3. Essayer l'exemple tel quel dans la console, avant de l'adapter.
4. Adapter à votre cas, puis vérifier sur un cas connu.
5. help() dans la console affiche la documentation intégrée : help(datetime.strptime) (touche q pour sortir si elle s'affiche page par page).

Ce que la documentation de datetime donne pour nos trois formats (tableau des codes de format) : %d jour sur deux chiffres, %m mois, %Y année sur quatre chiffres, %y année sur deux chiffres ; les autres caractères du format (-, ., /) doivent se retrouver tels quels dans le texte.

from datetime import datetime

print(datetime.strptime("03-10-2026", "%d-%m-%Y").date())
print(datetime.strptime("2026.10.05", "%Y.%m.%d").date())
print(datetime.strptime("05/10/26", "%d/%m/%y").date())

Affiche 2026-10-03, 2026-10-05 et 2026-10-05. Un texte qui ne correspond pas au format s'arrête sur une erreur claire (dernière ligne de la sortie réelle) :

« Les données de date '2026.10.05' ne correspondent pas au format '%d-%m-%Y'. » Le message est précédé de plusieurs lignes qui citent des fichiers internes de Python (_strptime.py) : appliquez la méthode du Boost, la dernière ligne d'abord.

Reconnaître une réponse périmée. print "…" sans parenthèses, c'est Python 2, dont le support a pris fin le 1er janvier 2020 : passez votre chemin. Une bonne réponse indique sa date et la version de Python ; et même bonne, elle se vérifie sur un cas connu.

La documentation officielle est écrite par ceux qui maintiennent Python, pour la version que vous utilisez. Une réponse trouvée ailleurs peut viser une autre version, un autre problème, ou contenir une erreur. Essayer l'exemple tel quel avant de l'adapter permet de savoir si un problème vient de l'outil ou de votre adaptation.

Bon réflexe ou piège ?

Lire et écrire des fichiers

Ouvrir un fichier : with open.

from pathlib import Path

releve = Path("entrainement") / "releves" / "releve-2026-10-01-au-10.csv"
with open(releve, encoding="utf-8-sig") as fichier:
    for ligne in fichier:
        print(ligne.strip())
        break

Affiche date;fournisseur;numero;montant : la première ligne du relevé. open ouvre le fichier en lecture ; with (« avec ») garantit qu'il sera refermé à la fin du bloc décalé, même en cas de problème. Un fichier texte se parcourt ligne par ligne avec for ; .strip() enlève le retour à la ligne. (break arrête la boucle après la première ligne : c'est l'instruction citée lundi dernier, utilisée ici une seule fois.)

L'encodage : préciser toujours. Un fichier texte est une suite d'octets ; l'encodage dit comment les transformer en lettres. Les accents sont la première victime d'un mauvais encodage. Deux règles :

• précisez toujours encoding= : sans lui, Python 3.12 utilise l'encodage du système (souvent Windows-1252 sous Windows), et Python 3.15 utilise UTF-8 partout ; votre script se comporterait différemment selon l'ordinateur ;
• les CSV « UTF-8 » enregistrés par un tableur commencent souvent par une marque invisible, le BOM (byte order mark). Lus en utf-8, elle se colle au premier mot ; lus en utf-8-sig, elle disparaît :

import csv
from pathlib import Path

releve = Path("entrainement") / "releves" / "releve-2026-10-01-au-10.csv"
with open(releve, encoding="utf-8") as fichier:
    print(next(csv.reader(fichier, delimiter=";")))
with open(releve, encoding="utf-8-sig") as fichier:
    print(next(csv.reader(fichier, delimiter=";")))

Affiche ['date', 'fournisseur', 'numero', 'montant'], puis ['date', 'fournisseur', 'numero', 'montant']. Le , c'est le BOM. (next(…) lit seulement la première ligne.) Si des lettres accentuées s'affichent comme é, essayez l'autre encodage courant des fichiers Windows : encoding="cp1252".

Lire un CSV : le module csv. Un CSV (comma-separated values) est un tableau en texte, une ligne par rangée, avec un séparateur entre les colonnes. Avec un tableur réglé en français, c'est souvent le point-virgule, car la virgule sert aux décimales.

import csv
from pathlib import Path

releve = Path("entrainement") / "releves" / "releve-2026-10-01-au-10.csv"
with open(releve, encoding="utf-8-sig", newline="") as fichier:
    lecteur = csv.reader(fichier, delimiter=";")
    for ligne in lecteur:
        print(ligne)

Sortie réelle (début) :

Chaque ligne devient une liste de textes. newline="" est recommandé par la documentation du module pour tous les fichiers CSV. Avec le mauvais séparateur (delimiter=","), toute la ligne reste en un seul morceau : ['date;fournisseur;numero;montant'].

DictReader : chaque ligne devient un dictionnaire. csv.DictReader utilise la première ligne comme noms de colonnes ; on lit ensuite ligne["montant"] au lieu de ligne[3]. (Les dictionnaires seront étudiés en semaine 4 ; ici, retenez seulement cette écriture.) Les montants sont des textes avec une virgule : .replace(",", ".") puis float (épisode 3).

import csv
from pathlib import Path

RELEVES = Path("entrainement") / "releves"
for releve in sorted(RELEVES.glob("*.csv")):
    total = 0
    nombre = 0
    with open(releve, encoding="utf-8-sig", newline="") as fichier:
        for ligne in csv.DictReader(fichier, delimiter=";"):
            total = total + float(ligne["montant"].replace(",", "."))
            nombre = nombre + 1
    print(f"{releve.name:<30}{nombre:>4} lignes{total:>12.2f} €")

Sortie réelle :

Écrire un fichier : dans un nouveau fichier, jamais par-dessus. open(chemin, "w") ouvre en écriture : il crée le fichier, ou efface son contenu s'il existe déjà, sans prévenir. D'où la règle du livre : on vérifie d'abord avec exists().

import csv
from pathlib import Path

RELEVES = Path("entrainement") / "releves"
SORTIES = Path("entrainement") / "sorties"
SORTIES.mkdir(exist_ok=True)
recap = SORTIES / "recapitulatif.txt"
if recap.exists():
    print("Le fichier", recap, "existe déjà : je ne l'écrase pas.")
else:
    with open(recap, "w", encoding="utf-8") as sortie:
        for releve in sorted(RELEVES.glob("*.csv")):
            total = 0
            with open(releve, encoding="utf-8-sig", newline="") as fichier:
                for ligne in csv.DictReader(fichier, delimiter=";"):
                    total = total + float(ligne["montant"].replace(",", "."))
            sortie.write(f"{releve.name} : {total:.2f} euros\n")
    print("Écrit :", recap)
    print(recap.read_text(encoding="utf-8"))

Premier lancement (sortie réelle) :

Deuxième lancement : Le fichier entrainement/sorties/recapitulatif.txt existe déjà : je ne l'écrase pas. SORTIES.mkdir(exist_ok=True) crée le dossier sorties s'il n'existe pas, et ne fait rien s'il existe. sortie.write(…) écrit du texte ; "\n" est le retour à la ligne. read_text relit tout le fichier d'un coup, pour vérifier.

« Copie, simulation, action, vérification »

Rappels : nouveau_nom (voir épisode 10), pathlib (voir épisode 11), fichiers CSV (voir épisode 13).

1. Copie : on travaille dans le dossier d'entraînement, jamais dans un vrai dossier.
2. Simulation : une constante SIMULATION = True en haut du script ; le script affiche « je rangerais A -> B » et ne touche à rien.
3. Relecture de la liste affichée : les noms sont-ils justes ? les conflits signalés ?
4. Action : SIMULATION = False, on relance.
5. Vérification : le nombre de fichiers avant et après est le même ; rien ne s'est perdu.

Et trois règles qui ne se discutent pas : jamais d'écrasement (si la destination existe, le fichier est mis de côté) ; jamais de suppression (aucun script du livre n'efface) ; ce qui n'est pas reconnu reste à sa place et part dans la liste « à traiter à la main ».

Pourquoi exists() avant chaque renommage. rename déplace et renomme un fichier. Si la destination existe déjà, son comportement dépend du système : sous macOS et Linux, l'ancien fichier est remplacé sans prévenir ; sous Windows, Python s'arrête sur une FileExistsError. Démonstration dans un dossier d'essai, sous Linux (sortie réelle) : après a.txt.rename(b.txt), il ne reste qu'un fichier, b.txt : contenu de A. Le contenu de B a disparu. D'où le test systématique.

Le script de rangement :

"""Renomme et range les factures du dossier d'entraînement (copie, simulation, action, vérification)."""
from pathlib import Path

SIMULATION = True  # True : le script affiche ce qu'il ferait, sans rien toucher
DOSSIER = Path("entrainement")
FACTURES = DOSSIER / "factures"
RANGEES = DOSSIER / "rangees"


def date_iso(date_fr):
    """Transforme une date JJ-MM-AAAA en AAAA-MM-JJ."""
    return date_fr[6:] + "-" + date_fr[3:5] + "-" + date_fr[:2]


def nettoyer(texte):
    """Renvoie le nom de fournisseur propre : sans espaces autour, majuscules aux mots, tirets."""
    return texte.strip().title().replace(" ", "-")


def nouveau_nom(ancien):
    """Renvoie le nouveau nom d'une facture, ou "" si le nom ne suit aucun modèle connu."""
    if not ancien.lower().endswith(".pdf"):
        return ""
    base = ancien[:-4]
    morceaux = base.split("_")
    if base.startswith("FACT-") and len(morceaux) == 3:
        numero = "F" + morceaux[0][5:]
        fournisseur = morceaux[1]
        date = morceaux[2]
    elif base.startswith("F") and base[6:7] == " " and len(base) > 17:
        numero = base[:6]
        fournisseur = base[7:-11]
        date = base[-10:]
    else:
        return ""
    return date_iso(date) + "_" + nettoyer(fournisseur) + "_" + numero + ".pdf"


def compter_fichiers(dossier):
    """Renvoie le nombre de fichiers dans le dossier et tous ses sous-dossiers."""
    nombre = 0
    for chemin in dossier.rglob("*"):
        if chemin.is_file():
            nombre = nombre + 1
    return nombre


if not FACTURES.exists():
    print("Dossier introuvable :", FACTURES, "- rien n'est fait.")
else:
    avant = compter_fichiers(DOSSIER)
    print("Mode simulation :", SIMULATION, "-", avant, "fichiers avant")
    a_traiter = []
    prevus = []
    for fichier in sorted(FACTURES.iterdir()):
        nom = nouveau_nom(fichier.name)
        if nom == "":
            a_traiter.append(fichier.name)
        else:
            destination = RANGEES / nom.split("_")[1] / nom
            if destination.exists() or destination in prevus:
                a_traiter.append(fichier.name + " (conflit : " + nom + " existe déjà)")
            elif SIMULATION:
                print("je rangerais", fichier.name, "->", destination)
                prevus.append(destination)
            else:
                destination.parent.mkdir(parents=True, exist_ok=True)
                fichier.rename(destination)
                prevus.append(destination)
    if SIMULATION:
        print(len(prevus), "factures à ranger ;", len(a_traiter), "à traiter à la main :")
    else:
        print(len(prevus), "factures rangées ;", len(a_traiter), "à traiter à la main :")
    for nom in a_traiter:
        print("  ", nom)
    apres = compter_fichiers(DOSSIER)
    if apres != avant:
        print(apres, "fichiers après : ATTENTION, écart !")
    elif SIMULATION:
        print(apres, "fichiers après : rien n'a bougé")
    else:
        print(apres, "fichiers après : aucun fichier perdu")

Les nouveautés, en une ligne chacune : RANGEES / nom.split("_")[1] / nom construit le chemin rangees/Fournisseur/nouveau-nom.pdf ; destination.parent est le dossier qui contiendra le fichier, et mkdir(parents=True, exist_ok=True) le crée s'il manque (avec les dossiers intermédiaires) ; fichier.rename(destination) déplace et renomme ; dossier.rglob("*") parcourt le dossier et tous ses sous-dossiers, et is_file() ne garde que les fichiers ; la liste prevus évite que deux fichiers visent la même destination pendant la simulation.

Simulation (sortie réelle, début et fin ; 34 lignes « je rangerais » au total) :

44 fichiers : les 40 factures, les 3 relevés et le fichier Excel des fournisseurs (il servira en semaine 4). La facture F00412 est arrivée deux fois (par l'export et par courriel) : la seconde copie est mise de côté, pas écrasée.

Action (SIMULATION = False, sortie réelle) : 34 factures rangées ; 6 à traiter à la main : (même liste), puis 44 fichiers après : aucun fichier perdu. Relancé une seconde fois, le script ne range plus rien (0 factures rangées) : les factures sont déjà rangées, les 6 autres sont toujours de côté. Contenu du dossier rangees après l'action (sortie réelle d'un petit programme de comptage) :

Fusionner les trois relevés en un seul fichier, avec l'en-tête une seule fois :

"""Fusionne les relevés du mois en un seul fichier CSV (l'en-tête une seule fois)."""
import csv
from pathlib import Path

RELEVES = Path("entrainement") / "releves"
SORTIES = Path("entrainement") / "sorties"
FUSION = SORTIES / "releves-octobre.csv"

SORTIES.mkdir(exist_ok=True)
if FUSION.exists():
    print(FUSION, "existe déjà : je ne l'écrase pas.")
else:
    lignes = 0
    with open(FUSION, "w", encoding="utf-8-sig", newline="") as sortie:
        ecrivain = csv.writer(sortie, delimiter=";")
        entete_ecrit = False
        for releve in sorted(RELEVES.glob("*.csv")):
            with open(releve, encoding="utf-8-sig", newline="") as fichier:
                lecteur = csv.reader(fichier, delimiter=";")
                entete = next(lecteur)
                if not entete_ecrit:
                    ecrivain.writerow(entete)
                    entete_ecrit = True
                for ligne in lecteur:
                    ecrivain.writerow(ligne)
                    lignes = lignes + 1
    print(lignes, "lignes écrites dans", FUSION)

Affiche 39 lignes écrites dans entrainement/sorties/releves-octobre.csv : 12 + 11 + 16. csv.writer écrit des lignes au format CSV ; next(lecteur) lit l'en-tête de chaque relevé, qu'on n'écrit que la première fois ; utf-8-sig à l'écriture ajoute le BOM, pour que le tableur reconnaisse les accents.

Lancer le script chaque mois, depuis le terminal. Un terminal (Invite de commandes ou PowerShell sous Windows, Terminal sous macOS) permet de lancer un script sans éditeur : on se place dans le dossier de travail avec cd, puis on tape python ranger.py (sous Windows, py ranger.py marche aussi). Thonny ou un double-clic font la même chose ; le terminal a l'avantage de garder l'affichage à l'écran.

La simulation transforme une action irréversible en liste à relire : vous voyez chaque renommage avant qu'il ait lieu. La copie rend toute erreur sans conséquence : on supprime le dossier d'entraînement et on le décompresse de nouveau. Le test exists() empêche le seul accident vraiment grave, l'écrasement. Et le comptage avant / après prouve, par un nombre, qu'aucun fichier ne s'est perdu.

Bon réflexe ou piège ?

« Avant de lancer un script sur des fichiers »

🎨 Carrousel récapitulatif — Semaine 3

Le dictionnaire : une valeur, retrouvée par son nom

Créer, lire, ajouter. Un dictionnaire associe des clés à des valeurs, entre accolades, comme un vrai dictionnaire associe un mot à sa définition :

dossiers = {"Papeterie Martin": "Papeterie-Martin", "Imprimerie Leroy": "Imprimerie-Leroy"}
print(dossiers["Papeterie Martin"])
dossiers["Café du Coin"] = "Cafe-du-Coin"
print(len(dossiers), "Café du Coin" in dossiers, "Nettoyage Pro" in dossiers)
print(dossiers.get("Nettoyage Pro", "inconnu"))
for nom, dossier in dossiers.items():
    print(nom, "->", dossier)

Affiche Papeterie-Martin, puis 3 True False, puis inconnu, puis les trois paires Papeterie Martin -> Papeterie-Martin, Imprimerie Leroy -> Imprimerie-Leroy, Café du Coin -> Cafe-du-Coin.

• dossiers[cle] donne la valeur ; dossiers[cle] = valeur ajoute une paire (ou remplace la valeur si la clé existe déjà : une clé est unique).
• in teste si une clé existe ; not in teste l'inverse.
• .get(cle, defaut) renvoie la valeur, ou defaut si la clé n'existe pas. Avec les crochets, une clé absente arrête le programme : KeyError: 'Nettoyage Pro' (« erreur de clé »).
• .items() donne les paires, qu'on parcourt avec deux variables ; les paires restent dans l'ordre où on les a ajoutées.

Une table de correspondance. Toutes les écritures d'un même fournisseur, ramenées au nom officiel (les clés sont écrites en minuscules, et on passe le texte brut en minuscules avant de chercher) :

CORRESPONDANCE = {
    "papeterie martin": "Papeterie Martin",
    "papeterie martin sarl": "Papeterie Martin",
    "pap. martin": "Papeterie Martin",
    "imprimerie leroy": "Imprimerie Leroy",
    "leroy impressions": "Imprimerie Leroy",
    "café du coin": "Café du Coin",
    "cafe du coin": "Café du Coin",
    "nettoyage pro": "Nettoyage Pro",
}
for brut in ["PAPETERIE MARTIN", "Papeterie Martin SARL", " pap. martin", "Leroy Impressions", "CAFE DU COIN", "Bureau Express"]:
    officiel = CORRESPONDANCE.get(brut.strip().lower(), "")
    if officiel == "":
        print(f"{brut:<24} -> inconnu : à ajouter à la table")
    else:
        print(f"{brut:<24} -> {officiel}")

Sortie réelle :

Un dictionnaire peut s'écrire sur plusieurs lignes, une paire par ligne : c'est plus lisible.

Totaliser par clé. La ligne à retenir de la semaine : totaux[f] = totaux.get(f, 0) + montant. Si le fournisseur n'a pas encore de total, get renvoie 0 ; sinon, son total actuel.

factures = [("Papeterie Martin", 1250.50), ("Imprimerie Leroy", 89.90), ("Papeterie Martin", 240.00),
            ("Café du Coin", 655.00), ("Imprimerie Leroy", 520.00), ("Papeterie Martin", 64.80)]
totaux = {}
nombres = {}
for fournisseur, montant in factures:
    totaux[fournisseur] = totaux.get(fournisseur, 0) + montant
    nombres[fournisseur] = nombres.get(fournisseur, 0) + 1
for fournisseur, total in totaux.items():
    print(f"{fournisseur:<18}{nombres[fournisseur]:>2} factures{total:>10.2f} €")
print(round(sum(totaux.values()), 2))

Sortie réelle :

.values() donne les valeurs seules : leur somme doit égaler le total de toutes les factures, c'est le contrôle.

Le tuple : des valeurs qui vont ensemble. Chaque facture ci-dessus est écrite entre parenthèses : ("Papeterie Martin", 1250.50). C'est un tuple : une suite de valeurs groupées, qu'on ne modifie pas. On le « déballe » dans plusieurs variables, et une fonction peut en renvoyer un pour donner deux résultats :

facture = ("F00412", "Papeterie Martin", 1250.50)
numero, fournisseur, montant = facture
print(numero, fournisseur, montant, len(facture))


def extremes(montants):
    """Renvoie la plus petite et la plus grosse facture."""
    return min(montants), max(montants)


petite, grosse = extremes([1250.50, 89.90, 240.00, 655.00])
print(petite, grosse)

Affiche F00412 Papeterie Martin 1250.5 3, puis 89.9 1250.5. Essayer de modifier un tuple (facture[2] = 1300.00) arrête le programme : TypeError: 'tuple' object does not support item assignment (« un tuple ne permet pas de modifier un élément »). C'est voulu : une facture enregistrée ne change pas.

L'ensemble : des valeurs distinctes. Un ensemble (set) ne garde chaque valeur qu'une fois, sans ordre :

fournisseurs = ["Papeterie Martin", "Imprimerie Leroy", "Papeterie Martin", "Café du Coin", "Imprimerie Leroy"]
distincts = set(fournisseurs)
print(len(fournisseurs), len(distincts))
print(sorted(distincts))
print("Café du Coin" in distincts)
deja_vus = set()
for nom in ["F00412", "F00413", "F00412"]:
    if nom in deja_vus:
        print("Doublon :", nom)
    deja_vus.add(nom)

Affiche 5 3, puis ['Café du Coin', 'Imprimerie Leroy', 'Papeterie Martin'], puis True, puis Doublon : F00412. set() crée un ensemble vide ; .add ajoute ; in y est très rapide. C'est la liste des « déjà vus » de l'épisode 7, en plus simple. Pour l'afficher dans l'ordre, on le trie.

« Lire, regrouper, écrire, vérifier »

Rappels : lire un CSV et écrire sans écraser (voir épisode 13), totaliser par clé (voir épisode 16).

1. Lire les trois relevés avec DictReader (épisode 13).
2. Regrouper avec un dictionnaire : totaux[fournisseur] = totaux.get(fournisseur, 0) + montant.
3. Écrire un CSV pour le tableur : séparateur ;, virgule décimale (on formate avec :.2f puis .replace(".", ",")), utf-8-sig pour les accents, jamais par-dessus un fichier existant.
4. Vérifier : la somme des totaux doit égaler le total de toutes les lignes des relevés.

"""Écrit le total des factures par fournisseur, à partir des relevés du mois, dans un CSV pour le tableur."""
import csv
from pathlib import Path

RELEVES = Path("entrainement") / "releves"
SORTIES = Path("entrainement") / "sorties"
TOTAUX = SORTIES / "totaux-fournisseurs.csv"

totaux = {}
total_releves = 0
for releve in sorted(RELEVES.glob("*.csv")):
    with open(releve, encoding="utf-8-sig", newline="") as fichier:
        for ligne in csv.DictReader(fichier, delimiter=";"):
            montant = float(ligne["montant"].replace(",", "."))
            fournisseur = ligne["fournisseur"]
            totaux[fournisseur] = totaux.get(fournisseur, 0) + montant
            total_releves = total_releves + montant

SORTIES.mkdir(exist_ok=True)
if TOTAUX.exists():
    print(TOTAUX, "existe déjà : je ne l'écrase pas.")
else:
    with open(TOTAUX, "w", encoding="utf-8-sig", newline="") as sortie:
        ecrivain = csv.writer(sortie, delimiter=";")
        ecrivain.writerow(["fournisseur", "total"])
        for fournisseur in sorted(totaux):
            ecrivain.writerow([fournisseur, f"{totaux[fournisseur]:.2f}".replace(".", ",")])
    print("Écrit :", TOTAUX)
    print(TOTAUX.read_text(encoding="utf-8-sig"))
somme = round(sum(totaux.values()), 2)
print("Contrôle :", somme, "=", round(total_releves, 2), "?", somme == round(total_releves, 2))

Premier lancement, sortie réelle :

Deuxième lancement : entrainement/sorties/totaux-fournisseurs.csv existe déjà : je ne l'écrase pas., puis le même contrôle. Le total du mois est celui que vous aviez calculé en semaine 3 : 14 475,98 €. sorted(totaux) parcourt les clés dans l'ordre alphabétique. Les montants sont arrondis à l'affichage seulement ; le contrôle compare des totaux arrondis au centime.

Le dictionnaire fait en une ligne ce que le tableau croisé faisait en dix clics, et il le refait à l'identique chaque mois. Le contrôle final transforme un récapitulatif « qui a l'air juste » en récapitulatif prouvé : si une ligne était oubliée ou comptée deux fois, les deux nombres différeraient. Et le format (;, virgule, utf-8-sig) est choisi pour le tableur du destinataire, pas pour Python.

Bon réflexe ou piège ?

Paquets, environnements virtuels et pip

Bibliothèque standard ou paquet à installer. La bibliothèque standard (semaine 3) ne lit pas les fichiers Excel. D'autres développeurs ont écrit des bibliothèques pour cela et les publient sur PyPI (Python Package Index, pypi.org), le catalogue officiel des paquets Python. On les installe avec pip, l'installateur livré avec Python.

Un projet, un environnement. Un environnement virtuel est un dossier (souvent nommé .venv) qui contient une copie de travail de Python et les paquets d'un seul projet. Installer dedans ne touche ni au Python de l'ordinateur ni aux autres projets ; en cas de problème, on supprime le dossier et on le recrée.

Dans un terminal, depuis votre dossier de travail :

Une fois l'environnement activé, son nom apparaît au début de la ligne de commande : (.venv). Session réelle (terminal Linux, Python 3.15.2, le 31/10/2026 ; à la première installation, pip affiche Downloading au lieu de Using cached) :

pip a aussi installé et-xmlfile, dont openpyxl a besoin : c'est une dépendance. Avec Thonny, pas de terminal : menu Outils → Gérer les paquets, recherche « openpyxl », bouton « Installer » (Thonny utilise son propre environnement). Sans l'environnement activé (ou sans installation), import openpyxl s'arrête sur ModuleNotFoundError: No module named 'openpyxl' (« aucun module nommé openpyxl ») : c'est le signe qu'on n'est pas dans le bon environnement.

Vérifier le nom exact avant d'installer. Des paquets malveillants sont régulièrement publiés sur PyPI sous des noms proches de paquets connus (openpyxI avec un i majuscule, open-pyxl…) : c'est le typosquatting. Avant d'installer, vérifiez le nom sur la page officielle du projet (pypi.org/project/openpyxl, lien depuis la documentation d'openpyxl), et tapez-le sans faute.

Lire le fichier Excel, sans le modifier.

from pathlib import Path

import openpyxl

FOURNISSEURS = Path("entrainement") / "fournisseurs.xlsx"
classeur = openpyxl.load_workbook(FOURNISSEURS, read_only=True, data_only=True)
print(classeur.sheetnames)
feuille = classeur["Fournisseurs"]
dossiers = {}
for nom, dossier, code in feuille.iter_rows(min_row=2, values_only=True):
    dossiers[nom] = dossier
    print(f"{nom:<20}{dossier:<20}{code}")
classeur.close()
print(len(dossiers), "fournisseurs lus")

Sortie réelle :

load_workbook ouvre le classeur ; read_only=True l'ouvre en lecture seule (rien ne peut y être écrit), data_only=True donne les valeurs calculées plutôt que les formules. sheetnames liste les feuilles ; classeur["Fournisseurs"] en choisit une ; iter_rows(min_row=2, values_only=True) parcourt les lignes à partir de la deuxième (la première contient les titres), chacune sous forme de tuple déballé en trois variables. classeur.close() referme le fichier, ce que la documentation demande en mode lecture seule. La première colonne contient le nom tel que le calcule nouveau_nom : c'est la clé du dictionnaire qui servira vendredi.

Sans installation : on peut aussi enregistrer la feuille en CSV depuis le tableur et la lire avec le module csv (épisode 13). openpyxl évite cette manipulation chaque mois.

« Demander, relire, tester, garder ou refuser »

Rappels : la règle d'or (Boost), copie et simulation (voir épisode 14).

1. Avant : le cadre.

• Votre employeur autorise-t-il l'IA pour ce travail, et avec quel outil ? Beaucoup d'entreprises fournissent un outil (offre professionnelle) ou en interdisent d'autres : suivez la règle de votre entreprise.
• Avec un compte personnel, vos conversations peuvent servir à entraîner les modèles, sauf si vous le refusez dans les réglages : « Améliorer le modèle pour tous » (ChatGPT, Paramètres → Gestion des données) ; « Aider à améliorer nos modèles d'IA » (Claude, Paramètres → Confidentialité). Les offres professionnelles de ces services ne s'en servent pas par défaut ; vérifiez celle que vous utilisez.

2. Demander : précis, et sans rien de confidentiel.

• Le contexte, le but, les contraintes, un exemple inventé : « Mon script Python range des factures (exemple de nom : FACT-00412_Papeterie Martin_01-10-2026.pdf). Ajoute un contrôle des doublons. Contraintes : ne supprime rien, n'écrase rien, signale seulement ; reste compatible avec ma constante SIMULATION. »
• Jamais de vrais noms de clients, montants, fichiers de l'entreprise ou données personnelles.

3. Relire : chaque ligne comprise. Cherchez en priorité ce qui agit sur les fichiers ou ailleurs : unlink ou remove (suppression), rename sans exists(), open(…, "w") sur un fichier existant, une adresse internet, un envoi. Si une ligne vous échappe, demandez une explication ligne par ligne.

4. Tester : sur la copie, en simulation, avec le comptage.

5. Garder, corriger ou refuser. Vous restez responsable du script.

La réponse de l'assistant (inventée pour le livre, à ne pas garder) :

"""Version proposée par l'assistant d'IA (à ne pas garder) : elle SUPPRIME les doublons."""
from pathlib import Path

DOSSIER = Path("entrainement")
FACTURES = DOSSIER / "factures"


def compter_fichiers(dossier):
    """Renvoie le nombre de fichiers dans le dossier et tous ses sous-dossiers."""
    nombre = 0
    for chemin in dossier.rglob("*"):
        if chemin.is_file():
            nombre = nombre + 1
    return nombre


avant = compter_fichiers(DOSSIER)
vus = []
for fichier in sorted(FACTURES.iterdir()):
    numero = fichier.name[:6]
    if fichier.name.startswith("FACT-"):
        numero = "F" + fichier.name[5:10]
    if numero in vus:
        print("Doublon supprimé :", fichier.name)
        fichier.unlink()
    else:
        vus.append(numero)
print(avant, "fichiers avant,", compter_fichiers(DOSSIER), "après")

Lancée sur le dossier d'entraînement (sortie réelle) :

Deux défauts, que la relecture aurait dû trouver avant le lancement : fichier.unlink() supprime un fichier (sans corbeille), ce que Nadia n'avait pas demandé ; et le « numéro » des scans vaut Scan_0 pour tous (fichier.name[:6]), si bien que trois scans différents passent pour des doublons. La version corrigée signale au lieu de supprimer :

"""Version corrigée par Nadia : les doublons sont signalés et laissés à leur place, en simulation comme en action."""
from pathlib import Path

DOSSIER = Path("entrainement")
FACTURES = DOSSIER / "factures"


def compter_fichiers(dossier):
    """Renvoie le nombre de fichiers dans le dossier et tous ses sous-dossiers."""
    nombre = 0
    for chemin in dossier.rglob("*"):
        if chemin.is_file():
            nombre = nombre + 1
    return nombre


avant = compter_fichiers(DOSSIER)
vus = []
doublons = []
for fichier in sorted(FACTURES.iterdir()):
    numero = fichier.name[:6]
    if fichier.name.startswith("FACT-"):
        numero = "F" + fichier.name[5:10]
    if numero in vus:
        doublons.append(fichier.name)
    else:
        vus.append(numero)
print("Doublons probables, à vérifier à la main :", doublons)
print(avant, "fichiers avant,", compter_fichiers(DOSSIER), "après")

Sortie réelle :

Les trois scans restent signalés à tort, mais rien n'est perdu : c'est Nadia qui regarde et décide. Son script de rangement, lui, traitait déjà les doublons sans rien supprimer (épisode 14) : la meilleure décision était peut-être de ne pas ajouter ce code du tout.

Un assistant d'IA écrit un code plausible, pas un code vérifié : il peut ajouter ce que vous n'avez pas demandé, ou se tromper avec assurance. La règle d'or reste vraie : un code que vous ne comprenez pas, vous ne le lancez pas. La relecture ciblée (ce qui supprime, écrase ou envoie) attrape l'essentiel ; la copie, la simulation et le comptage rattrapent le reste. Et ne rien confier de confidentiel protège votre entreprise, quel que soit l'outil.

Bon réflexe ou piège ?