TP4 Embelissement divers et PEP8
Premier TP où il y a uniquement la règle C0103 qui n'est pas respectée !
This commit is contained in:
parent
ddfeecd79d
commit
18741cf2ab
306
S2/TP4/tp4.py
306
S2/TP4/tp4.py
|
|
@ -8,7 +8,7 @@ Univ. Lille 1
|
||||||
|
|
||||||
tp4.py
|
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):
|
def question(numero):
|
||||||
|
"""
|
||||||
|
int → ∅
|
||||||
|
Affiche la question en cours
|
||||||
|
"""
|
||||||
print('\n***', 'Question', numero, '***')
|
print('\n***', 'Question', numero, '***')
|
||||||
|
|
||||||
|
|
||||||
def squestion(lettre):
|
def squestion(lettre):
|
||||||
|
"""
|
||||||
|
int → ∅
|
||||||
|
Affiche la sous-question en cours
|
||||||
|
"""
|
||||||
print('\n%s)' % lettre)
|
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:
|
while i < b and l[i] != x:
|
||||||
i += 1
|
i += 1
|
||||||
if i < b:
|
if i < b:
|
||||||
return (True, i)
|
return (True, i)
|
||||||
else:
|
else:
|
||||||
return (False, 0)
|
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:
|
while i < b and l[i] < x:
|
||||||
i +=1
|
i += 1
|
||||||
if i < b and l[i] == x:
|
if i < b and l[i] == x:
|
||||||
return (True, i)
|
return (True, i)
|
||||||
else:
|
else:
|
||||||
return (False, 0)
|
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
|
def dicho(l, a, b, x):
|
||||||
f = b - 1
|
"""
|
||||||
while d < f:
|
list, int, int, a → (bool, int)
|
||||||
m = (d+f)//2
|
Renvoie un tuple contenant un booléen indiquant si l'élément x est dans la liste l entre les
|
||||||
if l[m] < x:
|
bornes [a, b[, ainsi que sa position le cas échéant, -1 sinon, par dichotomie.
|
||||||
d = m+1
|
CU : l une liste, a et b des ints tels que 0 ≤ a < b ≤ len(l)
|
||||||
else:
|
"""
|
||||||
f = m
|
assert(type(l) == list), "l doit être une liste"
|
||||||
est_dedans = x == l[d]
|
assert(type(a) == type(b) == int), "a et b doivent être des ints"
|
||||||
return (est_dedans, d if x == l[d] else -1)
|
assert(0 <= a < b <= len(l)), "Il faut que 0 ≤ a < b ≤ len(l)"
|
||||||
|
|
||||||
def tricho(l, a, b, x):
|
d = a
|
||||||
"""
|
f = b - 1
|
||||||
list, int, int, a → (bool, int)
|
while d < f:
|
||||||
Renvoie un tuple contenant un booléen indiquant si l'élément x est dans la liste l entre les
|
m = (d + f) // 2
|
||||||
bornes [a, b[, ainsi que sa position le cas échéant, -1 sinon, par trichotomie.
|
if l[m] < x:
|
||||||
CU : l une liste, a et b des ints tels que 0 ≤ a < b ≤ len(l)
|
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
|
def tricho(l, a, b, x): # TODO
|
||||||
f = b - 1
|
"""
|
||||||
while d < f:
|
list, int, int, a → (bool, int)
|
||||||
m1 = (d+f)//3
|
Renvoie un tuple contenant un booléen indiquant si l'élément x est dans la liste l entre les
|
||||||
m2 = m1*2
|
bornes [a, b[, ainsi que sa position le cas échéant, -1 sinon, par trichotomie.
|
||||||
if l[m1] >= x:
|
CU : l une liste, a et b des ints tels que 0 ≤ a < b ≤ len(l)
|
||||||
f = m1
|
"""
|
||||||
elif l[m2] >= x:
|
assert(type(l) == list), "l doit être une liste"
|
||||||
d = m1+1
|
assert(type(a) == type(b) == int), "a et b doivent être des ints"
|
||||||
f = m2
|
assert(0 <= a < b <= len(l)), "Il faut que 0 ≤ a < b ≤ len(l)"
|
||||||
else:
|
|
||||||
d = m2+1
|
|
||||||
est_dedans = x == l[d]
|
|
||||||
return (est_dedans, d if x == l[d] else -1)
|
|
||||||
|
|
||||||
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):
|
def est_trie(l):
|
||||||
"""
|
"""
|
||||||
list → bool
|
list → bool
|
||||||
Indique si la liste l est triée dans l'ordre croissant
|
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 False
|
||||||
return True
|
return True
|
||||||
|
|
||||||
print("Le test indiquant si LEXIQUE est trié retourne %s." % est_trie(LEXIQUE))
|
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 \
|
cet ordre, ce qui n'est pas l'ordre \"naturel\" de Python, qui se base sur le codage des \
|
||||||
caractères")
|
caractères")
|
||||||
|
|
||||||
print("Création de LEXIQUE_TRIE, qui est une copie de LEXIQUE trié par l'ordre de Python")
|
print(
|
||||||
LEXIQUE_TRIE = list(LEXIQUE) # Crée une copie
|
"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()
|
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
|
# Définition des éléments choisis pour la recherche
|
||||||
from random import randint, SystemRandom
|
from random import randint, SystemRandom
|
||||||
from string import ascii_lowercase, ascii_uppercase, digits
|
from string import ascii_lowercase, ascii_uppercase
|
||||||
|
|
||||||
|
|
||||||
def motAleatoire(taille):
|
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):
|
def creerListeRecherche(l, dans, hors):
|
||||||
elements = list()
|
"""
|
||||||
taille = len(LEXIQUE)
|
list, int, int → list
|
||||||
for n in range(dans):
|
Crée une liste de termes dont `dans` sont contenus dans `l`, et `hors` sont des mots générés
|
||||||
elements.append(LEXIQUE[randint(0, taille)])
|
aléatoirement.
|
||||||
for n in range(hors):
|
"""
|
||||||
while True:
|
elements = list()
|
||||||
mot = motAleatoire(randint(0, 10))
|
taille = len(l)
|
||||||
if mot not in LEXIQUE:
|
for _ in range(dans):
|
||||||
break
|
elements.append(l[randint(0, taille)])
|
||||||
elements.append(mot)
|
for _ in range(hors):
|
||||||
return elements
|
while True:
|
||||||
|
mot = motAleatoire(randint(2, 10))
|
||||||
|
if mot not in l:
|
||||||
|
break
|
||||||
|
elements.append(mot)
|
||||||
|
return elements
|
||||||
|
|
||||||
# Méthode de test des fonctions
|
# Méthode de test des fonctions
|
||||||
from time import time
|
from time import time
|
||||||
from sys import stdout
|
from sys import stdout
|
||||||
|
|
||||||
|
|
||||||
def mesure(methode, l, elements):
|
def mesure(methode, l, elements):
|
||||||
"""
|
"""
|
||||||
function, list, list → ∅
|
function, list, list → ∅
|
||||||
Mesure le temps mis pour rechercher les éléments elements dans l en utilisant methode et affiche
|
Mesure le temps mis pour rechercher les éléments elements dans l en utilisant methode et affiche
|
||||||
les résultats.
|
les résultats.
|
||||||
"""
|
"""
|
||||||
t = len(l)
|
t = len(l)
|
||||||
print("Test de la méthode %s..." % methode, end='')
|
print("Test de la méthode %s..." % methode, end='')
|
||||||
stdout.flush()
|
stdout.flush()
|
||||||
debut = time()
|
debut = time()
|
||||||
for e in elements:
|
for e in elements:
|
||||||
methode(l, 0, t, e)
|
methode(l, 0, t, e)
|
||||||
fin = time()
|
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__':
|
if __name__ == '__main__':
|
||||||
import sys
|
import sys
|
||||||
if len(sys.argv) == 1:
|
if len(sys.argv) == 1:
|
||||||
MESURE_DEFAUT = 500
|
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" %
|
||||||
exclu = creerListeRecherche(LEXIQUE, MESURE_DEFAUT, 0)
|
MESURE_DEFAUT)
|
||||||
mesure(seq, LEXIQUE, exclu)
|
exclu = creerListeRecherche(LEXIQUE, MESURE_DEFAUT, 0)
|
||||||
mesure(seqTrie, LEXIQUE_TRIE, exclu)
|
mesure(seq, LEXIQUE, exclu)
|
||||||
mesure(dicho, LEXIQUE_TRIE, exclu)
|
mesure(seqTrie, LEXIQUE_TRIE, exclu)
|
||||||
|
mesure(dicho, LEXIQUE_TRIE, exclu)
|
||||||
|
|
||||||
PART_DEHORS = 0.2
|
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))
|
||||||
mesure(seq, LEXIQUE, exclu)
|
exclu = creerListeRecherche(LEXIQUE, int(
|
||||||
mesure(seqTrie, LEXIQUE_TRIE, exclu)
|
(1 - PART_DEHORS) * MESURE_DEFAUT), int(PART_DEHORS * MESURE_DEFAUT))
|
||||||
mesure(dicho, LEXIQUE_TRIE, exclu)
|
mesure(seq, LEXIQUE, exclu)
|
||||||
|
mesure(seqTrie, LEXIQUE_TRIE, exclu)
|
||||||
|
mesure(dicho, LEXIQUE_TRIE, exclu)
|
||||||
|
|
|
||||||
Reference in a new issue