From 18741cf2ab423bc403016110174c8ae95b32b442 Mon Sep 17 00:00:00 2001 From: Geoffrey Frogeye Date: Tue, 24 Feb 2015 14:29:20 +0100 Subject: [PATCH] TP4 Embelissement divers et PEP8 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Premier TP où il y a uniquement la règle C0103 qui n'est pas respectée ! --- S2/TP4/tp4.py | 306 ++++++++++++++++++++++++++++---------------------- 1 file changed, 171 insertions(+), 135 deletions(-) diff --git a/S2/TP4/tp4.py b/S2/TP4/tp4.py index 62d6493..4f80bc8 100644 --- a/S2/TP4/tp4.py +++ b/S2/TP4/tp4.py @@ -8,7 +8,7 @@ Univ. Lille 1 tp4.py -TP 4 +TP 4 - Algorithmes de recherche """ @@ -17,116 +17,131 @@ __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 +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) + while i < b and l[i] != x: + i += 1 + if i < b: + return (True, i) + else: + return (False, -1) -def seqTrie(l, a, b, x): # Jean-loup - """ - Recherche séquentielle de l'élément x dans la liste l triée, entre les bornes 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: l est triée et 0 <= a < b <= len(l) - """ - assert(a >=0 and b > a and b <= len(l)) +def seqTrie(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 triée entre + les bornes [a, b[, ainsi que sa position le cas échéant, -1 sinon, par méthode séquentielle. + 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)" - i=a + i = a - while i < b and l[i] < x: - i +=1 - if i < b and l[i] == x: - return (True, i) - else: - return (False, 0) + while i < b and l[i] < x: + i += 1 + if i < b and l[i] == x: + return (True, i) + else: + return (False, -1) -def dicho(l, a, b, x): # Geoffrey - """ - 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 dichotomie. - 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)" - d = a - f = b - 1 - while d < f: - m = (d+f)//2 - if l[m] < x: - d = m+1 - else: - f = m - est_dedans = x == l[d] - return (est_dedans, d if x == l[d] else -1) +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 + bornes [a, b[, ainsi que sa position le cas échéant, -1 sinon, par dichotomie. + 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)" -def tricho(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 trichotomie. - CU : l une liste, a et b des ints tels que 0 ≤ a < b ≤ len(l) - """ + d = a + f = b - 1 + while d < f: + m = (d + f) // 2 + if l[m] < x: + d = m + 1 + else: + f = m + est_dedans = x == l[d] + return (est_dedans, d if est_dedans else -1) - 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)" - d = a - f = b - 1 - while d < f: - m1 = (d+f)//3 - m2 = m1*2 - if l[m1] >= x: - f = m1 - elif l[m2] >= x: - d = m1+1 - f = m2 - else: - d = m2+1 - est_dedans = x == l[d] - return (est_dedans, d if x == l[d] else -1) +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)" -question(2) # Utiliser LEXIQUE + d = a + f = b - 1 + while d < f: + m1 = (d + f) // 3 + m2 = m1 * 2 + if l[m1] >= x: + f = m1 + elif l[m2] >= x: + d = m1 + 1 + f = m2 + else: + d = m2 + 1 + est_dedans = x == l[d] + return (est_dedans, d if x == l[d] else -1) -from lexique import * +question(2) # Utiliser LEXIQUE + +from lexique import LEXIQUE + +squestion('a') # Vérifier que LEXIQUE est triée -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): - if not l[i] < l[i+1]: - return False - return True + """ + list → bool + Indique si la liste l est triée dans l'ordre croissant + """ + for i in range(len(l) - 1): + if not l[i] < l[i + 1]: + return False + return True print("Le test indiquant si LEXIQUE est trié retourne %s." % est_trie(LEXIQUE)) @@ -134,69 +149,90 @@ 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") -LEXIQUE_TRIE = list(LEXIQUE) # Crée une copie +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 - # et comparer les temps d'éxécution selon les - # algorithmes utilisés +squestion('b') +# Effectuer de nombreuses recherches dans LEXIQUE +# 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): - elements = list() - taille = len(LEXIQUE) - for n in range(dans): - elements.append(LEXIQUE[randint(0, taille)]) - for n in range(hors): - while True: - mot = motAleatoire(randint(0, 10)) - if mot not in LEXIQUE: - break - elements.append(mot) - return elements + """ + 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(l) + for _ in range(dans): + elements.append(l[randint(0, taille)]) + for _ in range(hors): + while True: + mot = motAleatoire(randint(2, 10)) + if mot not in l: + break + elements.append(mot) + return elements # Méthode de test des fonctions from time import time from sys import stdout + + def mesure(methode, l, elements): - """ - function, list, list → ∅ - Mesure le temps mis pour rechercher les éléments elements dans l en utilisant methode et affiche - les résultats. - """ - t = len(l) - print("Test de la méthode %s..." % methode, end='') - stdout.flush() - debut = time() - 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"\ - % (methode, fin - debut, len(elements), (fin - debut)/len(elements))) + """ + function, list, list → ∅ + Mesure le temps mis pour rechercher les éléments elements dans l en utilisant methode et affiche + les résultats. + """ + t = len(l) + print("Test de la méthode %s..." % methode, end='') + stdout.flush() + debut = time() + 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." % (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) - exclu = creerListeRecherche(LEXIQUE, MESURE_DEFAUT, 0) - mesure(seq, LEXIQUE, exclu) - mesure(seqTrie, LEXIQUE_TRIE, exclu) - mesure(dicho, LEXIQUE_TRIE, exclu) + import sys + if len(sys.argv) == 1: + MESURE_DEFAUT = 500 + 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)) - 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) + PART_DEHORS = 0.2 + print("\nTest avec %d éléments dont %d sont dans LEXIQUE" % + (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)