geoffrey/s1-tp
geoffrey/s1-tp
Archived
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

TP2 Merge I guess?

Browse source
This commit is contained in:
Geoffrey Frogeye 2015-02-03 10:52:49 +01:00
parent 9a0a5789f3 3110e49c4b
commit dda8548c23
1 changed files with 149 additions and 89 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

214
S2/TP2/tp2.py
View file

@ -30,40 +30,42 @@ question(1)
# TODO utf-8 # TODO utf-8
# TODO en print # TODO en print
##>>> s = 'la méthode split est parfois bien utile' # >>> s = 'la méthode split est parfois bien utile'
##>>> s.split (' ') # >>> s.split (' ')
##['la', 'm\xc3\xa9thode', 'split', 'est', 'parfois', 'bien', 'utile'] ##['la', 'm\xc3\xa9thode', 'split', 'est', 'parfois', 'bien', 'utile']
##>>> s.split ('e') # >>> s.split ('e')
##['la m\xc3\xa9thod', ' split ', 'st parfois bi', 'n util', ''] ##['la m\xc3\xa9thod', ' split ', 'st parfois bi', 'n util', '']
##>>> s.split ('é') # >>> s.split ('é')
##['la m', 'thode split est parfois bien utile'] ##['la m', 'thode split est parfois bien utile']
##>>> s.split () # >>> s.split ()
##['la', 'm\xc3\xa9thode', 'split', 'est', 'parfois', 'bien', 'utile'] ##['la', 'm\xc3\xa9thode', 'split', 'est', 'parfois', 'bien', 'utile']
##>>> s.split ('') # >>> s.split ('')
##Traceback (most recent call last): # Traceback (most recent call last):
## File "<stdin>", line 1, in <module> # File "<stdin>", line 1, in <module>
##ValueError: empty separator # ValueError: empty separator
##>>> s.split ('split') # >>> s.split ('split')
##['la m\xc3\xa9thode ', ' est parfois bien utile'] ##['la m\xc3\xa9thode ', ' est parfois bien utile']
question(2) question(2)
# TODO Reformuler # TODO Reformuler
print('La méthode `split` appliquée à une chaîne de caractères renvoie une liste de châines de caractères correspondant à la chaîne de caractère originale découpée aux endroits où se trouvent la chaîne de caractère passée en paramètre (ou si absente, la chaîne de caractère contenant le caractère espacement seul), exemptée de cette dernière.') print(
'La méthode `split` appliquée à une chaîne de caractères renvoie une liste de châines de caractères correspondant à la chaîne de caractère originale découpée aux endroits où se trouvent la chaîne de caractère passée en paramètre (ou si absente, la chaîne de caractère contenant le caractère espacement seul), exemptée de cette dernière.')
question(3) question(3)
# TODO utf-8 # TODO utf-8
# TODO en print # TODO en print
##>>> s = "la méthode split est parfois bien utile" # >>> s = "la méthode split est parfois bien utile"
##>>> s.split(' ') # >>> s.split(' ')
##['la', 'm\xc3\xa9thode', 'split', 'est', 'parfois', 'bien', 'utile'] ##['la', 'm\xc3\xa9thode', 'split', 'est', 'parfois', 'bien', 'utile']
##>>> s # >>> s
##'la m\xc3\xa9thode split est parfois bien utile' ##'la m\xc3\xa9thode split est parfois bien utile'
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ère à laquelle elle s\'applique (ce qui est logique vu le caractère non-mutable des chaînes de caractère') 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ère à laquelle elle s\'applique (ce qui est logique vu le caractère non-mutable des chaînes de caractère')
section('Méthode join') section('Méthode join')
@ -73,63 +75,66 @@ question(1)
# TODO utf-8 # TODO utf-8
# TODO en print # TODO en print
##>>> l = s.split() # >>> l = s.split()
##'lam\xc3\xa9thodesplitestparfoisbienutile' # 'lam\xc3\xa9thodesplitestparfoisbienutile'
##>>> " ".join (l) # >>> " ".join (l)
##'la m\xc3\xa9thode split est parfois bien utile' ##'la m\xc3\xa9thode split est parfois bien utile'
##>>> ";".join (l) # >>> ";".join (l)
##'la;m\xc3\xa9thode;split;est;parfois;bien;utile' # 'la;m\xc3\xa9thode;split;est;parfois;bien;utile'
##>>> " tralala ".join (l) # >>> " tralala ".join (l)
##'la tralala m\xc3\xa9thode tralala split tralala est tralala parfois tralala bien tralala utile' ##'la tralala m\xc3\xa9thode tralala split tralala est tralala parfois tralala bien tralala utile'
##>>> print ("\n".join (l)) # >>> print ("\n".join (l))
##la # la
##méthode # méthode
##split # split
##est # est
##parfois # parfois
##bien # bien
##utile # utile
##>>> "".join (s) # >>> "".join (s)
##'la m\xc3\xa9thode split est parfois bien utile' ##'la m\xc3\xa9thode split est parfois bien utile'
##>>> "!".join (s) # >>> "!".join (s)
##'l!a! !m!\xc3!\xa9!t!h!o!d!e! !s!p!l!i!t! !e!s!t! !p!a!r!f!o!i!s! !b!i!e!n! !u!t!i!l!e' ##'l!a! !m!\xc3!\xa9!t!h!o!d!e! !s!p!l!i!t! !e!s!t! !p!a!r!f!o!i!s! !b!i!e!n! !u!t!i!l!e'
##>>> "".join () # >>> "".join ()
##Traceback (most recent call last): # Traceback (most recent call last):
## File "<stdin>", line 1, in <module> # File "<stdin>", line 1, in <module>
##TypeError: join() takes exactly one argument (0 given) # TypeError: join() takes exactly one argument (0 given)
##>>> "".join ([]) # >>> "".join ([])
##'' # ''
##>>> "".join ([1,2]) # >>> "".join ([1,2])
##Traceback (most recent call last): # Traceback (most recent call last):
## File "<stdin>", line 1, in <module> # File "<stdin>", line 1, in <module>
##TypeError: sequence item 0: expected string, int found # TypeError: sequence item 0: expected string, int found
question(2) 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.') 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) question(3)
# TODO utf-8 # TODO utf-8
# TODO en print # TODO en print
##>>> chaine = '!' # >>> chaine = '!'
##>>> chaine.join(l) # >>> chaine.join(l)
##'la!m\xc3\xa9thode!split!est!parfois!bien!utile' # 'la!m\xc3\xa9thode!split!est!parfois!bien!utile'
##>>> chaine # >>> chaine
##'!' # '!'
print('De par cet exemple, on remarque que chaine reste la même chaîne de caractère, `join` ne modifie donc pas la chaîne de caractère à laquelle elle s\'applique (ce qui est logique vu le caractère non-mutable des chaînes de caractère') print(
'De par cet exemple, on remarque que chaine reste la même chaîne de caractère, `join` ne modifie donc pas la chaîne de caractère à laquelle elle s\'applique (ce qui est logique vu le caractère non-mutable des chaînes de caractère')
question(4) question(4)
def join(chaine, sequence): def join(chaine, sequence):
# TODO Docstring # TODO Docstring
res = '' res = ''
l = len(sequence) l = len(sequence)
for i in range(l): for i in range(l):
res += sequence[i] res += sequence[i]
if i < l-1: if i < l - 1:
res += chaine res += chaine
return res return res
@ -143,38 +148,42 @@ question(1)
# TODO utf-8 # TODO utf-8
# TODO en print # TODO en print
##>>> l = list ('timoleon') # >>> l = list ('timoleon')
##>>> l.sort() # >>> l.sort()
##>>> l # >>> l
##['e', 'i', 'l', 'm', 'n', 'o', 'o', 't'] ##['e', 'i', 'l', 'm', 'n', 'o', 'o', 't']
print('La méthode sort semble trier les lettres par ordre alphabétique') print('La méthode sort semble trier les lettres par ordre alphabétique')
##>>> s = "Je n'ai jamais joué de flûte." # >>> s = "Je n'ai jamais joué de flûte."
##>>> l = list (s) # >>> l = list (s)
##>>> l.sort() # >>> l.sort()
##>>> l # >>> l
##[' ', ' ', ' ', ' ', ' ', "'", '.', 'J', 'a', 'a', 'a', 'd', 'e', 'e', 'e', 'f', 'i', 'i', 'j', 'j', 'l', 'm', 'n', 'o', 's', 't', 'u', '\xa9', '\xbb', '\xc3', '\xc3'] ##[' ', ' ', ' ', ' ', ' ', "'", '.', 'J', 'a', 'a', 'a', 'd', 'e', 'e', 'e', 'f', 'i', 'i', 'j', 'j', 'l', 'm', 'n', 'o', 's', 't', 'u', '\xa9', '\xbb', '\xc3', '\xc3']
print('La méthode sort trie aussi les caractères spéciaux : ponctuation au début, accents à la fin') print(
'La méthode sort trie aussi les caractères spéciaux : ponctuation au début, accents à la fin')
print('Il semblerait que la fonction sort trie les caractères de s selon l\'ordre croissant de leur numéro de code ASCII (ou tout encodage utilisé)') print(
'Il semblerait que la fonction sort trie les caractères de s selon l\'ordre croissant de leur numéro de code ASCII (ou tout encodage utilisé)')
question(2) question(2)
# TODO en print # TODO en print
##>>> l = ['a', 1] # >>> l = ['a', 1]
##>>> l.sort() # >>> l.sort()
##>>> l # >>> l
##[1, 'a'] ##[1, 'a']
print('On remarque que 1 se place avant \'a\'. Si nous étions correct dans la question précédente, les éléments de liste sont triés selon leur valeur, ou leur numéro de code pour les caractères. \'a\' ayant pour numéro de code 97 (`ord(\'a\') == 97`), et 1 < 97, il est normal qu\'il se retrouve après le 1.') print(
'On remarque que 1 se place avant \'a\'. Si nous étions correct dans la question précédente, les éléments de liste sont triés selon leur valeur, ou leur numéro de code pour les caractères. \'a\' ayant pour numéro de code 97 (`ord(\'a\') == 97`), et 1 < 97, il est normal qu\'il se retrouve après le 1.')
section('Une fonction sort pour les chaînes') section('Une fonction sort pour les chaînes')
question(1) question(1)
def sort(chaine): def sort(chaine):
# TODO Docstring # TODO Docstring
# TODO On peut pas faire plus court ? # TODO On peut pas faire plus court ?
@ -190,15 +199,17 @@ partie('Anagrammes') # Jean-loup
question(1) question(1)
def sont_anagrammes1(chaine1, chaine2): def sont_anagrammes1(chaine1, chaine2):
""" Prédicat, renvoie True si chaine1 et chaine2 sont des anagrammes, False sinon """ Prédicat, renvoie True si chaine1 et chaine2 sont des anagrammes, False sinon
str, str -> bool str, str -> bool
CU: chaine1 et chaine2 sont des str CU: chaine1 et chaine2 sont des str
""" """
assert(type(chaine1)==str and type(chaine2)==str) assert(type(chaine1) == str and type(chaine2) == str)
if len(chaine1) != len(chaine2): # Si la longueur est différente ca ne peut pas être des anagrammes # Si la longueur est différente ca ne peut pas être des anagrammes
if len(chaine1) != len(chaine2):
return False return False
l1 = list(chaine1) l1 = list(chaine1)
@ -211,33 +222,37 @@ def sont_anagrammes1(chaine1, chaine2):
question(2) question(2)
def sont_anagrammes2(chaine1, chaine2): def sont_anagrammes2(chaine1, chaine2):
""" Prédicat, renvoie True si chaine1 et chaine2 sont des anagrammes, False sinon """ Prédicat, renvoie True si chaine1 et chaine2 sont des anagrammes, False sinon
str, str -> bool str, str -> bool
CU: chaine1 et chaine2 sont des str CU: chaine1 et chaine2 sont des str
""" """
assert(type(chaine1)==str and type(chaine2)==str) assert(type(chaine1) == str and type(chaine2) == str)
if len(chaine1) != len(chaine2): # Si la longueur est différente ca ne peut pas être des anagrammes # Si la longueur est différente ca ne peut pas être des anagrammes
if len(chaine1) != len(chaine2):
return False return False
occu1 = dict((i,chaine1.count(i)) for i in chaine1) occu1 = dict((i, chaine1.count(i)) for i in chaine1)
occu2 = dict((i,chaine2.count(i)) for i in chaine2) occu2 = dict((i, chaine2.count(i)) for i in chaine2)
return occu1 == occu2 return occu1 == occu2
question(3) question(3)
def sont_anagrammes3(chaine1, chaine2): def sont_anagrammes3(chaine1, chaine2):
""" Prédicat, renvoie True si chaine1 et chaine2 sont des anagrammes, False sinon """ Prédicat, renvoie True si chaine1 et chaine2 sont des anagrammes, False sinon
str, str -> bool str, str -> bool
CU: chaine1 et chaine2 sont des str CU: chaine1 et chaine2 sont des str
""" """
assert(type(chaine1)==str and type(chaine2)==str) assert(type(chaine1) == str and type(chaine2) == str)
if len(chaine1) != len(chaine2): # Si la longueur est différente ca ne peut pas être des anagrammes # Si la longueur est différente ca ne peut pas être des anagrammes
if len(chaine1) != len(chaine2):
return False return False
for i in chaine1: for i in chaine1:
@ -251,18 +266,20 @@ section('Casse et accentuation')
question(1) question(1)
EQUIV_NON_ACCENTUE = {'é':'e', 'è':'e', 'à':'a', 'ç':'c', 'ï':'i', 'î':'i', 'ô':'o', 'ë':'e', 'ê':'e', 'â':'a', 'û':'u'} EQUIV_NON_ACCENTUE = {'é': 'e', 'è': 'e', 'à': 'a', 'ç': 'c', 'ï':
'i', 'î': 'i', 'ô': 'o', 'ë': 'e', 'ê': 'e', 'â': 'a', 'û': 'u'}
question(2) question(2)
def bas_casse_sans_accent(chaine): def bas_casse_sans_accent(chaine):
""" str -> str, renvoie une chaine qui est l'équivalent non accentuée et minuscule de la chaine passée en paramètre """ str -> str, renvoie une chaine qui est l'équivalent non accentuée et minuscule de la chaine passée en paramètre
CU: chaine est un str CU: chaine est un str
""" """
assert(type(chaine)==str) assert(type(chaine) == str)
chaineCpy=chaine.lower() chaineCpy = chaine.lower()
ret = "" ret = ""
@ -276,15 +293,17 @@ def bas_casse_sans_accent(chaine):
question(3) question(3)
def sont_anagrammes_sans_casse_ni_accent(chaine1, chaine2): def sont_anagrammes_sans_casse_ni_accent(chaine1, chaine2):
""" Prédicat, renvoie True si chaine1 et chaine2 sont des anagrammes, False sinon, ne tient pas compte de la casse ou des accents """ Prédicat, renvoie True si chaine1 et chaine2 sont des anagrammes, False sinon, ne tient pas compte de la casse ou des accents
str, str -> bool str, str -> bool
CU: chaine1 et chaine2 sont des str CU: chaine1 et chaine2 sont des str
""" """
assert(type(chaine1)==str and type(chaine2)==str) assert(type(chaine1) == str and type(chaine2) == str)
if len(chaine1) != len(chaine2): # Si la longueur est différente ca ne peut pas être des anagrammes # Si la longueur est différente ca ne peut pas être des anagrammes
if len(chaine1) != len(chaine2):
return False return False
chaine1Cpy = bas_casse_sans_accent(chaine1) chaine1Cpy = bas_casse_sans_accent(chaine1)
@ -293,7 +312,6 @@ def sont_anagrammes_sans_casse_ni_accent(chaine1, chaine2):
return sont_anagrammes2(chaine1Cpy, chaine2Cpy) return sont_anagrammes2(chaine1Cpy, chaine2Cpy)
partie('Recherche d\'anagrammes') # Jean-loup partie('Recherche d\'anagrammes') # Jean-loup
@ -321,12 +339,13 @@ section('Anagrammes d’un mot : première méthode')
question(1) question(1)
def anagrammes(mot): def anagrammes(mot):
""" str -> list de str, parcourt tout le lexique et recherche les anagrammes de mot """ str -> list de str, parcourt tout le lexique et recherche les anagrammes de mot
CU: mot est un str CU: mot est un str
""" """
assert(type(mot)==str) assert(type(mot) == str)
anag = [] anag = []
@ -338,20 +357,60 @@ def anagrammes(mot):
question(2) question(2)
print('Les anagrammes de Orange sont:', anagrammes('Orange'))
print('Les anagrammes de Calbuth sont:', anagrammes('Calbuth'))
section('Anagrammes d’un mot : seconde méthode') section('Anagrammes d’un mot : seconde méthode')
question(1) question(1)
# 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) question(2)
def cle(mot):
""" str -> str , renvoie la version triée des lettres de mot, sans accent et en bas de casse.
CU: mot est un str
"""
assert(type(mot) == str)
cpy = list(bas_casse_sans_accent(mot)).sort()
return str(cpy)
question(3) question(3)
ANAGRAMMES = {cle(i): anagrammes(i) for i in LEXIQUE}
print(len(ANAGRAMMES))
question(4) question(4)
def anagrammes2(mot):
""" str -> list de str, utilise le dictionnaire ANAGRAMMES pour trouver la liste des anagrammes de mot
CU: mot est un str
"""
k = cle(mot)
if k in ANAGRAMMES:
return ANAGRAMMES[k]
else:
return []
question(5) question(5)
print('Les anagrammes de Orange sont:', anagrammes2('Orange'))
print('Les anagrammes de Calbuth sont:', anagrammes2('Calbuth'))
section('Comparaison des deux méthodes') section('Comparaison des deux méthodes')
@ -381,3 +440,4 @@ def annagrammes_phrase(phrase):
return phraseAnagrammes # DEBUG return phraseAnagrammes # DEBUG
print(annagrammes_phrase('onomatopée dactylographie')) # DEBUG print(annagrammes_phrase('onomatopée dactylographie')) # DEBUG