Correction : modularité

Code du module modultab

def maximum(t):
    """Renvoie la valeur maximale dans le tableau.
    @param : t = tableau de valeurs (list)
    @return : la valeur maximale dans t
    """
    assert isinstance(t, list), "L'argument 't' doit être un tableau."
    assert len(t) != 0, "Le tableau ne peut pas être vide."
    
    maxi = t[0]
    for elt in t:
        if elt > maxi:
            maxi = elt 
    return maxi
    
def minimum(t):
    """Renvoie la valeur minimale dans le tableau.
    @param : t = tableau de valeurs (list)
    @return : la valeur minimale dans t
    """
    assert isinstance(t, list), "L'argument 't' doit être un tableau."
    assert len(t) != 0, "Le tableau ne peut pas être vide."
    
    mini = t[0]
    for elt in t:
        if elt < mini:
            mini = elt 
    return mini
    
def somme(t):
    """Renvoie la somme des élément d'un tableau.
    @param : t = tableau de valeurs (list)
    @return : la somme des éléments de t
    """
    assert isinstance(t, list), "L'argument 't' doit être un tableau."
    assert len(t) != 0, "Le tableau ne peut pas être vide."
    
    s = 0
    for elt in t:
        s += elt
    return s
    
def produit(t):
    """Renvoie le produit des élément d'un tableau.
    @param : t = tableau de valeurs (list)
    @return : le produit des éléments de t
    """
    assert isinstance(t, list), "L'argument 't' doit être un tableau."
    assert len(t) != 0, "Le tableau ne peut pas être vide."
    
    p = 1
    for elt in t:
        p *= elt
    return p
    
def longueur(t):
    """Renvoie le nombre d'éléments dans un tableau.
    @param : t = tableau de valeurs (list)
    @return : le nombre d'élément(s) dans t (int)
    """
    assert isinstance(t, list), "L'argument 't' doit être un tableau."
    
    n = 0
    for elt in t:
        n += 1
    return n
    
def moyenne(t):
    """Renvoie la moyenne des élément d'un tableau.
    @param : t = tableau de valeurs (list)
    @return : la moyenne des éléments de t (float)
    """
    assert isinstance(t, list), "L'argument 't' doit être un tableau."
    assert len(t) != 0, "Le tableau ne peut pas être vide."
    
    s = 0
    for elt in t:
        s += elt
    return s / longueur(t)

def inverse(t):
    """Renvoie un nouveau tableau, avec les éléments dans l'ordre inverse de celui passé en paramètre.
    @param : t = tableau de valeurs (list)
    @return : un nouveau tableau, avec les éléments en ordre inverse (list)
    """
    assert isinstance(t, list), "L'argument 't' doit être un tableau."
    
    nouveau = []
    for elt in t:
        nouveau = [elt] + nouveau
    return nouveau    

def tri(t, reverse = False):
    """Tri en place un tableau avec l'algorithme de tri par sélection.
    @param : t = tableau de valeurs (list)
    @param: ordre = booléen indiquant l'ordre de tri : False = ordre croissant (par défaut), True = ordre décroissant
    @return : le tableau trié (list)
    """
    assert isinstance(t, list), "L'argument 't' doit être un tableau."
    
    for i in range(len(t)-1):
        ech = i 
        for j in range(i+1, len(t)):
            if reverse:
                if t[j] > t[ech]:
                    ech = j 
            else:
                if t[j] < t[ech]:
                    ech = j
        if ech != i:
            t[i], t[ech] = t[ech], t[i]
    return t
    

if __name__ == '__main__':
    # tests du module
    t = [12, 1, 5, 63, 78, 4, 51, 32, 23, 7, 19, 45]
    print(maximum(t))
    print(minimum(t))
    print(somme(t))
    print(produit(t))
    print(longueur(t))
    print(moyenne(t))
    print(inverse(t))
    tri(t)
    print(t)
    tri(t, reverse=True)
    print(t)
			
			
						
			

Quelques remarques

• noter la façon utilisée ici pour indiquer dans la docstring des fonctions la nature des paramètres et des valeurs de retour :

  
  @param : indique le rôle, le type,... d'un paramètre
  @return : indique la nature, le type,... d'une valeur de retour
                      

• bien retenir que, dans une assertion, on teste la condition qui doit être vraie.
• la fonction isinstance(variable, type) renvoie un booléen indiquant si une variable est d'un type donné ou non.
• on peut indiquer des valeurs par défaut pour certains paramètres dans la définition d'une fonction, comme par exemple ici dans la fonction tri (ligne 93), dans laquelle on donne au paramètre reverse la valeur par défaut False ( = tri par ordre croissant).
  On appelle paramètre nommé un paramètre avec une valeur par défaut : l'utilisateur du module n'est alors pas obligé de lui passer une valeur en argument lors de l'appel de la fonction, le code utilisera la valeur par défaut; par contre, il doit indiquer le nom de ce paramètre au cas où il l'utilise lors de cet appel : la valeur passée remplace alors celle par défaut .
  A noter que, dans la liste des paramètres d'une fonction, les paramètres nommés doivent être toujours placés après les paramètres non nommés.