TP4 Embelissement divers et PEP8

Premier TP où il y a uniquement la règle C0103
qui n'est pas respectée !

S2/TP4/tp4.py

@@ -8,7 +8,7 @@ Univ. Lille 1
 
 tp4.py
 
-TP 4
+TP 4 - Algorithmes de recherche
 
 """
 
@@ -17,53 +17,67 @@ __date_creation__ = 'Tue, 24 Feb 2015 10:30:21 +0100'
 
 
 def question(numero):
+    """
+    int → ∅
+    Affiche la question en cours
+    """
     print('\n***', 'Question', numero, '***')
 
+
 def squestion(lettre):
+    """
+    int → ∅
+    Affiche la sous-question en cours
+    """
     print('\n%s)' % lettre)
 
 
 question(1)  # Programmer recherches seq, seq triée, dicho
 
-def seq(l, a, b, x): # Jean-loup
-	"""
-		Recherche séquentielle de l'élément x dans la liste l, entre les borne a et b, b étant exclu
-		list(x), int, int, x → (bool, int)
-		Renvoie True et l'emplacement de x dans l, si x a été trouvé, sinon (False, 0)
-		CU: 0 <= a < b <= len(l)
-	"""
 
-	assert(a >=0 and b > a and b <= len(l))
+def seq(l, a, b, x):
+    """
+    list, int, int, a → (bool, int)
+    Renvoie un tuple contenant un booléen indiquant si l'élément x est dans la liste l entre les
+    bornes [a, b[, ainsi que sa position le cas échéant, -1 sinon, par méthode séquentielle.
+    CU : l une liste, a et b des ints tels que 0 ≤ a < b ≤ len(l)
+    """
+    assert(type(l) == list), "l doit être une liste"
+    assert(type(a) == type(b) == int), "a et b doivent être des ints"
+    assert(0 <= a < b <= len(l)), "Il faut que 0 ≤ a < b ≤ len(l)"
 
-	i=a
+    i = a
 
     while i < b and l[i] != x:
         i += 1
     if i < b:
         return (True, i)
     else:
-		return (False, 0)
+        return (False, -1)
 
-def seqTrie(l, a, b, x): # Jean-loup
+
+def seqTrie(l, a, b, x):
     """
-		Recherche séquentielle de l'élément x dans la liste l triée, entre les bornes a et b, b étant exclu
+    list, int, int, a → (bool, int)
-		list(x), int, int, x → (bool, int)
+    Renvoie un tuple contenant un booléen indiquant si l'élément x est dans la liste l triée entre
-		Renvoie True et l'emplacement de x dans l, si x a été trouvé, sinon (False, 0)
+    les bornes [a, b[, ainsi que sa position le cas échéant, -1 sinon, par méthode séquentielle.
-		CU: l est triée et 0 <= a < b <= len(l)
+    CU : l une liste triée, a et b des ints tels que 0 ≤ a < b ≤ len(l)
     """
+    assert(type(l) == list), "l doit être une liste triée"
+    assert(type(a) == type(b) == int), "a et b doivent être des ints"
+    assert(0 <= a < b <= len(l)), "Il faut que 0 ≤ a < b ≤ len(l)"
 
-	assert(a >=0 and b > a and b <= len(l))
+    i = a
-
-	i=a
 
     while i < b and l[i] < x:
-		i +=1
+        i += 1
     if i < b and l[i] == x:
         return (True, i)
     else:
-		return (False, 0)
+        return (False, -1)
 
-def  dicho(l, a, b, x): # Geoffrey
+
+def dicho(l, a, b, x):
     """
     list, int, int, a → (bool, int)
     Renvoie un tuple contenant un booléen indiquant si l'élément x est dans la liste l entre les
@@ -77,22 +91,22 @@ def  dicho(l, a, b, x): # Geoffrey
     d = a
     f = b - 1
     while d < f:
-		m = (d+f)//2
+        m = (d + f) // 2
         if l[m] < x:
-			d = m+1
+            d = m + 1
         else:
             f = m
     est_dedans = x == l[d]
-	return (est_dedans, d if x == l[d] else -1)
+    return (est_dedans, d if est_dedans else -1)
 
-def tricho(l, a, b, x):
+
+def tricho(l, a, b, x):  # TODO
     """
     list, int, int, a → (bool, int)
     Renvoie un tuple contenant un booléen indiquant si l'élément x est dans la liste l entre les
     bornes [a, b[, ainsi que sa position le cas échéant, -1 sinon, par trichotomie.
     CU : l une liste, a et b des ints tels que 0 ≤ a < b ≤ len(l)
     """
-
     assert(type(l) == list), "l doit être une liste"
     assert(type(a) == type(b) == int), "a et b doivent être des ints"
     assert(0 <= a < b <= len(l)), "Il faut que 0 ≤ a < b ≤ len(l)"
@@ -100,31 +114,32 @@ def tricho(l, a, b, x):
     d = a
     f = b - 1
     while d < f:
-		m1 = (d+f)//3
+        m1 = (d + f) // 3
-		m2 = m1*2
+        m2 = m1 * 2
         if l[m1] >= x:
             f = m1
         elif l[m2] >= x:
-			d = m1+1
+            d = m1 + 1
             f = m2
         else:
-			d = m2+1
+            d = m2 + 1
     est_dedans = x == l[d]
     return (est_dedans, d if x == l[d] else -1)
 
 question(2)  # Utiliser LEXIQUE
 
-from lexique import *
+from lexique import LEXIQUE
 
 squestion('a')  # Vérifier que LEXIQUE est triée
 
+
 def est_trie(l):
     """
     list → bool
     Indique si la liste l est triée dans l'ordre croissant
     """
-	for i in range(len(l)-1):
+    for i in range(len(l) - 1):
-		if not l[i] < l[i+1]:
+        if not l[i] < l[i + 1]:
             return False
     return True
 
@@ -134,33 +149,48 @@ print("Le lexique est cependant bien trié, mais par ordre alphabétique, compre
 cet ordre, ce qui n'est pas l'ordre \"naturel\" de Python, qui se base sur le codage des \
 caractères")
 
-print("Création de LEXIQUE_TRIE, qui est une copie de LEXIQUE trié par l'ordre de Python")
+print(
+    "Création de LEXIQUE_TRIE, qui est une copie de LEXIQUE trié par l'ordre de Python")
 LEXIQUE_TRIE = list(LEXIQUE)  # Crée une copie
 LEXIQUE_TRIE.sort()
 
-print("Le test indiquant si LEXIQUE_TRIE est trié retourne %s." % est_trie(LEXIQUE_TRIE))
+print("Le test indiquant si LEXIQUE_TRIE est trié retourne %s." %
+      est_trie(LEXIQUE_TRIE))
 
-squestion('b') # Effectuer de nombreuses recherches dans LEXIQUE
+squestion('b')
-			   # et comparer les temps d'éxécution selon les
+# Effectuer de nombreuses recherches dans LEXIQUE
-			   # algorithmes utilisés
+# et comparer les temps d'éxécution selon les
+# algorithmes utilisés
 
 # Définition des éléments choisis pour la recherche
 from random import randint, SystemRandom
-from string import ascii_lowercase, ascii_uppercase, digits
+from string import ascii_lowercase, ascii_uppercase
+
 
 def motAleatoire(taille):
-	return ''.join(SystemRandom().choice(ascii_lowercase + ascii_uppercase + digits) \
+    """
-		for i in range(taille))
+    int → str
+    Renvoie une mot aléatoire constitué de lettres (sans accent) minuscules et majuscules, et de
+    chiffres
+    """
+    return ''.join(SystemRandom().choice(ascii_lowercase + ascii_uppercase)
+                   for _ in range(taille))
+
 
 def creerListeRecherche(l, dans, hors):
+    """
+    list, int, int → list
+    Crée une liste de termes dont `dans` sont contenus dans `l`, et `hors` sont des mots générés
+    aléatoirement.
+    """
     elements = list()
-	taille = len(LEXIQUE)
+    taille = len(l)
-	for n in range(dans):
+    for _ in range(dans):
-		elements.append(LEXIQUE[randint(0, taille)])
+        elements.append(l[randint(0, taille)])
-	for n in range(hors):
+    for _ in range(hors):
         while True:
-			mot = motAleatoire(randint(0, 10))
+            mot = motAleatoire(randint(2, 10))
-			if mot not in LEXIQUE:
+            if mot not in l:
                 break
         elements.append(mot)
     return elements
@@ -168,6 +198,8 @@ def creerListeRecherche(l, dans, hors):
 # Méthode de test des fonctions
 from time import time
 from sys import stdout
+
+
 def mesure(methode, l, elements):
     """
     function, list, list → ∅
@@ -181,22 +213,26 @@ def mesure(methode, l, elements):
     for e in elements:
         methode(l, 0, t, e)
     fin = time()
-	print("\rLa méthode %s a pris %f secondes pour trouver %d éléments, soit %f secondes par élément"\
+    print("\rLa méthode %s a pris %f secondes pour trouver %d éléments, soit %f secondes par \
-		% (methode, fin - debut, len(elements), (fin - debut)/len(elements)))
+élément." % (methode, fin - debut, len(elements), (fin - debut) / len(elements)))
+
 
 if __name__ == '__main__':
     import sys
     if len(sys.argv) == 1:
         MESURE_DEFAUT = 500
-		print("\nTest avec %d éléments pris exclusivement de LEXIQUE" % MESURE_DEFAUT)
+        print("\nTest avec %d éléments pris exclusivement de LEXIQUE" %
+              MESURE_DEFAUT)
         exclu = creerListeRecherche(LEXIQUE, MESURE_DEFAUT, 0)
         mesure(seq, LEXIQUE, exclu)
         mesure(seqTrie, LEXIQUE_TRIE, exclu)
         mesure(dicho, LEXIQUE_TRIE, exclu)
 
         PART_DEHORS = 0.2
-		print("\nTest avec %d éléments dont %d sont dans LEXIQUE" % (MESURE_DEFAUT, (1-PART_DEHORS)*MESURE_DEFAUT))
+        print("\nTest avec %d éléments dont %d sont dans LEXIQUE" %
-		exclu = creerListeRecherche(LEXIQUE, int((1-PART_DEHORS)*MESURE_DEFAUT), int(PART_DEHORS * MESURE_DEFAUT))
+              (MESURE_DEFAUT, (1 - PART_DEHORS) * MESURE_DEFAUT))
+        exclu = creerListeRecherche(LEXIQUE, int(
+            (1 - PART_DEHORS) * MESURE_DEFAUT), int(PART_DEHORS * MESURE_DEFAUT))
         mesure(seq, LEXIQUE, exclu)
         mesure(seqTrie, LEXIQUE_TRIE, exclu)
         mesure(dicho, LEXIQUE_TRIE, exclu)