Exo infernal sous Python 3.4

[inviteef177ef5]

Salut à tous.

Je viens implorer votre aide !

Je suis en Master 2 de Langues rien à voir avec l'informatique, mais pourtant j'ai un cours de langage informatique duquel le prof nous demande de lui rendre un script Python pour créer un correcteur orthographique.
Cet exo sera ma seule note du semestre, coef. 4 (joie) et ça risque de me plomber mon master parce que JE N'Y COMPRENDS STRICTEMENT RIEN.

Alors oui, c'est mal ce que je m'apprête à demander, mais y aurait-il une âme charitable pour (m'aider à) faire mon devoir ? J'ai déjà quelques lignes de code (qui sont censées fonctionner) et une partie de l'exercice est déjà faite.
Voici la consigne :

a) Écrivez des fonctions Remplace1(mot), Supprime1(mot), Ajoute1(mot) et Echange1(mot) qui retournent l'ensemble des mots obtenus à partir du mot mot en effectuant une seule modification. (en théorie, j'ai pu faire une bonne partie du a/ mais je ne sais pas si ça fonctionne réellement).

b) Écrivez une fonction Edit1(mot,dico) qui retourne la liste de tous les mots du dictionnaire dico à distance d'édition 1 du mot mot.

c) Écrivez une fonction Edit2(mot,dico) qui retourne la liste de tous les mots du dictionnaire dico à distance d'édition 2 du mot mot.

d) Créer un dictionnaire contenant des mots et leur fréquence d'apparition dans la langue française (vous pouvez utiliser les textes libres du site http://www.gutenberg.org/).

e) À l'aide du module pickle, écrivez deux fonctions sauverDico(dico,f) et chargerDico(f) permettant de sauvegarder ou de charger un dictionnaire python.

f) Écrivez une fonction Corriger(mot, dico) qui énumère la liste de tous les mots du dictionnaire dico à distance d'édition 1 ou 2 du mot mot, propose à l'utilisateur de choisir l'orthographe correcte et renvoie le mot choisi. La fonction classera notamment les mots en fonction de la distance d'édition et de leur probabilité d'apparition dans la langue.

Voilà, s'il y a un super-héros parmi vous qui voudrait bien sauver la damoiselle en détresse que je suis, je lui serai éternellement reconnaissante et s'il se dévoue, je lui envoie tous les outils par mail puisque j'ai quelques fichiers .py et des lignes de code données par le prof, ça serait donc plus simple.

PS: Mon devoir est à rendre pour vendredi 1er mai...

Merci d'avance.

Maly.
-----

[Jack]

Bonjour,

je pense que la première chose à faire serait de montrer ce que tu as déjà fait, en accord avec la politique de ce forum:
http://forums.futura-sciences.com/pr...ces-forum.html

Je ne doute pas que dans ces conditions, ces fameuses âmes charitables te prennent en mains pour faire aboutir ton projet.

Tant qu'on y est, merci de suivre ces quelques règles également pour la suite (mieux vaut prévenir ...):
http://forums.futura-sciences.com/pr...ves-forum.html

[inviteef177ef5]

J'ai bien lu le topic "Exercices et forum" mais mes scripts me paraissaient tellement fouillis que je n'ai pas voulu encombrer le sujet.
En revanche je n'avais pas vu qu'on pouvait joindre des fichiers, désolée.

Donc, j'envoie en pièce jointe ce que j'ai déjà fait.

[JPL]

Ce serai plus commode si tu utilisais la balise Code (# dans l'éditeur en mode avancé) et que tu colles le script dedans. Tiens c'est mon jour de bonté :

# -*- coding: utf-8 -*-

#Consignes et fichiers à télécharger : http://meloni.univ-tln.fr/teaching/mla-info3.html

#EXERCICE 5.a)

mt = input(mot) 
def Remplace1():
    copie = ""
    i = 0
    while i < len():
        if i in lpos:
            copie = copie + lettre
        else:
            copie = copie + mot[i]
        i = i + 1
    return mot
#print (???)
    
def Supprime1():
    L=[]
    i = 0
    while i<len(mot):
       L.append(Remplace1(mot,"",[i] ))
       i = i + 1
    return L
    
def Ajoutelettre(mot,lettre,pos):
    copie = ""
    i = 0
    while i<len(mot):
        if i == pos:
            copie = copie + lettre
        copie = copie + mot[i]
        i = i + 1
    if pos == len(mot):
        copie = copie + lettre
    return copie

'''def Ajouter1():
    alpha = ["a","à","b","c","ç","d","e","é","è","f","g","h","i","î","ï","j","k","l","m","n","o","p","q","r","s","t","u","ù","v","w","x","y","z","ê","ô","ö"]
    for lettre in alpha:
        mot.append(Ajoute1(alpha
        i = i + 1(
    return mot ''' 

def Echangelettre(mot, pos1, pos2):
    copie = ""
    i = 0
    while i<len(mot):
        if i == pos1:
            copie = copie + mot[pos2]
        elif i == pos2:
            copie = copie + mot[pos1]
        else:
            copie = copie + mot [i]
        i = i +1
    return copie

'''def Echange1():
    copie = ""
    i = 0
    while i<len(mot):'''

#5.b)
#5.c)

#5.d) e)

def creerDico( dicoBrut ):
    """ Cree un dictionnaire dont les clés sont les mots et 
    les valeurs le type grammatical """
    dico = {}
    if os.access(dicoBrut, os.R_OK):
        fichier = open(dicoBrut,"r")
        contenu = fichier.readlines()
        fichier.close()
    else:
        print("Le fichier",nomfichier,"n'existe pas")
    
    for phrase in contenu: 
        if len(phrase.split()) >= 2:
            cle, val = coupler(phrase)
            if " " not in cle and cle[0].islower():
                if cle in dico:
                    dico[cle] += ","+val
                else:
                    dico[cle] = val
    return dico

#5.f)

[A voir en vidéo sur Futura]

[invite43901482]

On devrait commencer par le début, pourquoi ne testes tu pas ton code ?

Ensuite, rien que dans la fonction Remplace1(), il y a au moins 5 erreurs, l'interpréteur ne devine pas ce que l'utilisateur souhaite faire, il faut parler la langue python et cela avec tout simplement 0 erreur... Pour cela il y a des documentations, des exemples sur le net qui permettent amplement de répondre à tes besoins. L'interpréteur python quand à lui permettra de tester tes codes essais, c'est le principal avantage de ce langage.

En admettant que Remplace1 est une fonction permettant de remplacer une lettre dans un mot, la fonction devrait s'appeler Remplace1(mot, vieille_lettre, nouv_lettre)

et s'écrirait simplement comme cela

>>> def Remplace1(mot, vieille_lettre, nouv_lettre):
...     resultat = ''
...     for caractere in mot:
...         if caractere == vieille_lettre:
...             resultat += nouv_lettre
...         else:
...             resultat += caractere
...     return resultat
... 
>>> mot = Remplace1('coucou', 'u', 'n')
>>> mot
'concon'

Maintenant je peux me tromper, mais si on avait l'énoncé ça serait plus simple, car effectivement, je crois que tu n'as pas très bien compris le problème.

[inviteef177ef5]

Je pensais que c'était plus simple en pièce jointe, mais ok, c'est noté, j'utiliserai la balise code à l'avenir.
Merci. (:

[inviteef177ef5]

Merci pour ta réponse fred1599.

L'énoncé est là dessus, en bas de page : http://meloni.univ-tln.fr/teaching/mla-info3.html il n'y a rien d'autre niveau explication.

Pour ce qui est de tester le code, j'ai des syntax error partout, comme tu l'as noté, et puisque je suis une newbie complète en langage Python, j'y comprends rien (c'est comme essayer de parler français à un extraterrestre, et dans mon cas, je ne comprends juste pas la logique de ce langage. Hé, je suis une Lettre, soyez indulgents...).

Enfin, j'ai compris l'idée générale de ton exemple, mais si je simplifie comme ça, apparemment ça ne rentre pas dans le cadre de l'exercice, selon mon prof.

[invite43901482]

Et moi je suis pas en Lettre, et donc je ne comprend pas le terme distance. Bon il y a l'exemple, heureusement... le plus difficile est de trouver l'algorithme prenant en compte tout les cas de figures.

Dans ton exemple,

la distance entre fote et faute est de 2, celle entre fuate et faute est de 1.

Je ne comprend pas pourquoi fuate et faute n'a pas une distance de 2, comment savoir la valeur d'une distance en fonction de toutes les possibilités ? Y a-t-il une règle ?

[inviteef177ef5]

Aucune explication de la part de mon prof, il nous a demandé de trouver nous-mêmes en nous disant "on compte en partant de 0".

Donc après mes recherches, j'ai supposé qu'on parlait de la distance de Levenshtein (si jamais ça te parle ?)


" distance mathématique donnant une mesure de la similarité entre deux chaînes de caractères. Elle est égale au nombre minimal de caractères qu'il faut supprimer, insérer ou remplacer pour passer d’une chaîne à l’autre."

Et voilà l’algorithme pour deux chaînes de caractères courtes:

 entier DistanceDeLevenshtein(caractere chaine1[1..longueurChaine1],
                             caractere chaine2[1..longueurChaine2])
   // d est un tableau de longueurChaine1+1 rangées et longueurChaine2+1 colonnes
   declarer entier d[0..longueurChaine1, 0..longueurChaine2]
   // i et j itèrent sur chaine1 et chaine2
   declarer entier i, j, coût
 
   pour i de 0 à longueurChaine1
       d[i, 0] := i
   pour j de 0 à longueurChaine2
       d[0, j] := j
 
   pour i de 1 à longueurChaine1
       pour j de 1 à longueurChaine2
           si chaine1[i - 1] = chaine2[j - 1] alors coût := 0
                                sinon coût := 1
           d[i, j] := minimum(
                                d[i-1, j  ] + 1,     // effacement
                                d[i,   j-1] + 1,     // insertion
                                d[i-1, j-1] + coût   // substitution
                             )
 
   renvoyer d[longueurChaine1, longueurChaine2]

Mais je doute qu'on puisse l'inclure tel quel dans le code de mon exercice et je suis incapable de l'adapter ou de l'interpréter.

[invite2d7144a7]

Bonjour,

Et moi je suis pas en Lettre, et donc je ne comprend pas le terme distance. Bon il y a l'exemple, heureusement... le plus difficile est de trouver l'algorithme prenant en compte tout les cas de figures.

Dans ton exemple,



Je ne comprend pas pourquoi fuate et faute n'a pas une distance de 2, comment savoir la valeur d'une distance en fonction de toutes les possibilités ? Y a-t-il une règle ?

Ça semble être le résultat du calcul de la Distance de Levenshtein.

Je te laisse chercher.

[inviteef177ef5]

Alors c'est bien ce que j'avais compris, whoami.

Me reste plus qu'à comprendre comment ça fonctionne !

[invite43901482]

Non ça me parle pas, mais à ce que j'ai compris, le remplacement, c'est déduire le nombre de lettres remplacées par rapport au mot correct, ça donnerait cela en interprétant, mais la fonction n'est pas terminée, elle doit prendre en compte les mots n'ayant pas la même longueur que le mot d'origine.

>>> mot = 'coucou'
>>> def Remplace1(mot_test):
...     res = 0
...     if len(mot_test) == len(mot):
...         for index, caractere in enumerate(mot):
...             if caractere != mot_test[index]:
...                 res += 1
...     return res
... 
>>> n = Remplace1('concou')
>>> n
1

[inviteef177ef5]

Ok, merci fred1599, je vais me pencher là-dessus !