Python et list

class Kmeans():
    """""
    Input : 
    C : Number of clusters
    X : Training set
    """""
    def __init__(self, C, data, Bool):
        self.C = C
        self.data = data
        self.N = len(X) # Number of points
        self.display = Bool 
    
    def d2(data, G):
        """""
        Input : 
        clusters_label : A numpy vector of size data set and each coordinate is the number of the clusters 
                            whoose the data point belongs.
        G : A set centroids
        
        Output : 
        """""
        
        return np.array([ [np.sum((x-g)**2) for g in G] for x in data])
    
    def Inertia(clusters_label, G):
        """""
        Input : 
        clusters_label : A numpy vector of size data set and each coordinate is the number of the clusters 
                            whoose the data point belongs.
        G : A set centroids
        
        Output : 
        """""
        return 
        
    
    def assignement(G):
        """""
        Input : 
        C : Number of clusters
        X : Training set
        
        Output : Cluster_labels 
        """""
        return np.argmin( d2(data, G), axis = 1)

    
    def centroids(clusters_labels, G):
        """""
        Input : 
        C : Number of clusters
        X : Training set
        """""
        Gnew = np.zeros(G.shape)
        for j in range(C):
            if sum(clusters_label == j) == 0:
                Gnew[j] = G[j]
            else:
                Gnew[j] = np.mean(data[cluster_label == j, :], axis=0)
        
    def display(clusters_labels, step):
        """""
        Input : 
        C : Number of clusters
        X : Training set
        
        Out : Display step
        """""
        
    def train(self,C,data, G):
        """""
        Input : 
        C : Number of clusters
        data : Training set 
        G : Set of centroids set up as a list of points
        """""
        IB = 0 # Inertia before
        IA = 0 # Intertia after
        step = 0 
        epsilon = 10**(-3) # inertia's variation minimum value.
        
        # Represent the clusters as a list with C lines each lines is a cluster 
        clusters = [[G[ i]] for i in range(C)] # Initialization of the clusters set
        clusters_label = np.zeros(len(data))
        
        while np.abs(IB-IA) > epsilon or step==0 : # While inertia doesn't stagnate 
            #Display step
            if self.display :
                display(clusters_label, G, step)
            # Training step
            IB = IA # Old interia to compute variation
            IA = Inertia(clusters, G) # Update Inertia
            clusters_labels = assignement(G) # Update clusters
            G = centroids(clusters_labels, G) # Update centroids
            step = step +1 # Update step
            

class KLoyds(KMeans):
    def __init__(self, C, data, Bool):
        super().__init__(self, C, data, Bool)
    # Initialisation step 
    G = np.random.choice(self.data, self.C)
    self.train(self.C, self.data, G)

class KLoyds(Kmeans):
    def __init__(self, C, data, Bool):
        super().__init__(self, C, data, Bool)
        self.G = np.random.choice(self.data, self.C) # Initialisation step
    def train(self):
        self.train(self.C, self.G)