Rigueur

S2/TP4/analyse_tris.py

@@ -1,5 +1,6 @@
 #!/usr/bin/python3
 # -*- coding: utf-8 -*-
+# pylint: disable=invalid-name, global-statement
 
 """
 TP AP1
@@ -21,14 +22,31 @@ from random import randint
 
 
 def partie(nom):
+    """
+    str → ∅
+    Affiche le nom de la partie en cours
+    """
+    assert type(nom) == str
+
     print('\n', nom, '=' * len(nom), sep='\n')
 
 
 def section(nom):
+    """
+    str → ∅
+    Affiche le nom de la section en cours
+    """
+    assert type(nom) == str
+
     print('\n', nom, '-' * len(nom), sep='\n')
 
 
 def question(numero):
+    """
+    str → ∅
+    Affiche le numéro de la question en cours
+    """
+    assert type(numero) == int
     print('\n***', 'Question', numero, '***')
 
 partie("Prérequis")
@@ -45,6 +63,7 @@ def comp(x, y):
     action : incrémente le compteur
     CU : aucune
     """
+
     global compteur
     compteur = compteur + 1
     if x < y:
@@ -59,8 +78,8 @@ def select_min(l, a, b):
     """
     list, int, int → int
     Renvoie l'indicde d'un élément minimal de la tranche l[a:b]
-    CU : l est une liste de longueur n, d'éléments homogènes ordonnables, et a et b deux indices tels
+    CU : l est une liste de longueur n, d'éléments homogènes ordonnables, et a et b deux indices
-    que 0 ≤ a < b < n
+    tels que 0 ≤ a < b < n
     """
     assert 0 <= a < b <= len(l)
 
@@ -77,6 +96,7 @@ def tri_selection(l):
     La liste l est trié (selon l'algorithme du tri par sélection du minimum)
     CU : l est une liste de longueur n, homogène, d’éléments ordonnables
     """
+    assert type(l) == list
     n = len(l)
     for i in range(n - 1):
         imin = select_min(l, i, n - 1)
@@ -86,11 +106,12 @@ def tri_selection(l):
 def tri_insertion_base(l, n):
     """
     list, int → ∅
-    n est un indice de l tel que l[0:n] soit une liste triée. La fonction déplace l'élément de rang n de telle sorte que l[0:i+1] soit triée
+    n est un indice de l tel que l[0:n] soit une liste triée. La fonction déplace l'élément
-    CU: n est un entier < len(l) et l est une liste, dont les éléments sont comparables, triée jusqu'à l'indice n-1.
+    de rang n de telle sorte que l[0:i+1] soit triée
+    CU: n est un entier < len(l) et l est une liste, dont les éléments sont comparables, triée
+    jusqu'à l'indice n-1.
     """
-
+    assert type(n) == int and type(l) == list and 0 <= n < len(l)
-    assert(type(n) == int and type(l) == list and n < len(l))
 
     aux = l[n]
 
@@ -103,6 +124,12 @@ def tri_insertion_base(l, n):
 
 
 def tri_insertion(l):
+    """
+    list → ∅
+    La liste l est trié (selon l'algorithme du tri par insertion)
+    CU : l est une liste de longueur n, homogène, d’éléments ordonnables
+    """
+    assert type(l) == list
     for i in range(1, len(l)):
         tri_insertion_base(l, i)
 
@@ -119,9 +146,9 @@ def liste_croissante(n):
     Retourne la liste des entiers compris entre 0 et n-1, rangés dans l'ordre croissant
     CU: n est un entier positif
     """
-    assert(type(n) == int and n >= 0)
+    assert type(n) == int and n >= 0
 
-    return [i for i in range(n)]
+    return list(range(n))
 
 
 question(2)
@@ -133,9 +160,9 @@ def liste_decroissante(n):
     Retourne la liste des entiers compris entre 0 et n-1, rangés dans l'ordre décroissant
     CU: n est un entier positif
     """
-    assert(type(n) == int and n >= 0)
+    assert type(n) == int and n >= 0
 
-    return [i for i in range(n - 1, 0, -1)]
+    return list(range(n - 1, 0, -1))
 
 question(3)
 
@@ -145,11 +172,11 @@ def liste_alea(n, a, b):
     int, int, int → list
     Renvoie une liste d’entiers, qui construit une liste de longueur n les entiers choisis au hasard
     compris entre a et b.
+    CU : n entier positif, a et b entiers, a ≤ b
     """
-    res = []
+    assert type(n) == type(a) == type(b) == int and n >= 0 and a <= b
-    for i in range(n):
+
-        res.append(randint(a, b))
+    return [randint(a, b) for _ in range(n)]
-    return res
 
 section("Compter les comparaisons")
 
@@ -159,24 +186,24 @@ compteur = 0
 
 tri_selection(liste_alea(100, -5000, 5000))
 
-print(compteur, 'comparaisons')
+print('{} comparaisons ont été faite pour cette liste.'.format(compteur))
 
 question(2)
 
 
-def tri_et_compte(foo, l):
+def tri_et_compte(trieur, l):
     """
-    Trie la liste l avec la fonction de triage foo passée en paramètre, renvoie la liste triée et le nombre de comparaisons effectuées
+    Trie la liste l avec la fonction de triage trieur passée en paramètre, renvoie la liste triée
+    et le nombre de comparaisons effectuées
     str, list → (list, int)
     CU: l est une liste
     """
-
+    assert type(l) == list
-    assert(type(l) == list)
 
     global compteur
 
     compteur = 0
-    foo(l)
+    trieur(l)
 
     return (l, compteur)
 
@@ -207,10 +234,12 @@ def afficher_tableau(donnees):
 
 question(1)
 
-tableau = [['i  ', 'croissante  ', 'decroissante', 'aléatoire   ']]
+tableau = [['nb ', 'croissante  ', 'decroissante', 'aléatoire   ']]
-for i in range(1, 101):
+for nb in range(1, 101):
-    tableau.append([i, tri_et_compte(tri_selection, liste_croissante(i))[1], tri_et_compte(
+    tableau.append([nb,
-        tri_selection, liste_decroissante(i))[1], tri_et_compte(tri_selection, liste_alea(i, 0, 500))[1]])
+                    tri_et_compte(tri_selection, liste_croissante(nb))[1],
+                    tri_et_compte(tri_selection, liste_decroissante(nb))[1],
+                    tri_et_compte(tri_selection, liste_alea(nb, 0, 500))[1]])
 afficher_tableau(tableau)
 
 question(2)
@@ -220,9 +249,11 @@ partie("Analyse du tri par insertion")
 question(1)
 
 tableau = [tableau[0]]
-for i in range(1, 101):
+for nb in range(1, 101):
-    tableau.append([i, tri_et_compte(tri_insertion, liste_croissante(i))[1], tri_et_compte(
+    tableau.append([nb,
-        tri_insertion, liste_decroissante(i))[1], tri_et_compte(tri_insertion, liste_alea(i, 0, 500))[1]])
+                    tri_et_compte(tri_insertion, liste_croissante(nb))[1],
+                    tri_et_compte(tri_insertion, liste_decroissante(nb))[1],
+                    tri_et_compte(tri_insertion, liste_alea(nb, 0, 500))[1]])
 afficher_tableau(tableau)
 
 section("Dans le meilleur des cas")