242 lines
8.7 KiB
Python
242 lines
8.7 KiB
Python
import numpy as np
|
|
import pandas as pd
|
|
|
|
from app import comp
|
|
from app.comp.moy_sem import comp_ranks_series
|
|
from app.pe import pe_affichage
|
|
|
|
|
|
class Moyenne:
|
|
CRITERES = [
|
|
"note",
|
|
"classement",
|
|
"rang",
|
|
"min",
|
|
"max",
|
|
"moy",
|
|
"nb_etuds",
|
|
"nb_inscrits",
|
|
]
|
|
|
|
def __init__(self, notes: pd.Series):
|
|
"""Classe centralisant la synthèse des moyennes/classements d'une série
|
|
de notes :
|
|
|
|
* des "notes" : la Serie pandas des notes (float),
|
|
* des "classements" : la Serie pandas des classements (float),
|
|
* des "min" : la note minimum,
|
|
* des "max" : la note maximum,
|
|
* des "moy" : la moyenne,
|
|
* des "nb_inscrits" : le nombre d'étudiants ayant une note,
|
|
"""
|
|
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 nulle"""
|
|
self.df: pd.DataFrame = self.comp_moy_et_stat(self.notes)
|
|
"""Le dataframe retraçant les moyennes/classements/statistiques"""
|
|
self.synthese = self.to_dict()
|
|
"""La synthèse (dictionnaire) des notes/classements/statistiques"""
|
|
|
|
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.CRITERES,
|
|
)
|
|
|
|
# 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)
|
|
# 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)
|
|
|
|
# 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
|
|
|
|
# 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_dict(self) -> dict:
|
|
"""Renvoie un dictionnaire de synthèse des moyennes/classements/statistiques générale (but)"""
|
|
synthese = {
|
|
"notes": self.df["note"],
|
|
"classements": self.df["classement"],
|
|
"min": self.df["min"].mean(),
|
|
"max": self.df["max"].mean(),
|
|
"moy": self.df["moy"].mean(),
|
|
"nb_inscrits": self.df["nb_inscrits"].mean(),
|
|
}
|
|
return synthese
|
|
|
|
def get_notes(self):
|
|
"""Série des notes, arrondies à 2 chiffres après la virgule"""
|
|
return self.df_gen["note"].round(2)
|
|
|
|
def get_rangs_inscrits(self) -> pd.Series:
|
|
"""Série des rangs classement/nbre_inscrit"""
|
|
return self.df_gen["rang"]
|
|
|
|
def get_min(self) -> pd.Series:
|
|
"""Série des min"""
|
|
return self.df_gen["min"].round(2)
|
|
|
|
def get_max(self) -> pd.Series:
|
|
"""Série des max"""
|
|
return self.df_gen["max"].round(2)
|
|
|
|
def get_moy(self) -> pd.Series:
|
|
"""Série des moy"""
|
|
return self.df_gen["moy"].round(2)
|
|
|
|
def get_note_for_df(self, etudid: int):
|
|
"""Note d'un étudiant donné par son etudid"""
|
|
return round(self.df_gen["note"].loc[etudid], 2)
|
|
|
|
def get_min_for_df(self) -> float:
|
|
"""Min renseigné pour affichage dans un df"""
|
|
return round(self.synthese["min"], 2)
|
|
|
|
def get_max_for_df(self) -> float:
|
|
"""Max renseigné pour affichage dans un df"""
|
|
return round(self.synthese["max"], 2)
|
|
|
|
def get_moy_for_df(self) -> float:
|
|
"""Moyenne renseignée pour affichage dans un df"""
|
|
return round(self.synthese["moy"], 2)
|
|
|
|
def get_class_for_df(self, etudid: int) -> str:
|
|
"""Classement ramené au nombre d'inscrits,
|
|
pour un étudiant donné par son etudid"""
|
|
classement = self.df_gen["rang"].loc[etudid]
|
|
if not pd.isna(classement):
|
|
return classement
|
|
else:
|
|
return pe_affichage.SANS_NOTE
|
|
|
|
def is_significatif(self) -> bool:
|
|
"""Indique si la moyenne est significative (c'est-à-dire à des notes)"""
|
|
return self.synthese["nb_inscrits"] > 0
|
|
|
|
|
|
class MoyennesTag:
|
|
def __init__(
|
|
self,
|
|
tag: str,
|
|
matrice_notes: pd.DataFrame, # etudids x colonnes
|
|
matrice_coeffs: pd.DataFrame, # etudids x colonnes
|
|
):
|
|
"""Classe centralisant la synthèse des moyennes/classements d'une série
|
|
d'étudiants à un tag donné, en différenciant les notes
|
|
obtenues aux UE et au général (toutes UEs confondues)
|
|
|
|
|
|
Args:
|
|
tag: Un tag
|
|
matrice_notes: Les moyennes (etudid x acronymes_ues ou etudid x compétences) aux différentes UEs ou compétences
|
|
matrice_coeffs: Les coeff à appliquer pour le calcul de la moyenne générale
|
|
# notes_gen: Une série de notes (moyenne) sous forme d'un ``pd.Series`` (toutes UEs confondues)
|
|
"""
|
|
self.tag = tag
|
|
"""Le tag associé aux moyennes"""
|
|
|
|
# Les moyennes par UE
|
|
self.matrice_notes: pd.DataFrame = matrice_notes
|
|
"""Les notes aux UEs ou aux compétences (DataFrame)"""
|
|
|
|
self.matrice_coeffs_moy_gen: pd.DataFrame = matrice_coeffs
|
|
"""Les coeffs à appliquer pour le calcul des moyennes générales
|
|
(toutes UE ou compétences confondues). NaN si étudiant non inscrit"""
|
|
|
|
self.moyennes: dict[int, pd.DataFrame] = {}
|
|
"""Les dataframes retraçant les moyennes/classements/statistiques des étudiants aux UEs"""
|
|
colonnes = self.matrice_notes.columns
|
|
for col in colonnes: # if ue.type != UE_SPORT:
|
|
notes = matrice_notes[col]
|
|
self.moyennes[col] = Moyenne(notes)
|
|
|
|
# Les moyennes générales
|
|
notes_gen = pd.Series(np.nan, index=self.matrice_notes.index)
|
|
"""Les notes générales (moyenne toutes UEs confonudes)"""
|
|
if self.has_notes():
|
|
notes_gen = self.compute_moy_gen(
|
|
self.matrice_notes, self.matrice_coeffs_moy_gen
|
|
)
|
|
self.notes_gen = notes_gen
|
|
self.moyenne_gen = Moyenne(notes_gen)
|
|
"""Le dataframe retraçant les moyennes/classements/statistiques général"""
|
|
|
|
def has_notes(self):
|
|
"""Détermine si les moyennes (aux UEs ou aux compétences)
|
|
ont des notes
|
|
|
|
Returns:
|
|
True si la moytag a des notes, False sinon
|
|
"""
|
|
notes = self.matrice_notes
|
|
nbre_nan = notes.isna().sum().sum()
|
|
nbre_notes_potentielles = len(notes.index) * len(notes.columns)
|
|
if nbre_nan == nbre_notes_potentielles:
|
|
return False
|
|
else:
|
|
return True
|
|
|
|
def compute_moy_gen(self, moys: pd.DataFrame, coeffs: pd.DataFrame) -> pd.Series:
|
|
"""Calcule la moyenne générale (toutes UE/compétences confondus)
|
|
pour le tag considéré, en pondérant les notes obtenues au UE
|
|
par les coeff (généralement les crédits ECTS).
|
|
|
|
Args:
|
|
moys: Les moyennes etudids x acronymes_ues/compétences
|
|
coeff: Les coeff etudids x ueids/compétences
|
|
"""
|
|
|
|
# Calcule la moyenne générale dans le semestre (pondérée par le ECTS)
|
|
try:
|
|
moy_gen_tag = comp.moy_sem.compute_sem_moys_apc_using_ects(
|
|
moys,
|
|
coeffs.fillna(0.0),
|
|
# formation_id=self.formsemestre.formation_id,
|
|
skip_empty_ues=True,
|
|
)
|
|
except TypeError as e:
|
|
raise TypeError(
|
|
"Pb dans le calcul de la moyenne toutes UEs/compétences confondues"
|
|
)
|
|
|
|
return moy_gen_tag
|