import numpy as np import pandas as pd from app.comp.moy_sem import comp_ranks_series from app.pe import pe_affichage class Moyenne: COLONNES = [ "note", "classement", "rang", "min", "max", "moy", "nb_etuds", "nb_inscrits", ] """Colonnes du df""" @classmethod def get_colonnes_synthese(cls, with_min_max_moy): """Renvoie le nom des colonnes à prendre en compte pour la génération d'un dataFrame résumant les données d'un objet pe_moy.Moyenne""" if with_min_max_moy: return ["note", "rang", "min", "max", "moy"] else: return ["note", "rang"] def __init__(self, notes: pd.Series, infos: dict[str]): """Classe centralisant la synthèse des moyennes/class/stat d'une série de notes pour un groupe d'étudiants (déduits des notes). Sont génerés des Séries/DataFrame donnant : * les "notes" : notes (float), * des "classements" : classements (float), * des "min" : la note minimum sur tout le groupe d'étudiants, * des "max" : la note maximum sur tout le groupe d'étudiants, * des "moy" : la moyenne des notes sur tout le groupe d'étudiants, * des "nb_inscrits" : le nombre d'étudiants ayant une note (non NaN) Args: notes: Une (pandas.)Série de notes infos: Un dictionnaire donnant les informations sur la moyenne (aggrégat, tag, intitule, cohorte, groupe) """ self.notes = notes """Les notes""" self.etudids = list(notes.index) # calcul à venir """Les id des étudiants""" self.inscrits_ids = notes[notes.notnull()].index.to_list() """Les id des étudiants dont la note est non nan/renseignée""" self.df: pd.DataFrame = self.comp_moy_et_stat(self.notes) """Le dataframe retraçant les moyennes/classements/statistiques""" self.infos = { "aggregat": infos["aggregat"], "tag": infos["tag"], "intitule": infos["intitule"], "cohorte": infos["cohorte"], } """Dictionnaire donnant des informations sur la note (aggrégat, cohorte, tag, type_de_moyenne)""" # self.synthese = self.to_dict() # """La synthèse (dictionnaire) des notes/classements/statistiques""" def __repr__(self): """Représentation textuelle d'un objet Moyenne sur la base de ses `infos`. """ repr = get_repr( self.infos["aggregat"], self.infos["tag"], self.infos["intitule"], self.infos["cohorte"], ) return f"Moyenne {repr}" def comp_moy_et_stat(self, notes: pd.Series) -> dict: """Calcule et structure les données nécessaires au PE pour une série de notes (pouvant être une moyenne d'un tag à une UE ou une moyenne générale d'un tag) dans un dictionnaire spécifique. Partant des notes, sont calculés les classements (en ne tenant compte que des notes non nulles). Args: notes: Une série de notes (avec des éventuels NaN) Returns: Un dictionnaire stockant les notes, les classements, le min, le max, la moyenne, le nb de notes (donc d'inscrits) """ df = pd.DataFrame( np.nan, index=self.etudids, columns=Moyenne.COLONNES, ) # Supprime d'éventuelles chaines de caractères dans les notes notes = pd.to_numeric(notes, errors="coerce") df["note"] = notes # Les nb d'étudiants & nb d'inscrits df["nb_etuds"] = len(self.etudids) df["nb_etuds"] = df["nb_etuds"].astype(int) # Les étudiants dont la note n'est pas nulle inscrits_ids = notes[notes.notnull()].index.to_list() df.loc[inscrits_ids, "nb_inscrits"] = len(inscrits_ids) # df["nb_inscrits"] = df["nb_inscrits"].astype(int) # Le classement des inscrits notes_non_nulles = notes[inscrits_ids] (class_str, class_int) = comp_ranks_series(notes_non_nulles) df.loc[inscrits_ids, "classement"] = class_int # df["classement"] = df["classement"].astype(int) # Le rang (classement/nb_inscrit) df["rang"] = df["rang"].astype(str) df.loc[inscrits_ids, "rang"] = ( df.loc[inscrits_ids, "classement"].astype(int).astype(str) + "/" + df.loc[inscrits_ids, "nb_inscrits"].astype(int).astype(str) ) # Les stat (des inscrits) df.loc[inscrits_ids, "min"] = notes.min() df.loc[inscrits_ids, "max"] = notes.max() df.loc[inscrits_ids, "moy"] = notes.mean() return df def to_df(self, with_min_max_moy=None): """Renvoie le df de synthèse (tel qu'attendu dans les exports Excel), en limitant les colonnes à celles attendues (dépendantes de l'option ``with_min_max_moy``) """ colonnes_synthese = Moyenne.get_colonnes_synthese( with_min_max_moy=with_min_max_moy ) # Copie le df modélisant les données df = self.df[colonnes_synthese].copy() df["rang"] = df["rang"].replace("nan", "") # Remplace les noms de colonnes par leur intitulé dans le tableur excel cols = [] for critere in colonnes_synthese: nom_col = get_colonne_df( self.infos["aggregat"], self.infos["tag"], self.infos["intitule"], # UEs ou compétences self.infos["cohorte"], critere, ) cols += [nom_col] df.columns = cols return df def to_json(self) -> dict: """Renvoie un dictionnaire de synthèse des moyennes/classements/statistiques générale (but)""" df = self.to_df(with_min_max_moy=True) resultat = df.to_json(orient="index") return resultat def has_notes(self) -> bool: """Indique si la moyenne est significative (c'est-à-dire à des notes) et/ou des inscrits""" return len(self.inscrits_ids) > 0 def get_repr(aggregat, tag, intitule, cohorte): """Renvoie une représentation textuelle "aggregat|tag|intitule|cohorte" pour représenter une moyenne """ liste_champs = [] if aggregat != None: liste_champs += [aggregat] liste_champs += [tag, intitule] if cohorte != None: liste_champs += [cohorte] return "|".join(liste_champs) def get_colonne_df(aggregat, tag, intitule, cohorte, critere): """Renvoie la chaine de caractère "aggregat|tag|intitule|cohorte|critere" utilisé pour désigner les colonnes du df. Args: aggregat: Un nom d'aggrégat (généralement "S1" ou "3S") pouvant être optionnel (si `None`) tag: Un nom de tags (par ex. "maths") intitule: Un nom d'UE ou de compétences ou "Général" cohorte: Une cohorte pour les interclassements (généralement Groupe ou Promo pouvant être optionnel (si `None`) critere: Un critère correspondant à l'une des colonnes d'une pe_moy.Moyenne Returns: Une chaine de caractères indiquant les champs séparés par un ``"|"``, généralement de la forme "S1|maths|UE|Groupe|note" """ liste_champs = [get_repr(aggregat, tag, intitule, cohorte), critere] return "|".join(liste_champs)