diff --git a/main.py b/main.py
index 7c39f344dfbf7fbbaaad291b2c281eaa0b384e98..ed0c367c4e345af5f2103397769f7ad9f8758a41 100644
--- a/main.py
+++ b/main.py
@@ -1,22 +1,65 @@
+# Importation des bibliothèques
+from typing import Tuple, List
 import pandas as pd
 import numpy as np
 import matplotlib.pyplot as plt
 
 
-def import_csv(filename: str):
-    return pd.read_csv(filename, header=None)
+def import_csv(filename: str, h: int or None) -> pd.DataFrame:
+    """
+    Importe un fichier CSV et retourne un DataFrame pandas.
 
+    Args:
+        filename (str): Le chemin du fichier CSV.
+        h (int or None, optional): L'entête du fichier CSV.
 
-def manhattan_distance(x1, x2):
+    Returns:
+        pandas.DataFrame: Les données importées sous forme de DataFrame.
+    """
+    return pd.read_csv(filename, header=h)
+
+
+def manhattan_distance(x1: np.ndarray, x2: np.ndarray) -> float:
+    """
+    Calcule la distance de Manhattan (L1) entre deux vecteurs.
+
+    Args:
+        x1 (numpy.ndarray): Le premier vecteur.
+        x2 (numpy.ndarray): Le deuxième vecteur.
+
+    Returns:
+        float: La distance de Manhattan entre x1 et x2.
+    """
     return np.sum(np.abs(x1 - x2))
 
 
-def assign_clusters(X, centroids):
+def assign_clusters(X: np.ndarray, centroids: np.ndarray) -> np.ndarray:
+    """
+    Attribue chaque point de données à son cluster le plus proche en utilisant la distance de Manhattan.
+
+    Args:
+        X (numpy.ndarray): Les données.
+        centroids (numpy.ndarray): Les centroïdes des clusters.
+
+    Returns:
+        numpy.ndarray: Les étiquettes de cluster attribuées à chaque point de données.
+    """
     distances = np.array([[manhattan_distance(x, centroid) for centroid in centroids] for x in X])
     return np.argmin(distances, axis=1)
 
 
-def k_means(X, k, max_iterations=100):
+def k_means(X: np.ndarray, k: int, max_iterations: int = 100) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Implémente l'algorithme K-Means pour regrouper les données en k clusters.
+
+    Args:
+        X (numpy.ndarray): Les données à regrouper.
+        k (int): Le nombre de clusters à former.
+        max_iterations (int, optional): Le nombre maximal d'itérations. Défaut à 100.
+
+    Returns:
+        tuple: Une paire contenant les étiquettes de cluster et les centroïdes finaux.
+    """
     # Initialisation des k-centroïdes de manière aléatoire
     np.random.seed(0)
     centroids = X[np.random.choice(X.shape[0], k, replace=False)]
@@ -73,16 +116,16 @@ if __name__ == "__main__":
     # Initialiser k-centroides
     # attribuer les points aux centroïde le plus proche (Manhattan / L2)
     # Tant que les centroïdes bougent :
-        # Pour chaque cluster, calculer le point central du cluster (moyenne des coordonnées)
-        # noter si ancien centroïde ~= nouveau centroïde
-        # attribution des points aux nouveaux centroïdes
-            # calcul de la somme des distances au sein d'un cluster
-                # fonction objectif à minimiser
-                # plot la somme de la somme des distances à chaque itération
-        # afficher les nouveaux cluster à chaque itérations
+    # Pour chaque cluster, calculer le point central du cluster (moyenne des coordonnées)
+    # noter si ancien centroïde ~= nouveau centroïde
+    # attribution des points aux nouveaux centroïdes
+    # calcul de la somme des distances au sein d'un cluster
+    # fonction objectif à minimiser
+    # plot la somme de la somme des distances à chaque itération
+    # afficher les nouveaux cluster à chaque itérations
 
     # Charger les données depuis le fichier CSV
-    df = import_csv("Data/iris.csv")
+    df = import_csv("Data/iris.csv", None)
     X = df.iloc[:, :-1].values
 
     k = 3