ajout : aout des tests test_cleaning.py

cleaning.py

@@ -1,13 +1,31 @@
 #!/usr/bin/env python3
 from pandas import DataFrame, to_numeric
+import pandas as pd
+
+SCORE_COLS = ["Robert", "Robinson", "Suckling"]
 
 
-def display_info(df: DataFrame) -> None:
-    print(df.all())
-    print(df.info())
-    print("\nNombre de valeurs manquantes par colonne :")
+def display_info(df: DataFrame, name: str = "DataFrame") -> None:
+    """
+    Affiche un résumé du DataFrame
+        -la taille
+        -types des colonnes
+        -valeurs manquantes
+        -statistiques numériques
+    """
+    print(f"\n===== {name} =====")
+
+    print(f"Shape : {df.shape[0]} lignes × {df.shape[1]} colonnes")
+
+    print("\nTypes des colonnes :")
+    print(df.dtypes)
+
+    print("\nValeurs manquantes :")
     print(df.isna().sum())
 
+    print("\nStatistiques numériques :")
+    print(df.describe().round(2))
+
 
 def drop_empty_appellation(df: DataFrame) -> DataFrame:
 
@@ -45,4 +63,44 @@ def mean_robinson(df: DataFrame) -> DataFrame:
 
 
 def mean_suckling(df: DataFrame) -> DataFrame:
-    return mean_score(df, "Suckling")
+    return mean_score(df, "Suckling")
+
+
+def fill_missing_scores(df: DataFrame) -> DataFrame:
+    """
+    Remplacer les notes manquantes par la moyenne
+    des vins de la même appellation.
+    """
+    df_copy = df.copy()
+    df_copy["Appellation"] = df_copy["Appellation"].astype(str).str.strip()
+
+    for score in SCORE_COLS:
+        df_copy[score] = to_numeric(df_copy[score], errors="coerce")
+
+    temp_cols: list[str] = []
+
+    for score in SCORE_COLS:
+        mean_df = mean_score(df_copy, score)
+        mean_name = f"mean_{score}"
+        temp_cols.append(mean_name)
+
+        df_copy = df_copy.merge(mean_df, on="Appellation", how="left")
+        df_copy[score] = df_copy[score].fillna(df_copy[mean_name])
+
+    df_copy = df_copy.drop(columns=temp_cols)
+    return df_copy
+
+
+def encode_appellation(df: DataFrame, column: str = "Appellation") -> DataFrame:
+    """
+    Remplace la colonne 'Appellation' par des colonnes indicatrices
+    """
+    df_copy = df.copy()
+    
+    appellations = df_copy[column].astype(str).str.strip()
+
+    appellation_dummies = pd.get_dummies(appellations)
+
+    df_copy = df_copy.drop(columns=[column])
+
+    return df_copy.join(appellation_dummies)

main.py

@@ -9,7 +9,9 @@ from cleaning import (display_info,
                       drop_empty_appellation,
                       mean_robert,
                       mean_robinson,
-                      mean_suckling)
+                      mean_suckling,
+                      fill_missing_scores,
+                      encode_appellation)
 
 
 def load_csv(filename: str) -> DataFrame:
@@ -27,30 +29,32 @@ def main() -> None:
 
     df = load_csv(argv[1])
 
-    print("=== Avant nettoyage ===")
-    display_info(df)
+    display_info(df, "Avant le nettoyage")
 
     df = drop_empty_appellation(df)
     save_csv(df, "donnee_clean.csv")
-
-    print("\n=== Après nettoyage d'appellations manquantes ===")
-    display_info(df)
+    display_info(df, "Après nettoyage d'appellations manquantes")
     
     #la moyenne des notes des vins pour chaque appellation
     robert_means = mean_robert(df)
     save_csv(robert_means, "mean_robert_by_appellation.csv")
-    print("\n=== moyenne Robert par appellation ===")
-    print(robert_means.head(10))
+    display_info(robert_means, "Moyennes Robert par appellation")
 
     robinson_means = mean_robinson(df)
     save_csv(robinson_means, "mean_robinson_by_appellation.csv")
-    print("\n===: moyennes Robinson par appellation ===")
-    print(robinson_means.head(10))
-    
+    display_info(robinson_means, "Moyennes Robinson par appellation")
+  
     suckling_means = mean_suckling(df)
     save_csv(suckling_means, "mean_suckling_by_appellation.csv")
-    print("\n===: moyennes Suckling par appellation ===")
-    print(suckling_means.head(10))
+    display_info(suckling_means, "Moyennes Suckling par appellation")
+    
+    df_missing_scores = fill_missing_scores(df)
+    save_csv(df_missing_scores, "donnee_filled.csv")
+    display_info(df_missing_scores, "Après remplissage des notes manquantes par la moyenne de l'appellation")
+     
+    df_ready = encode_appellation(df_missing_scores)
+    save_csv(df_ready, "donnee_ready.csv")
+    display_info(df_ready, "Après remplacer la colonne 'Appellation' par des colonnes indicatrices")
 
 
 if __name__ == "__main__":

test_cleaning.py

@@ -0,0 +1,64 @@
+import pandas as pd
+import pytest
+from pandas import DataFrame
+
+from cleaning import (
+    SCORE_COLS,
+    drop_empty_appellation,
+    mean_score,
+    fill_missing_scores,
+    encode_appellation,
+)
+
+
+@pytest.fixture
+def df_raw() -> DataFrame:
+    return pd.DataFrame({
+        "Appellation": ["Pauillac", "Pauillac ", "Margaux", None, "Pomerol", "Pomerol"],
+        "Robert":      ["95", None, "bad", 90, None, None],
+        "Robinson":    [None, "93", 18, None, None, None],
+        "Suckling":    [96, None, None, None, 91, None],
+        "Prix":        ["10.0", "11.0", "20.0", "30.0", "40.0", "50.0"],
+    })
+
+
+def test_drop_empty_appellation(df_raw: DataFrame):
+    out = drop_empty_appellation(df_raw)
+    assert out["Appellation"].isna().sum() == 0
+    assert len(out) == 5 
+
+
+def test_mean_score_zero_when_no_scores(df_raw: DataFrame):
+    out = drop_empty_appellation(df_raw)
+    m = mean_score(out, "Robert")
+    assert list(m.columns) == ["Appellation", "mean_Robert"]
+
+    # Pomerol n'a aucune note Robert => moyenne doit être 0
+    pomerol_mean = m.loc[m["Appellation"].str.strip() == "Pomerol", "mean_Robert"].iloc[0]
+    assert pomerol_mean == 0
+
+
+def test_fill_missing_scores(df_raw: DataFrame):
+    out = drop_empty_appellation(df_raw)
+    filled = fill_missing_scores(out)
+
+    # plus de NaN dans les colonnes de scores
+    for col in SCORE_COLS:
+        assert filled[col].isna().sum() == 0
+
+    assert filled.loc[1, "Robert"] == 95.0
+
+    # pas de colonnes temporaires mean_*
+    for col in SCORE_COLS:
+        assert f"mean_{col}" not in filled.columns
+
+
+def test_encode_appellation(df_raw: DataFrame):
+    out = drop_empty_appellation(df_raw)
+    filled = fill_missing_scores(out)
+    encoded = encode_appellation(filled)
+
+    # la colonne texte disparaît
+    assert "Appellation" not in encoded.columns
+    assert "Pauillac" in encoded.columns
+    assert encoded.loc[0, "Pauillac"] == 1