Partie 1 · Mesurer

L'unicité : doublons, grain et bonne règle

L'unicité demande : « y a-t-il des doublons ? » (exemple : même identifiant répété). Sur l'IRVE, le TP compte 67 094 lignes dupliquées sur l'identifiant de borne (id_pdc_itinerance). On est tenté de lancer un drop_duplicates() et de passer à la suite.

Or le TP prévient : ces 67 000 « doublons » n'en sont pas. Le grain du fichier est point de charge × livraison : chaque livraison contient à nouveau les points de charge. Un drop_duplicates() naïf supprime des bornes valides.

Vérifie que tu as compris

Pourquoi un drop_duplicates() aveugle sur l'identifiant est-il dangereux sur l'IRVE ?

À toi de coder

Compter les lignes en trop sur un identifiant

Un identifiant répété signale des doublons. Écris lignes_en_trop(ids) : nombre de lignes en trop = nombre total de lignes moins nombre d'identifiants distincts. C'est la logique de la mesure du TP (« bornes réelles vs lignes en trop »).

IDS = ["FR1", "FR2", "FR1", "FR3", "FR1", "FR2"]

def lignes_en_trop(ids):
    return len(ids) - len(___(ids))

Ctrl/⌘+Entrée

La démarche du TP (partie 2, « Comprendre la donnée avant de la nettoyer ») :

Étudier le grain : pourquoi id_pdc_itinerance se répète-t-il ?
Définir LA règle de dédoublonnage : par exemple garder la livraison la plus récente (date_maj max).
Mesurer l'impact : combien de bornes réelles contre combien de lignes en trop.

Le livrable est un dataset dédoublonné accompagné d'une justification écrite de la règle. Dans le Journal de décisions : problème « Doublons id_pdc » ; options « tout supprimer / garder récent » ; choix « garder date_maj max » ; justification « une borne = un point physique ».

À toi de coder

Dédoublonner en gardant la livraison la plus récente

Le grain du fichier IRVE est point de charge × livraison : un même id_pdc apparaît à chaque livraison. La règle du TP : garder la livraison la plus récente (date_maj max). Écris garder_recent(lignes) qui renvoie une liste avec une seule ligne par id_pdc : celle dont date_maj (format ISO AAAA-MM-JJ, comparables comme texte) est la plus grande. Trie le résultat par id_pdc.

LIVRAISONS = [
    {"id_pdc": "FR1", "date_maj": "2024-01-10", "kw": 22},
    {"id_pdc": "FR2", "date_maj": "2024-01-10", "kw": 50},
    {"id_pdc": "FR1", "date_maj": "2024-03-02", "kw": 22},
    {"id_pdc": "FR2", "date_maj": "2023-12-01", "kw": 43},
]

def garder_recent(lignes):
    best = {}
    for l in lignes:
        i = l["id_pdc"]
        if i not in best or l["date_maj"] ___ best[i]["date_maj"]:
            best[i] = l
    return [best[i] for i in sorted(best)]

Ctrl/⌘+Entrée

Vérifie que tu as compris

Quelle règle de dédoublonnage le Journal de décisions du TP donne-t-il en exemple ?

Distinguer deux situations est essentiel : un doublon exact (toutes les colonnes égales : vraie redondance) et une répétition de grain (même identifiant, livraisons différentes : information légitime à arbitrer par une règle).

À toi de coder

Doublon exact contre répétition de grain

Tous les identifiants répétés ne sont pas des erreurs. Écris doublons_exacts(lignes) : nombre de lignes strictement identiques à une ligne déjà vue (toutes les colonnes égales). Une même borne livrée à deux dates (date_maj différente) n'est PAS un doublon exact.

L = [
    {"id": "FR1", "date": "2024-01-10", "kw": 22},
    {"id": "FR1", "date": "2024-01-10", "kw": 22},
    {"id": "FR1", "date": "2024-03-02", "kw": 22},
    {"id": "FR2", "date": "2024-01-10", "kw": 50},
]

def doublons_exacts(lignes):
    vues = set()
    n = 0
    for l in lignes:
        cle = tuple(sorted(l.___()))
        if cle in vues:
            n += 1
        vues.add(cle)
    return n

Ctrl/⌘+Entrée