DS MPSI - Analyse de consommation énergétique - Relevés électriques

def lire_mesures(fichier):
    mesures = {}
    with open(fichier, 'r', encoding='utf-8') as f:
        for ligne in f:
            ligne = ligne.strip()
            if not ligne:
                continue
            batiment, jour, appareil, consommation = ligne.split(';')
            consommation = int(consommation)
            
            if batiment not in mesures:
                mesures[batiment] = []
            mesures[batiment].append((jour, appareil, consommation))
    
    return mesures

def consommation_totale(mesures, batiment):
    if batiment not in mesures:
        return 0
    
    total = 0
    for jour, appareil, conso in mesures[batiment]:
        total += conso
    
    return total

def appareils_utilises(mesures, batiment):
    if batiment not in mesures:
        return set()
    
    appareils = set()
    for jour, appareil, conso in mesures[batiment]:
        appareils.add(appareil)
    
    return appareils

def jours_actifs(mesures):
    jours = set()
    for batiment, liste_mesures in mesures.items():
        for jour, appareil, conso in liste_mesures:
            jours.add(jour)
    return jours

def batiment_plus_consommateur(mesures):
    max_conso = -1
    meilleur_batiment = None
    
    for batiment in mesures:
        total = consommation_totale(mesures, batiment)
        
        if total > max_conso:
            max_conso = total
            meilleur_batiment = batiment
        elif total == max_conso:
            if meilleur_batiment is None or batiment < meilleur_batiment:
                meilleur_batiment = batiment
    
    return meilleur_batiment

def consommation_par_appareil(mesures):
    conso_par_app = {}
    for batiment, liste_mesures in mesures.items():
        for jour, appareil, conso in liste_mesures:
            conso_par_app[appareil] = conso_par_app.get(appareil, 0) + conso
    return conso_par_app

def appareil_dominant(mesures, batiment):
    if batiment not in mesures:
        return None
    
    conso_par_app = {}
    for jour, appareil, conso in mesures[batiment]:
        conso_par_app[appareil] = conso_par_app.get(appareil, 0) + conso
    
    max_conso = -1
    dominant = None
    
    for appareil, conso in conso_par_app.items():
        if conso > max_conso:
            max_conso = conso
            dominant = appareil
        elif conso == max_conso:
            if dominant is None or appareil < dominant:
                dominant = appareil
    
    return dominant

def batiments_par_appareil(mesures):
    dico = {}
    for batiment, liste_mesures in mesures.items():
        for jour, appareil, conso in liste_mesures:
            if appareil not in dico:
                dico[appareil] = set()
            dico[appareil].add(batiment)
    return dico

def appareils_communs(mesures, b1, b2):
    if b1 not in mesures or b2 not in mesures:
        return set()
    
    app_b1 = appareils_utilises(mesures, b1)
    app_b2 = appareils_utilises(mesures, b2)
    
    return app_b1 & app_b2

def ecrire_consommations_elevees(fichier_entree, fichier_sortie, seuil):
    with open(fichier_entree, 'r', encoding='utf-8') as f_entree, \
         open(fichier_sortie, 'w', encoding='utf-8') as f_sortie:
        
        for ligne in f_entree:
            ligne = ligne.strip()
            if not ligne:
                continue
            parties = ligne.split(';')
            if len(parties) >= 4:
                try:
                    consommation = int(parties[3])
                    if consommation >= seuil:
                        f_sortie.write(ligne + '\n')
                except ValueError:
                    pass  # Ignorer les lignes mal formatées

def profil_journalier(mesures):
    profil = {}
    for batiment, liste_mesures in mesures.items():
        for jour, appareil, conso in liste_mesures:
            profil[jour] = profil.get(jour, 0) + conso
    return profil

def recommandation_economies(mesures, batiment):
    if batiment not in mesures:
        return None
    
    # Appareils utilisés dans le bâtiment
    appareils_batiment = appareils_utilises(mesures, batiment)
    
    # Consommation totale par appareil
    conso_par_app = consommation_par_appareil(mesures)
    
    # Filtrer les appareils non utilisés dans le bâtiment
    appareils_autres = [app for app in conso_par_app.keys() if app not in appareils_batiment]
    
    if not appareils_autres:
        return None
    
    # Trouver l'appareil avec la plus faible consommation totale
    min_conso = float('inf')
    meilleur_appareil = None
    
    for appareil in appareils_autres:
        conso = conso_par_app[appareil]
        if conso < min_conso:
            min_conso = conso
            meilleur_appareil = appareil
        elif conso == min_conso:
            if meilleur_appareil is None or appareil < meilleur_appareil:
                meilleur_appareil = appareil
    
    return meilleur_appareil