Bonjour, Bonsoir

Pour mon projet de fin d'année j'aimerais programmer une calculatrice qui à la base ne connaîtrait que la valeur des nombres et à laquelle il faudrait apprendre les opérations. Le projet est quasiment terminé mais j'aimerais rendre ma fonction traduction plus optimisé. Voici le code :

def traducteur(TextEntrant):

    #=====Variables=====#
    global TextSortant  #
    global Traduction   #
    global Trad         #
    global retour_ligne #
    global texte        #
    global mot          #
    retour_ligne = False#
    Trad = False        #
    Traduction = []     #
    #===================#

    # Fonction qui convertit la phrase présenté sous forme d'une liste et renvoie la traduction sous forme d'une liste à la fonction analyse
    def convertion (listedemot):
        global Traduction
        global Trad
        global retour_ligne
        Trad = False

        if listedemot == "plus":
            Traduction.append("+")
            Trad = True

        if listedemot == "longeur de" :
            Traduction.append("len(")
            Trad = True

        if listedemot == "moins":
            Traduction.append("-")
            Trad = True

        if listedemot == "retourner":
            Traduction.append("return")
            Trad = True

        if listedemot == "tant que":
            Traduction.append("while")
            Trad = True

        if listedemot == "fin tant que":
            Trad = True
            Traduction.append ("\n")
            retour_ligne = True

        if listedemot == "si":
            Traduction.append ("if")
            Trad = True

        if listedemot == "début afficher" :
            Trad = True
            Traduction.append ("print ('")

        if listedemot == "fin afficher":
            Trad = True
            Traduction.append("'")

        if listedemot == "début instruction" :
            Traduction.append("(")
            Trad = True

        if listedemot == "fin instruction" :
            Trad = True
            Traduction.append(")")

        if listedemot == "fin condition" :
            Trad = True
            Traduction.append(":\n    ")
            retour_ligne=True

        if listedemot == "a":
            Trad = True
            Traduction.append("a")

        if listedemot == "b" :
            Trad = True
            Traduction.append("b")

        if listedemot == "prend la valeur":
            Trad = True
            Traduction.append("=")

        if listedemot == "début demander":
            Trad = True
            Traduction.append("input('")

        if listedemot == "fin demander":
            Trad = True
            Traduction.append("')")

        if listedemot == "demander":
            Trad = True
            Traduction.append("input(")

        if listedemot == "retour ligne":
            Trad = True
            Traduction.append("\n")
            retour_ligne =True

        if listedemot == "vaut" :
            Trad = True
            retour_ligne = True
            Traduction.append("=")

        if listedemot == "différent de":
            Trad = True
            Traduction.append("!=")

        if listedemot == ",":
            Trad = True
            Traduction.append(",")

        if listedemot == "début crochet":
            Trad = True
            Traduction.append("[")

        if listedemot == "fin crochet":
            Trad = True
            Traduction.append("]")

        if listedemot == "définir":
            Trad = True
            Traduction.apped("def")

        if listedemot == "est égal à":
            Trad = True
            Traduction.append("==")

        if listedemot == "est un entier":
            Trad = True
            Traduction.append("int(")

        if listedemot == "inférieur à":
            Trad = True
            Traduction.append("<")

        if listedemot == "supérieur à":
            Trad = True
            Traduction.append(">")

        if listedemot == "inférieur ou égal à":
            Trad = True
            Traduction.append("<=")

        if listedemot == "supérieur ou égal à":
            Trad = True
            Traduction.append(">=")

        if listedemot == "ou":
            Trad = True
            Traduction.append("or")

        if listedemot == "sinon":
            Trad = True
            Traduction.append("else")

        if listedemot == "tab":
            Trad = True
            Traduction.append("    ")

        if listedemot == "sinonsi":
            Trad = True
            Traduction.append("elif")

        if listedemot == "pour i allant de":
            Trad = True
            Traduction.append("for i in range(")

        if listedemot == "chaine de caractère":
            Trad = True
            Traduction.append("str(")

        if listedemot == "convertir en binaire":
            Trad = True
            Traduction.append("bin(")
        if listedemot == "début caractère":
            Trad = True
            Traduction.append("str('")

        if listedemot == "fin caractère":
            Trad = True
            Traduction.append("'")

        if listedemot == "faux":
            Trad = True
            Traduction.append("False")

        if listedemot == "vrai":
            Trad = True
            Traduction.append("True")

        if listedemot == "à":
            Trad = True
            Traduction.append(",")

        if listedemot == "et":
            Trad = True
            Traduction.append("and")

        if listedemot == "afficher":
            Trad = True
            Traduction.append("print(")

        if listedemot == "entier":
            Trad = True
            Traduction.append("int")



    #Fonction qui retire les mots traduits
    def nettoyage ():
        global listedemot
        listedemot.remove(listedemot[0])

    #Fonction qui découpe la phrase et l'analyse mot par mot la phrase entrée dans la boite de texte et retourne une Traduction sous forme d'un str
    def analyse() :
        global Trad
        global listedemot
        global retour_ligne
        global mot
        listedemot= TextEntrant.split("/") #découpe le texte entré au niveau de tous les / pour les stocker dans une liste
        compteur=int(len(listedemot))
        i = 0
        while i< compteur:
                convertion(listedemot[i]) #Appelle de la fonction pour traduire
                if Trad == True :
                    nettoyage() #Retire l'élément de la liste si il est traduit
                    i=i
                    if listedemot == []: #arrete la boucle si la liste est vide
                        i = compteur
                else :
                    Traduction.append(listedemot[i]) #Permet d'apprendre le nom des variables
                    nettoyage()
                    i=i
                    if listedemot == []: #arrete la boucle si la liste est vide
                        i = compteur

        mot = "    "

        for i in range (0, len(Traduction)):
            mot += Traduction[i]
            if Traduction[i] == "\n" or Traduction[i] == ":\n    " or Traduction[i] == "    ":
                mot += "    "
            else:
                mot += " "

    analyse ()
    return mot

Voila ma fonction qui est donc fonctionnelle (oui c'est très mal dit je sais :p) mais comme vous pouvez le remarquer lors de mon analyse du texte je hache le texte avec des "/". Ce qui est extrêmement chiant et loin de l'idée de base. Mais après des heures et des heures passés à chercher sur le net à tester des algorithmes tordu et autres je n'ai rien trouvé de concluant. 

J'aimerais pouvoir entrer mon texte dans le style :

"demander a

si a supérieur à 15 .... "

Pour que la fonction me ressorte ce même texte mais traduit en python et en respectant la forme syntaxique (sinon c'est pas drôle ^^). 

Mais le temps mis pour traduire le code que l'on veut obtenir pour ensuite le rentrer dans cette fonction est énorme. J'ai donc créé une fonction qui me facilite la tache en traduisant le code source dans en l'espèce de langage algorithmique que l'on utilise.

Mais pour le jour de l'examen j'aimerais réellement pouvoir rentrer un texte sans / pour faire un peu plus pro

Des idées? Merci d'avance

P.S: il y a des traductions inutile dans la fonction qui servaient lors des tests. Il ne faut pas en tenir compte elles seront retirés d'ici là
 

-
Edité par Anonyme 20 mars 2015 à 20:53:42

Si listedemot est une liste comment cela se fait-il que tu compares ce type d'objet à une chaîne de caractère ?

Si listedemot n'est pas une liste, alors pourquoi l'appeler listedemot

En fait je ne sais pas du tout malgré tes explications à quoi sert la fonction conversion, en fait je ne sais pas pourquoi cette fonction.

Je ne comprend absolument rien de ce que tu fais, et du coup je me demande si le manque de réponse ne serait pas une conséquence de tout cela...

Cette fonction sert à lorsque l'on rentre un texte en langage pseudo-algorithme à le traduire et à le retourner sous la forme d'un str.

Pour cela je récupère la variable TextEntrant que je hache à tous les / que j'aurais mis et chaque terme est stocké dans une liste (listedemot). J'envoie cette liste à traduire en Python puis je reconvertis la liste traduite (Traduction) en str pour la renvoyer vers une autre fonction qui écrira la traduction à la suite du programme parent 

du coup mon TextEntrant ressemble à ça : 

"a/prend la valeur/5/si/a/supérieur à/ ..."

mais j'aimerais que ça ressemble à ça:

"a prend la valeur 5 si a supérieur à"

le problème c'est que dans cet exemple "prend la valeur" n'as son sens que si les trois mots sont mis ensemble et le problème c'est que si je hache pas la liste avec des / je n'arrive pas à traduire ce genre d'instruction

 En gros la fonction convertion sert de base de données

est ce que c'est plus clair? sinon n'hésite pas :p 

-
Edité par Anonyme 21 mars 2015 à 11:55:48

Mouais... bref la seule chose où je peux t'aider c'est de remplacer tes '/' en espace

>>> s = "a/prend la valeur/5/si/a/supérieur à/"
>>> s.replace('/', ' ')
'a prend la valeur 5 si a supérieur à '

Ce que tu sembles vouloir faire s'appelle la tokenisation (pas très franças ça, je l'admets) :). Ceci risque de demander l'utilisation d'expressions régulières que tu n'as probablement pas encore vu. Sinon tu peux peut-être t'en sortir avec la méthode startswith des strings.

s = 'prend la valeur 5 si a supérieur à'
s.startswith('prend la valeur') # True

Chacun de ces tokens connait sa traduction en ce que tu veux (Python, ...)

ça m'as l'air fort intéressant ce que tu me dis je vais essayer ça dès que je peux

donc si j'ai bien compris avec .startswith si il y a le terme recherché ça vaut True sinon False ?

du coup ma fonction conversion

pourrait donner ça :

listedemot = "Exemple"
if listedemot.startswith('Exemple'):
    Trad = True
    Traduction.append("Test")

Mais est ce que du coup ça me permet de gérer l'ordre d'une chaine de caractère?

Bon j'ai fais quelques test et ça marche pas bien voici le code :

listedemot = "a prend la valeur est un entier début demander a prend la valeur fin afficher fin instruction fin instruction retour ligne retour ligne a prend la valeur chaine de caractère convertir en binaire a fin instruction fin instruction retour ligne ab prend la valeur chaine de caractère fin instruction retour ligne for i in range ( longeur de a fin instruction moins 2 fin instruction fin condition ab prend la valeur ab plus a début crochet i plus 2 fin crochet retour ligne a prend la valeur ab"
Traduction = []
global Trad
global listedemot
Trad = False

def convertion ():
    global listedemot
    global Trad
    if listedemot.startswith('Exemple'):
        Traduction.append("Exemple")
        listedemot = " ".join(listedemot.split()[1:])

    if listedemot.startswith('à la con'):
        Traduction.append("à la con")
        listedemot = " ".join(listedemot.split()[3:])

    if listedemot.startswith('de phrase'):
        Traduction.append("de phrase")
        listedemot = " ".join(listedemot.split()[2:])

    if listedemot.startswith("plus"):
        Traduction.append("+")
        Trad = True
        listedemot = " ".join(listedemot.split()[1:])

    if listedemot.startswith("longeur de") :
        Traduction.append("len(")
        Trad = True
        listedemot = " ".join(listedemot.split()[2:])

    if listedemot.startswith("moins") :
        Traduction.append("-")
        Trad = True
        listedemot = " ".join(listedemot.split()[1:])

    if listedemot.startswith("retourner"):
        Traduction.append("return")
        Trad = True
        listedemot = " ".join(listedemot.split()[1:])

    if listedemot.startswith("tant que"):
        Traduction.append("while")
        Trad = True
        listedemot = " ".join(listedemot.split()[2:])

    if listedemot.startswith("fin tant que"):
        Trad = True
        Traduction.append ("\n")
        retour_ligne = True
        listedemot = " ".join(listedemot.split()[3:])

    if listedemot.startswith("si"):
        Traduction.append ("if")
        Trad = True
        listedemot = " ".join(listedemot.split()[1:])

    if listedemot.startswith("début afficher") :
        Trad = True
        Traduction.append ("print ('")
        listedemot = " ".join(listedemot.split()[2:])

    if listedemot.startswith("fin afficher"):
        Trad = True
        Traduction.append("'")
        listedemot = " ".join(listedemot.split()[2:])

    if listedemot.startswith("début instruction") :
        Traduction.append("(")
        Trad = True
        listedemot = " ".join(listedemot.split()[2:])

    if listedemot.startswith("fin instruction") :
        Trad = True
        Traduction.append(")")
        listedemot = " ".join(listedemot.split()[2:])

    if listedemot.startswith("fin condition") :
        Trad = True
        Traduction.append(":\n    ")
        retour_ligne=True
        listedemot = " ".join(listedemot.split()[2:])

    if listedemot.startswith("prend la valeur"):
        Trad = True
        Traduction.append("=")
        listedemot = " ".join(listedemot.split()[3:])

    if listedemot.startswith("début demander"):
        Trad = True
        Traduction.append("input('")
        listedemot = " ".join(listedemot.split()[2:])

    if listedemot.startswith("fin demander"):
        Trad = True
        Traduction.append("')")
        listedemot = " ".join(listedemot.split()[2:])

    if listedemot.startswith("demander"):
        Trad = True
        Traduction.append("input(")
        listedemot = " ".join(listedemot.split()[1:])

    if listedemot.startswith("retour ligne"):
        Trad = True
        Traduction.append("\n")
        listedemot = " ".join(listedemot.split()[2:])
        retour_ligne =True

    if listedemot.startswith("vaut") :
        Trad = True
        retour_ligne = True
        Traduction.append("=")
        listedemot = " ".join(listedemot.split()[1:])

    if listedemot.startswith("différent de"):
        Trad = True
        Traduction.append("!=")
        listedemot = " ".join(listedemot.split()[2:])

    if listedemot.startswith(","):
        Trad = True
        Traduction.append(",")
        listedemot = " ".join(listedemot.split()[2:])

    if listedemot.startswith("début crochet"):
        Trad = True
        Traduction.append("[")
        listedemot = " ".join(listedemot.split()[2:])

    if listedemot.startswith("fin crochet"):
        Trad = True
        Traduction.append("]")
        listedemot = " ".join(listedemot.split()[2:])

    if listedemot.startswith("définir"):
        Trad = True
        Traduction.apped("def")
        listedemot = " ".join(listedemot.split()[1:])

    if listedemot.startswith("est égal à"):
        Trad = True
        Traduction.append("==")
        listedemot = " ".join(listedemot.split()[3:])

    if listedemot.startswith("est un entier"):
        Trad = True
        Traduction.append("int(")
        listedemot = " ".join(listedemot.split()[3:])

    if listedemot.startswith("inférieur à"):
        Trad = True
        Traduction.append("<")
        listedemot = " ".join(listedemot.split()[2:])

    if listedemot.startswith("supérieur à"):
        Trad = True
        Traduction.append(">")
        listedemot = " ".join(listedemot.split()[2:])

    if listedemot.startswith("inférieur ou égal à"):
        Trad = True
        Traduction.append("<=")
        listedemot = " ".join(listedemot.split()[4:])

    if listedemot.startswith("supérieur ou égal à"):
        Trad = True
        Traduction.append(">=")
        listedemot = " ".join(listedemot.split()[4:])

    if listedemot.startswith("ou"):
        Trad = True
        Traduction.append("or")
        listedemot = " ".join(listedemot.split()[1:])

    if listedemot.startswith("sinon"):
        Trad = True
        Traduction.append("else")
        listedemot = " ".join(listedemot.split()[1:])

    if listedemot.startswith("tab"):
        Trad = True
        Traduction.append("    ")
        listedemot = " ".join(listedemot.split()[1:])

    if listedemot.startswith("sinonsi"):
        Trad = True
        Traduction.append("elif")
        listedemot = " ".join(listedemot.split()[1:])

    if listedemot.startswith("pour i allant de"):
        Trad = True
        Traduction.append("for i in range(")
        listedemot = " ".join(listedemot.split()[4:])

    if listedemot.startswith("chaine de caractère"):
        Trad = True
        Traduction.append("str(")
        listedemot = " ".join(listedemot.split()[3:])

    if listedemot.startswith("convertir en binaire"):
        Trad = True
        Traduction.append("bin(")
        listedemot = " ".join(listedemot.split()[3:])

    if listedemot.startswith("début caractère"):
        Trad = True
        Traduction.append("str('")
        listedemot = " ".join(listedemot.split()[2:])

    if listedemot.startswith("fin caractère"):
        Trad = True
        Traduction.append("'")
        listedemot = " ".join(listedemot.split()[2:])

    if listedemot.startswith("faux"):
        Trad = True
        Traduction.append("False")
        listedemot = " ".join(listedemot.split()[1:])

    if listedemot.startswith("vrai"):
        Trad = True
        Traduction.append("True")
        listedemot = " ".join(listedemot.split()[1:])

    if listedemot.startswith("à"):
        Trad = True
        Traduction.append(",")
        listedemot = " ".join(listedemot.split()[1:])

    if listedemot.startswith("et"):
        Trad = True
        Traduction.append("and")
        listedemot = " ".join(listedemot.split()[1:])

    if listedemot.startswith("afficher"):
        Trad = True
        Traduction.append("print(")
        listedemot = " ".join(listedemot.split()[1:])

    if listedemot.startswith("entier"):
        Trad = True
        Traduction.append("int")
        listedemot = " ".join(listedemot.split()[1:])

    if listedemot.startswith("a"):
        Trad = True
        Traduction.append("a")
        listedemot = " ".join(listedemot.split()[1:])

    if listedemot.startswith("b"):
        Trad = True
        Traduction.append("b")
        listedemot = " ".join(listedemot.split()[1:])

    if listedemot.startswith("ab"):
        Trad = True
        Traduction.append("ab")
        listedemot = " ".join(listedemot.split()[1:])


for words in listedemot :
    convertion()

#test=" ".join(map(str, Traduction))
mot = ""
for i in range (0, len(Traduction)):
    mot += Traduction[i]
    if Traduction[i] == "\n" or Traduction[i] == ":\n    " or Traduction[i] == "    ":
        mot += "    "
    else:
        mot += " "


print(listedemot)
print(mot)

et ça me retourne :

listedemot = for i in range ( longeur de a fin instruction moins 2 fin instruction fin condition ab prend la valeur ab plus a début crochet i plus 2 fin crochet retour ligne a prend la valeur ab

mot = a = int( input(' a = ' ) ) 

    a = str( bin( a ) ) 

    a = str( ) 

donc dans la variable listedemot qui est sensé être vide y a la fin de ce qu'il y a à traduire avec au début un morceau de traduction

et la variable mot est incomplète. Elle devrait ressembler à ça :

    a = int( input(' a = ' ) ) 

    a = str( bin( a ) ) 

    ab = str( ) 

    for i in range ( len( a ) - 2 ) :

        ab = ab + a [ i + 2 ] 

    a = ab  

ça fait plusieurs heures que j'essaye de débugger mais pour le coup je vois pas trop d'où ça vient 

Quelqu’un aurait une idée d'où ça pourrait venir?

Edit : La variable Trad a servit lors d'un des test mais là est inutile

-
Edité par Anonyme 21 mars 2015 à 15:25:50

Edit : Je suis un gros boulet ->retour ligne for i in range ( longeur de

-
Edité par Anonyme 23 mars 2015 à 19:31:14