520 lines
13 KiB
Python
520 lines
13 KiB
Python
# PREUD'HOMME Geoffrey
|
|
# BEAUSSART Jean-loup
|
|
# Donné le 27/01/2015
|
|
|
|
# TP2 Anagrammes - Dictionnaires
|
|
|
|
# http://www.fil.univ-lille1.fr/~L1S2API/CoursTP/tp2_dictionnaires.html
|
|
|
|
|
|
def partie(nom):
|
|
print('\n', nom, '=' * len(nom), sep='\n')
|
|
|
|
|
|
def section(nom):
|
|
print('\n', nom, '-' * len(nom), sep='\n')
|
|
|
|
|
|
def question(numero):
|
|
print('\n***', 'Question', numero, '***')
|
|
|
|
|
|
partie('Quelques méthodes sur les listes et les chaînes') # Geoffrey
|
|
|
|
|
|
section('Méthode split')
|
|
|
|
question(1)
|
|
print(">>> s = 'la méthode split est parfois bien utile'")
|
|
s = 'la méthode split est parfois bien utile'
|
|
print(">>> s.split (' ')")
|
|
print(s.split(' '))
|
|
print(">>> s.split ('e')")
|
|
print(s.split('e'))
|
|
print(">>> s.split ('é')")
|
|
print(s.split('é'))
|
|
print(">>> s.split ()")
|
|
print(s.split())
|
|
print(">>> s.split ('')")
|
|
print('ValueError: empty separator')
|
|
print(">>> s.split ('split')")
|
|
print(s.split('split'))
|
|
|
|
question(2)
|
|
print('La méthode `split` renvoie la liste des chaînes de la découpe de la chaîne sur laquelle est \
|
|
appliquée la fonction par la chaîne passée en argument (ou à défaut le caractères d\'espacement')
|
|
|
|
question(3)
|
|
print(">>> s = 'la méthode split est parfois bien utile'")
|
|
s = 'la méthode split est parfois bien utile'
|
|
print(">>> s.split(' ')")
|
|
print(s.split(' '))
|
|
print('>>> s')
|
|
print('\'' + s + '\'')
|
|
|
|
print('De par cet exemple, on remarque que s reste la même chaîne de caractère, `split` ne modifie \
|
|
donc pas la chaîne de caractères à laquelle elle s\'applique (ce qui est logique vu le caractère \
|
|
non-mutable des chaînes de caractères')
|
|
|
|
|
|
section('Méthode join')
|
|
|
|
question(1)
|
|
print(">>> s = 'la méthode split est parfois bien utile'")
|
|
s = 'la méthode split est parfois bien utile'
|
|
print('>>> l = s.split()')
|
|
l = s.split()
|
|
print('>>> "".join (l)')
|
|
print("".join(l))
|
|
print('>>> " ".join (l)')
|
|
print(" ".join(l))
|
|
print('>>> ";".join (l)')
|
|
print(";".join(l))
|
|
print('>>> " tralala ".join (l)')
|
|
print(" tralala ".join(l))
|
|
print('>>> "\n".join (l)')
|
|
print("\n".join(l))
|
|
print('>>> "".join (s)')
|
|
print("".join(s))
|
|
print('>>> "!".join (s)')
|
|
print("!".join(s))
|
|
print('>>> "".join ()')
|
|
print('TypeError: join() takes exactly one argument (0 given)')
|
|
print('>>> "".join ([])')
|
|
print("".join([]))
|
|
print('>>> "".join ([1,2])')
|
|
print('TypeError: sequence item 0: expected str instance, int found')
|
|
|
|
question(2)
|
|
print('La méthode join concatène les chaînes de caractères contenues dans la liste passée en \
|
|
paramètre, en insérant entre deux la chaîne de caractère sur laquelle elle est appliquée.')
|
|
|
|
question(3)
|
|
print('>>> chaine = \'!\'')
|
|
chaine = '!'
|
|
print('>>> chaine.join(l)')
|
|
print(chaine.join(l))
|
|
print('>>> chaine')
|
|
print('\'' + chaine + '\'')
|
|
|
|
|
|
print('De par cet exemple, on remarque que chaine reste la même chaîne de caractères, `join` ne \
|
|
modifie donc pas la chaîne de caractères à laquelle elle s\'applique (ce qui est logique vu le \
|
|
caractère non-mutable des chaînes de caractères')
|
|
|
|
question(4)
|
|
|
|
|
|
def join(chaine, sequence):
|
|
"""
|
|
Retourne la concaténation des éléments de séquence en insérant chaine entre eux.
|
|
str, [str *] → str
|
|
"""
|
|
res = ''
|
|
l = len(sequence)
|
|
for i in range(l):
|
|
res += sequence[i]
|
|
if i < l - 1:
|
|
res += chaine
|
|
return res
|
|
|
|
print(">>> join('.', ['raymond', 'calbuth', 'ronchin', 'fr'])")
|
|
print(join('.', ['raymond', 'calbuth', 'ronchin', 'fr']))
|
|
|
|
|
|
section('Méthode sort')
|
|
|
|
question(1)
|
|
print('>>> l = list (\'timoleon\')')
|
|
l = list('timoleon')
|
|
print('>>> l.sort()')
|
|
l.sort()
|
|
print('>>> l')
|
|
print(l)
|
|
|
|
print('La méthode sort semble trier les lettres par ordre alphabétique')
|
|
|
|
print('>>> s = "Je n\'ai jamais joué de flûte."')
|
|
s = "Je n'ai jamais joué de flûte."
|
|
print('>>> l = list (s)')
|
|
l = list(s)
|
|
print('>>> l.sort()')
|
|
l.sort()
|
|
print('>>> l')
|
|
print(l)
|
|
|
|
print('La méthode sort trie aussi les caractères spéciaux : ponctuation au début, accents à la fin')
|
|
|
|
print('Il semblerait que la méthode sort trie les caractères de s selon l\'ordre croissant de leur \
|
|
numéro de code ASCII (ou tout encodage utilisé)')
|
|
|
|
question(2)
|
|
print('>>> l = [\'a\', 1]')
|
|
print('>>> l.sort()')
|
|
print('TypeError: unorderable types: int() < str()')
|
|
|
|
print('On obtient une erreur comme quoi les types str et int ne sont pas ordonnable. En effet, il \
|
|
n\'est pas logique d\'ordonner des caractères avec des chiffres.')
|
|
print('Notons qu\'il aurait très bien pu être possible que cette méthode utilise le code des \
|
|
caractères, puisque celui-ci est de type int, comme c\'était le cas avec Python 2.')
|
|
|
|
|
|
section('Une fonction sort pour les chaînes')
|
|
|
|
question(1)
|
|
|
|
|
|
def sort(chaine):
|
|
"""
|
|
Trie les caractères de chaine par ordre de codage.
|
|
str → str
|
|
"""
|
|
t = list(chaine)
|
|
t.sort()
|
|
return ''.join(t)
|
|
|
|
print('>>> sort(\'timoleon\')')
|
|
print(sort('timoleon'))
|
|
|
|
|
|
partie('Anagrammes') # Jean-loup
|
|
|
|
question(1)
|
|
|
|
|
|
def sont_anagrammes1(chaine1, chaine2):
|
|
"""
|
|
Indique si chaine1 et chaine2 sont anagrammes
|
|
str, str → bool
|
|
CU : chaine1 et chaine2 sont des str
|
|
"""
|
|
|
|
assert(type(chaine1) == type(chaine2) ==
|
|
str), 'chaine1 et chaine2 doivent être des str'
|
|
|
|
# Si la longueur est différente, ça ne peut pas être des anagrammes
|
|
if len(chaine1) != len(chaine2):
|
|
return False
|
|
|
|
c1 = sort(chaine1)
|
|
c2 = sort(chaine2)
|
|
|
|
return c1 == c2
|
|
|
|
question(2)
|
|
|
|
|
|
def sont_anagrammes2(chaine1, chaine2):
|
|
"""
|
|
Indique si chaine1 et chaine2 sont anagrammes
|
|
str, str → bool
|
|
CU : chaine1 et chaine2 sont des str
|
|
"""
|
|
|
|
assert(type(chaine1) == type(chaine2) ==
|
|
str), 'chaine1 et chaine2 doivent être des str'
|
|
|
|
# Si la longueur est différente, ça ne peut pas être des anagrammes
|
|
if len(chaine1) != len(chaine2):
|
|
return False
|
|
|
|
occu1 = dict((i, chaine1.count(i)) for i in chaine1)
|
|
occu2 = dict((i, chaine2.count(i)) for i in chaine2)
|
|
|
|
return occu1 == occu2
|
|
|
|
question(3)
|
|
|
|
|
|
def sont_anagrammes3(chaine1, chaine2):
|
|
"""
|
|
Indique si chaine1 et chaine2 sont anagrammes
|
|
str, str → bool
|
|
CU : chaine1 et chaine2 sont des str
|
|
"""
|
|
|
|
assert(type(chaine1) == type(chaine2) ==
|
|
str), 'chaine1 et chaine2 doivent être des str'
|
|
|
|
# Si la longueur est différente, ça ne peut pas être des anagrammes
|
|
if len(chaine1) != len(chaine2):
|
|
return False
|
|
|
|
for i in chaine1:
|
|
if chaine1.count(i) != chaine2.count(i):
|
|
return False
|
|
|
|
return True
|
|
|
|
|
|
section('Casse et accentuation')
|
|
|
|
question(1)
|
|
EQUIV_NON_ACCENTUE = {'é': 'e', 'è': 'e', 'à': 'a', 'ç': 'c', 'î': 'i', 'ï':
|
|
'i', 'ô': 'o', 'ê': 'e', 'ë': 'e', 'â': 'a', 'û': 'u', 'ü': 'u', 'ù': 'u'}
|
|
|
|
question(2)
|
|
|
|
|
|
def bas_casse_sans_accent(chaine):
|
|
"""
|
|
Renvoie l'équivalent minuscule non accentuée de la chaîne passée en paramètre
|
|
str → str
|
|
CU : chaine est un str
|
|
"""
|
|
|
|
assert(type(chaine) == str), 'chaine doit être un str'
|
|
|
|
chaineCpy = chaine.lower()
|
|
|
|
ret = ""
|
|
|
|
for i in chaineCpy:
|
|
if i in EQUIV_NON_ACCENTUE:
|
|
ret += EQUIV_NON_ACCENTUE[i]
|
|
else:
|
|
ret += i
|
|
return ret
|
|
|
|
question(3)
|
|
|
|
|
|
def sont_anagrammes_sans_casse_ni_accent(chaine1, chaine2):
|
|
"""
|
|
Indique si chaine1 et chaine2 sont anagrammes sans de tenir compte de la casse ni des accents
|
|
str, str → bool
|
|
CU : chaine1 et chaine2 sont des str
|
|
"""
|
|
|
|
assert(type(chaine1) == type(chaine2) ==
|
|
str), 'chaine1 et chaine2 doivent être des str'
|
|
|
|
# Si la longueur est différente, ça ne peut pas être des anagrammes
|
|
if len(chaine1) != len(chaine2):
|
|
return False
|
|
|
|
chaine1Cpy = bas_casse_sans_accent(chaine1)
|
|
chaine2Cpy = bas_casse_sans_accent(chaine2)
|
|
|
|
return sont_anagrammes2(chaine1Cpy, chaine2Cpy)
|
|
|
|
|
|
partie('Recherche d\'anagrammes') # Jean-loup
|
|
|
|
|
|
section('Le lexique')
|
|
|
|
question(1)
|
|
|
|
question(2)
|
|
from lexique import *
|
|
|
|
question(3)
|
|
print('Il y a %d mots dans le lexique' % len(LEXIQUE))
|
|
|
|
question(4)
|
|
test = len(LEXIQUE) == len(set(LEXIQUE))
|
|
# Bien que l'on ai vu en cours que cette méthode n'est pas la plus économique en mémoire, c'est
|
|
# bizarrement la plus rapide
|
|
print('Le test a retourné %s.' % test)
|
|
|
|
|
|
section('Anagrammes d\'un mot : première méthode')
|
|
|
|
question(1)
|
|
|
|
|
|
def anagrammes(mot):
|
|
"""
|
|
Recherche les anagrammes de mot
|
|
str → [str *]
|
|
CU : mot est un str
|
|
"""
|
|
|
|
assert(type(mot) == str), 'mot doit être un str'
|
|
|
|
return [i for i in LEXIQUE if sont_anagrammes_sans_casse_ni_accent(i, mot)]
|
|
|
|
question(2)
|
|
for a in ['Orange', 'Calbuth']:
|
|
print('Les anagrammes de %s sont %s.' % (a, ', '.join(anagrammes(a))))
|
|
|
|
|
|
section('Anagrammes d\'un mot : seconde méthode')
|
|
|
|
question(1)
|
|
print('Il se peut que certains mots du lexique soient des anagrammes d\'autres mots du lexique,\
|
|
or on se retrouverait alors avec plusieurs fois la même liste d\'anagrammes \
|
|
pour des clés différentes.')
|
|
|
|
question(2)
|
|
|
|
|
|
def cle(mot):
|
|
"""
|
|
Renvoie la version triée des lettres en minuscule et sans accents de mot
|
|
str → str
|
|
CU : mot est un str
|
|
"""
|
|
|
|
assert(type(mot) == str), 'mot doit être un str'
|
|
|
|
cpy = bas_casse_sans_accent(mot)
|
|
|
|
return sort(cpy)
|
|
|
|
question(3)
|
|
ANAGRAMMES = dict()
|
|
|
|
for m in LEXIQUE:
|
|
k = cle(m)
|
|
if not k in ANAGRAMMES:
|
|
ANAGRAMMES[k] = [m]
|
|
else:
|
|
ANAGRAMMES[k] = ANAGRAMMES[k] + [m]
|
|
|
|
|
|
print('Le dictionnaire des anagrammes contient %d entrées' % len(ANAGRAMMES))
|
|
|
|
question(4)
|
|
|
|
|
|
def anagrammes2(mot):
|
|
"""
|
|
Recherche les anagrammes de mot
|
|
str → [str *]
|
|
CU : mot est un str
|
|
"""
|
|
|
|
assert(type(mot) == str), 'mot doit être un str'
|
|
|
|
k = cle(mot)
|
|
|
|
if k in ANAGRAMMES:
|
|
return ANAGRAMMES[k]
|
|
else:
|
|
return []
|
|
|
|
question(5)
|
|
for a in ['Orange', 'Calbuth']:
|
|
print('Les anagrammes de %s sont %s.' % (a, ', '.join(anagrammes2(a))))
|
|
|
|
|
|
section('Comparaison des deux méthodes')
|
|
|
|
question(1)
|
|
NB_TESTS = 30 # Mettre à 0 pour réduire l'attente
|
|
|
|
import time
|
|
|
|
debut = time.time()
|
|
for t in range(NB_TESTS):
|
|
anagrammes(LEXIQUE[t])
|
|
temps1 = time.time() - debut
|
|
|
|
debut = time.time()
|
|
for t in range(NB_TESTS):
|
|
anagrammes2(LEXIQUE[t])
|
|
temps2 = time.time() - debut
|
|
|
|
print('La première méthode a duré %s secondes, et la deuxième %s secondes.' % (temps1, temps2),
|
|
'La deuxième méthode est %0.2f fois plus efficace que la première.' % (
|
|
temps1 / temps2),
|
|
'En effet, la première vérifie %d combinaisons d\'anagrammes, alors que la deuxième ne \
|
|
réalise qu\'un accès à un dictionnaire. Notons que la construction dudit dictionnaire a lui aussi \
|
|
pris un certain temps, mais reste négligeable par rapport à la première méthode.' % len(LEXIQUE),
|
|
sep='\n')
|
|
|
|
partie('Phrases d\'anagrammes') # Geoffrey
|
|
|
|
question(1)
|
|
|
|
def liste_possibilites(arbre, precede):
|
|
"""
|
|
Renvoie la liste des possibilités à partir d'un arbre de possibilités.
|
|
dict, list → list
|
|
|
|
>>> liste_possibilites(annagrammes_arbre(['mange', 'ton']), [])
|
|
[['mange', 'ton'], ['mange', 'ont'], ['mangé', 'ton'], ['mangé', 'ont']]
|
|
"""
|
|
possibilites = []
|
|
for branche in arbre:
|
|
if type(arbre[branche]) == dict:
|
|
possibilites = possibilites + \
|
|
liste_possibilites(arbre[branche], precede + [branche])
|
|
elif arbre[branche] == None:
|
|
possibilites = possibilites + [precede + [branche]]
|
|
return possibilites
|
|
|
|
|
|
def annagrammes_arbre(liste):
|
|
"""
|
|
Renvoie l'arbre des anagrammes possibles à partir d'une liste de mots.
|
|
list → dict
|
|
|
|
>>> annagrammes_arbre(['mange', 'ton'])
|
|
{'mange': {'ton': None, 'ont': None}, 'mangé': {'ton': None, 'ont': None}}
|
|
"""
|
|
anagrammesPremier = anagrammes2(liste[0])
|
|
if len(liste) > 1: # Si il y a des anagrammes après
|
|
return dict((i, annagrammes_arbre(liste[1:])) for i in anagrammesPremier)
|
|
else:
|
|
return dict((i, None) for i in anagrammesPremier)
|
|
|
|
|
|
def annagrammes_phrase(phrase):
|
|
"""
|
|
Renvoie la liste des anagrammes possibles à partir d'une phrase.
|
|
str → str
|
|
|
|
>>> annagrammes_phrase('mange ton')
|
|
['mange ton', 'mange ont', 'mangé ton', 'mangé ont']
|
|
"""
|
|
mots = phrase.split()
|
|
arbre = annagrammes_arbre(mots)
|
|
liste = liste_possibilites(arbre, [])
|
|
return [' '.join(i) for i in liste]
|
|
|
|
print('>>> annagrammes_phrase(\'Mange ton orange\')')
|
|
print(annagrammes_phrase('Mange ton orange'))
|
|
|
|
|
|
partie('Sauvegarde et récupération')
|
|
|
|
ANAGRAMMES_FICHIER = 'anagrammes.txt'
|
|
|
|
question(1)
|
|
|
|
|
|
def sauver_dico():
|
|
"""
|
|
Sauvegarde le dictionnaire des anagrammes dans un fichier.
|
|
∅ → ∅
|
|
"""
|
|
fichier = open(ANAGRAMMES_FICHIER, 'w')
|
|
for i in ANAGRAMMES:
|
|
fichier.write(i + ':' + ':'.join(ANAGRAMMES[i]) + '\n')
|
|
fichier.close()
|
|
|
|
question(2)
|
|
sauver_dico()
|
|
from os.path import getsize
|
|
taille = getsize(ANAGRAMMES_FICHIER)
|
|
print('Le dictionnaire fait %d octets, soit %0.3f Mio.' %
|
|
(taille, taille / 1024 / 1024))
|
|
|
|
question(3)
|
|
|
|
|
|
def charger_dico():
|
|
"""
|
|
Lit le dictionnaire des anagrammes depuis un fichier.
|
|
∅ → ∅
|
|
"""
|
|
ANAGRAMMES = dict()
|
|
fichier = open(ANAGRAMMES_FICHIER, 'r')
|
|
for ligne in fichier:
|
|
decoupe = ':'.split(str(ligne))
|
|
ANAGRAMMES[decoupe[0]] = decoupe[1:]
|
|
fichier.close()
|