Partage
  • Partager sur Facebook
  • Partager sur Twitter

programme de traduction

Sujet résolu
    12 novembre 2021 à 9:29:24

    Bonjour à tous,

    J'ai commencé le python y'a pas très longtemps en autonomie. Mon projet pour faire court et simple :développez un traducteur qui puisse traduire une langue que j'ai crée.

    Dans cette interface pour traduire il y'a plusieurs boutons :

    Voici les fonctions de ces boutons :

    Traduire --> sert à traduire le texte

    Quitter --> sert à fermer la fenêtre

    Dictionnaire complet --> afficher le dictionnaire complet dans un popup

    Ajouter --> ajouter un mot inconnu au dictionnaire

    Pour l'instant j'ai réussi les deux premiers boutons (quitter et traduire) mais pas les deux autres et je suis perdu !!!

    Est ce que quelqu'un peut m'aider svp ?

    merci beaucoup, voici mon code en dessous:

    import tkinter as tk
    
    dico_fr_pr = {"homme":"akvi","femme":"akva"}
    
    #La fonction associée au bouton.
    #Elle sera appelée à chaque fois que l'utilisateur appuie sur le bouton
    
    def afficher_traduction(dictionnaire, entry, label):
    
        def wrap():
    
            mot_traduit = dictionnaire.get(entry.get().lower(), "Mot inconnu ou mal orthographié.")
    
            affichage["text"] = mot_traduit
        return wrap
        
    #Fen
    fen = tk.Tk()
    fen.geometry("600x400")
    fen.title("Traducteur Piar")
    entree_utilisateur = tk.Entry(fen, width=30)
    textentry=tk.Label(fen, text="Ecrivez un mot en français :")
    affichage = tk.Label(fen,width=30, bg="white")
    
    #Fenpop
    fenpop = tk.Tk()
    fenpop.geometry("600x400")
    fenpop.title("Dictionnaire complet en Piar")
    affichage2 = tk.Label(fenpop, width=70, bg="white", text='')
    
    #Boutons
    btn_equivalence = tk.Button(fen, text="Traduction", fg="blue", width=20, command=afficher_traduction(dico_fr_pr, entree_utilisateur,affichage))
    btn_quitter = tk.Button(fen, text="Quitter", fg="red", width=20, command=fen.destroy)
    btn_ajouter = tk.Button(fen, text="Ajouter",width=20)
    btn_dico = tk.Button(fen, text="Dictionnaire complet", fg="green", width=20, command = fenpop)
    
    
    #Placement des widgets dans la fenêtre
    btn_equivalence.place(x="200", y="80")
    btn_ajouter.place(x="200", y="150")
    btn_quitter.place(x="200", y="290")
    btn_dico.place(x="200", y="220")
    entree_utilisateur.place(x="10", y="40")
    affichage.place(x="300", y="44")
    affichage2.place(x="50", y="50")
    textentry.place(x="12", y="15")
    
    
    fen.mainloop()

    c'est du python.

    -
    Edité par AbcAbc6 12 novembre 2021 à 9:37:15

    • Partager sur Facebook
    • Partager sur Twitter
      12 novembre 2021 à 9:39:50

      Bonjour, je viens de modifié votre titre en effet "Besoin d'aide" n'a rien à y faire, si vous postez on se doute que vous avez besoin d'aide l'indiquer dans le titre n'apporte rien comme information quand au contenu du sujet.

      Liens conseillés

      -
      Edité par AbcAbc6 12 novembre 2021 à 9:40:25

      • Partager sur Facebook
      • Partager sur Twitter
        12 novembre 2021 à 13:47:44

        Bonjour,

        fenpop s'ouvre au lancement du programme en même temps que le fenêtre principale

        A quoi sert le bouton btn_dico ?

        Si tu veux ouvrir une fenêtre secondaire avec un bouton, voir du coté de la fonction Toplevel()

        -
        Edité par Phil_1857 12 novembre 2021 à 13:48:48

        • Partager sur Facebook
        • Partager sur Twitter
          12 novembre 2021 à 13:56:19

          *Justement je n'arrive pas à faire apparaître fenpop lorsque le btn_dico est appuyé

          Je viens de commencer python, je ne comprends pas très bien ce que veut dire Toplevel(), pouvez-vous m'expliquer pour que je puisse comprendre svp :D

          Merciiii

          -
          Edité par LucienDeRubènprey 12 novembre 2021 à 13:59:42

          • Partager sur Facebook
          • Partager sur Twitter
            12 novembre 2021 à 13:59:39

            Donc, comme je le disais, voir du coté de Toplevel() qui permet de créer une fenêtre secondaire ...

            • Partager sur Facebook
            • Partager sur Twitter
              12 novembre 2021 à 14:10:28

              Je ne comprends pas comment ça fonctionne... J'ai littéralement commencé python avec ce code.

              J'ai regardé des tutos, mais je ne comprends pas la disposition qui suit Toplevel() pour pouvoir créer un lien avec btn_dico (j'ai seulement pris connaissance avec les options et descriptions; background, cursor etc)

              Voici ce que j'en conclus alors :

              #Fenpop
              fenpop = Toplevel(bg ='white')
              fenpop = tk.Tk()
              fenpop.geometry("600x400")
              fenpop.title("Dictionnaire complet en Piar")
              affichage2 = tk.Label(fenpop, width=70, bg="white", text='')

              ça ne marche pas car on me dit que Toplevel is not definded

              -
              Edité par LucienDeRubènprey 12 novembre 2021 à 14:16:33

              • Partager sur Facebook
              • Partager sur Twitter
                12 novembre 2021 à 15:56:03

                Ben oui

                fenpop a pour parent fen, donc :

                fenpop = tk.Toplevel(fen)

                et derrière, ne pas refaire une autre fenêtre : supprimer la ligne 3 !

                et si on laisse ça dans le programme principal, elle va s'ouvrir de suite

                il vaudrait mieux mettre ça dans une fonction qui sera lancée par ton bouton ...

                def _pop():
                    fenpop = tk.Toplevel(fen)
                    fenpop.geometry("600x400")
                    fenpop.title("Dictionnaire complet en Piar")
                    affichage2 = tk.Label(fenpop, width=70, bg="white", text='')
                    affichage2.place(x="50", y="50")
                
                btn_dico = tk.Button(fen, text="Dictionnaire complet", fg="green", width=20, command = _pop)
                btn_dico.place(x="200", y="220")
                



                -
                Edité par Phil_1857 12 novembre 2021 à 16:11:13

                • Partager sur Facebook
                • Partager sur Twitter
                  13 novembre 2021 à 12:28:40

                  Merci beaucoup ça m'avance beaucoup, mais je suis toujours aussi coincé sur deux points :

                  1-Que le dictionnaire entier apparaisse dans la fenêtre popup (pour l'instant je n'arrive qu'à faire apparaître dico_fr_pr)

                  2- La fonction qui permet d'ajouter des mots inconnus du dictionnaire dans le dictionnaire avec leurs traductions

                  J'ai essayer de copier ce que vous avez faits pour le bouton ajout...sauf que je suis beaucoup moins doué que vous !!!

                  import tkinter as tk
                  
                  dico_fr_pr = {"homme":"akvi","femme":"akva"}
                  
                  #La fonction associée au bouton.
                  #Elle sera appelée à chaque fois que l'utilisateur appuie sur le bouton
                  
                  def afficher_traduction(dictionnaire, entry, label):
                  
                      def wrap():
                  
                          mot_traduit = dictionnaire.get(entry.get().lower(), "Mot inconnu ou mal orthographié.")
                  
                          affichage["text"] = mot_traduit
                      return wrap
                      
                  #Fen
                  fen = tk.Tk()
                  fen.geometry("600x400")
                  fen.title("Traducteur Piar")
                  entree_utilisateur = tk.Entry(fen, width=30)
                  textentry=tk.Label(fen, text="Ecrivez un mot en français :")
                  affichage = tk.Label(fen,width=30, bg="white")
                  
                  #Fenpop
                  def _pop():
                      fenpop = tk.Toplevel(fen)
                      fenpop.geometry("600x400")
                      fenpop.title("Dictionnaire complet en Piar")
                      affichage2 = tk.Label(fenpop, width=70, bg="white", text='dico_fr_pr')
                      affichage2.place(x="50", y="50")
                    
                  #Fenpop2
                  def _pop2():
                      fenpop2 = tk.Toplevel(fen)
                      fenpop2.geometry("600x400")
                      fenpop2.title("Ajouter des mots au dictionnaire")
                      entree_utilisateur2= tk.Entry(fenpop2, width=30)
                      textentry2= tk.Label(fenpop2, text="Ecrivez un mot en français")
                      affichage3 = tk.Label(fenpop2, width=30, bg='white')
                      
                  #Boutons Fen
                  btn_equivalence = tk.Button(fen, text="Traduction", fg="blue", width=20, command=afficher_traduction(dico_fr_pr, entree_utilisateur,affichage))
                  btn_quitter = tk.Button(fen, text="Quitter", fg="red", width=20, command=fen.destroy)
                  btn_ajouter = tk.Button(fen, text="Ajouter",width=20)
                  btn_dico = tk.Button(fen, text="Dictionnaire complet", fg="green", width=20, command = _pop)
                  btn_dico.place(x="200", y="220")
                  
                  #Boutons fenpop
                  btn_quitter = tk.Button(fenpop, text="Quitter", fg="red", width=20, command=fenpop.destroy)
                  
                  #Boutons fenpop2
                  btn_ajout2 = tk.Button(fenpop2, text="Ajouter au dictionnaire", fg="blue", width=20, command = _pop2)
                  btn_ajout2.place(x="200", y="150")
                  
                  
                  #Placement des widgets dans la fenêtre
                  btn_equivalence.place(x="200", y="80")
                  btn_ajouter.place(x="200", y="150")
                  btn_quitter.place(x="200", y="290")
                  btn_dico.place(x="200", y="220")
                  entree_utilisateur.place(x="10", y="40")
                  affichage.place(x="300", y="44")
                  
                  textentry.place(x="12", y="15")
                     
                  
                  fen.mainloop()
                  

                  Visiblement ça ne marche pas, puisqu'on me dit que "fenpop is not defined"...

                  Pouvez vous encore m'aider svp ?

                  Merci énormément du temps que vous m'accordez !

                  PS: Ci dessous vous trouverez mon code après que vous m'avez aidé, celui qui marche mais où il n'y a pas de fenêtre qui s'ouvre lorsqu'on appuie sur "Ajouter"...

                  import tkinter as tk
                  
                  dico_fr_pr = {"homme":"akvi","femme":"akva"}
                  
                  #La fonction associée au bouton.
                  #Elle sera appelée à chaque fois que l'utilisateur appuie sur le bouton
                  
                  def afficher_traduction(dictionnaire, entry, label):
                  
                      def wrap():
                  
                          mot_traduit = dictionnaire.get(entry.get().lower(), "Mot inconnu ou mal orthographié.")
                  
                          affichage["text"] = mot_traduit
                      return wrap
                      
                  #Fen
                  fen = tk.Tk()
                  fen.geometry("600x400")
                  fen.title("Traducteur Piar")
                  entree_utilisateur = tk.Entry(fen, width=30)
                  textentry=tk.Label(fen, text="Ecrivez un mot en français :")
                  affichage = tk.Label(fen,width=30, bg="white")
                  
                  #Fenpop
                  def _pop():
                      fenpop = tk.Toplevel(fen)
                      fenpop.geometry("600x400")
                      fenpop.title("Dictionnaire complet en Piar")
                      affichage2 = tk.Label(fenpop, width=70, bg="white", text='dico_fr_pr')
                      affichage2.place(x="50", y="50")
                  
                  #Boutons
                  btn_equivalence = tk.Button(fen, text="Traduction", fg="blue", width=20, command=afficher_traduction(dico_fr_pr, entree_utilisateur,affichage))
                  btn_quitter = tk.Button(fen, text="Quitter", fg="red", width=20, command=fen.destroy)
                  btn_ajouter = tk.Button(fen, text="Ajouter",width=20)
                  btn_dico = tk.Button(fen, text="Dictionnaire complet", fg="green", width=20, command = _pop)
                  btn_dico.place(x="200", y="220")
                  
                  
                  #Placement des widgets dans la fenêtre
                  btn_equivalence.place(x="200", y="80")
                  btn_ajouter.place(x="200", y="150")
                  btn_quitter.place(x="200", y="290")
                  btn_dico.place(x="200", y="220")
                  entree_utilisateur.place(x="10", y="40")
                  affichage.place(x="300", y="44")
                  affichage2.place(x="50", y="50")
                  textentry.place(x="12", y="15")
                  
                  
                  fen.mainloop()
                  




                  -
                  Edité par LucienDeRubènprey 13 novembre 2021 à 12:32:02

                  • Partager sur Facebook
                  • Partager sur Twitter
                    13 novembre 2021 à 13:54:52

                    Bonjour,

                    Je vois que tu défini les boutons des fenetres Toplevel() en dehors des fonctions: pas très logique

                    Et donc, à l'exécution, tant qu'on n'a pas cliqué sur un bouton qui créé une fenêtre secondaire, celle-ci n'est pas encore connue :

                    "fenpop is not defined"

                    Sinon, moi, je place toujours les widgets juste après leur définition:

                    affichage = tk.Label(fen,width=30, bg="white")
                    affichage.place(x="300", y="44")
                    

                    etc, etc ...

                    Le bouton de fen qui s'appelle ajouter ne lance pas la fonction _pop2

                    Si on corrige, fenpop2 apparait mais avec un bouton ajouter qui crée une autre fenêtre secondaire

                    (si on place bien btn_ajout2 dans _pop2)

                    dans _pop2, ces 3 widgets n'ont pas de placement:

                        entree_utilisateur2= tk.Entry(fenpop2, width=30)
                        
                        textentry2= tk.Label(fenpop2, text="Ecrivez un mot en français")
                        
                        affichage3 = tk.Label(fenpop2, width=30, bg='white')


                    donc, il n'apparaissent pas dans fenpop2

                     Il manque le texte de affichage3

                    Comme ça, ça va un peu mieux:

                    import tkinter as tk
                    
                    dico_fr_pr = {"homme":"akvi","femme":"akva"}
                     
                    def afficher_traduction(dictionnaire, entry, label):
                     
                        def wrap():
                            mot_traduit = dictionnaire.get(entry.get().lower(), "Mot inconnu ou mal orthographié.")
                            affichage["text"] = mot_traduit
                    
                        return wrap
                    
                    #Fenpop
                    def _pop():
                        fenpop = tk.Toplevel(fen)
                        fenpop.geometry("600x400")
                        fenpop.title("Dictionnaire complet en Piar")
                    
                        affichage2 = tk.Label(fenpop, width=70, bg="white", text=dico_fr_pr)
                        affichage2.place(x="50", y="50")
                    
                        btn_quitter = tk.Button(fenpop, text="Quitter", fg="red", width=20, command=fenpop.destroy)
                        btn_quitter.place(x="200", y="290")
                    
                    #Fenpop2
                    def _pop2():
                        fenpop2 = tk.Toplevel(fen)
                        fenpop2.geometry("600x400")
                        fenpop2.title("Ajouter des mots au dictionnaire")
                    
                        entree_utilisateur2= tk.Entry(fenpop2, width=30)
                        entree_utilisateur2.place(x="10", y="40")
                    
                        textentry2= tk.Label(fenpop2, text="Ecrivez un mot en français")
                        textentry2.place(x="12", y="15")
                    
                        affichage3 = tk.Label(fenpop2,text = 'coucou')
                        affichage3.place(x="12", y="100")
                    
                    #Fen
                    fen = tk.Tk()
                    fen.geometry("600x400")
                    fen.title("Traducteur Piar")
                    
                    entree_utilisateur = tk.Entry(fen, width=30)
                    entree_utilisateur.place(x="10", y="40")
                    entree_utilisateur.focus()
                    
                    textentry=tk.Label(fen, text="Ecrivez un mot en français :")
                    textentry.place(x="12", y="15")
                    
                    affichage = tk.Label(fen,width=30, bg="white")
                    affichage.place(x="300", y="44")
                    
                    #Boutons Fen
                    btn_equivalence = tk.Button(fen, text="Traduction", fg="blue", width=20, command=afficher_traduction(dico_fr_pr, entree_utilisateur,affichage))
                    btn_equivalence.place(x="200", y="80")
                    
                    btn_quitter = tk.Button(fen, text="Quitter", fg="red", width=20, command=fen.destroy)
                    btn_quitter.place(x="200", y="290")
                    
                    btn_ajouter = tk.Button(fen, text="Ajouter",width=20,command = _pop2)
                    btn_ajouter.place(x="200", y="150")
                    
                    btn_dico = tk.Button(fen, text="Dictionnaire complet", fg="green", width=20, command = _pop)
                    btn_dico.place(x="200", y="220")
                    
                    fen.mainloop()
                    




                    -
                    Edité par Phil_1857 13 novembre 2021 à 14:12:13

                    • Partager sur Facebook
                    • Partager sur Twitter
                      13 novembre 2021 à 15:43:05

                      Wow, c'est époustoflant ! Un rêve qui se réalise ! Merci beaucoup, il ne manque qu'une chose :  le fait d'ajouter un mot et sa traduction dans le dictionnaire...(j'ai rajouté les boutons quitter et ajouter dans la fenpop2 grâce à votre aide).

                      C'est du trop haut niveau pour moi la fonction de ajouter, c'est la dernière ligne droite, pouvez-vous m'aider ?

                      PS : J'ai voulu ranger en ordre alphabétique le dictionnaire sauf que je n'ai que le mot en français qui apparaît !

                      import tkinter as tk
                       
                      dico_fr_pr = {"homme":"akvi","femme":"akva"}
                        
                      def afficher_traduction(dictionnaire, entry, label):
                        
                          def wrap():
                              mot_traduit = dictionnaire.get(entry.get().lower(), "Mot inconnu ou mal orthographié.")
                              affichage["text"] = mot_traduit
                       
                          return wrap
                       
                      #Fenpop
                      def _pop():
                          fenpop = tk.Toplevel(fen)
                          fenpop.geometry("600x400")
                          fenpop.title("Dictionnaire complet en Piar")
                       
                          affichage2 = tk.Label(fenpop, width=70, bg="white", text=sorted(dico_fr_pr))
                          affichage2.place(x="50", y="50")
                       
                          btn_quitter = tk.Button(fenpop, text="Quitter", fg="red", width=20, command=fenpop.destroy)
                          btn_quitter.place(x="220", y="290")
                       
                      #Fenpop2
                      def _pop2():
                          fenpop2 = tk.Toplevel(fen)
                          fenpop2.geometry("205x300")
                          fenpop2.title("Ajouter des mots au dictionnaire")
                       
                          entree_utilisateur2= tk.Entry(fenpop2, width=30)
                          entree_utilisateur2.place(x="10", y="40")
                       
                          textentry2= tk.Label(fenpop2, text="Ecrivez un mot en français :")
                          textentry2.place(x="12", y="15")
                       
                          affichage3 = tk.Label(fenpop2,text = 'Sa traduction en Piar :')
                          affichage3.place(x="12", y="100")
                          entree_utilisateur3= tk.Entry(fenpop2, width = 30)
                          entree_utilisateur3.place(x="12", y="120")
                          btn_quitter = tk.Button(fenpop2, text="Quitter",fg="red", width=20, command=fenpop2.destroy)
                          btn_quitter.place(x="12", y="200")
                          btn_ajouter = tk.Button(fenpop2, text="Ajouter",fg="blue", width=20)
                          btn_ajouter.place(x="12", y="160")
                      
                      #Fen
                      fen = tk.Tk()
                      fen.geometry("600x400")
                      fen.title("Traducteur Piar")
                       
                      entree_utilisateur = tk.Entry(fen, width=30)
                      entree_utilisateur.place(x="10", y="40")
                      entree_utilisateur.focus()
                       
                      textentry=tk.Label(fen, text="Ecrivez un mot en français :")
                      textentry.place(x="12", y="15")
                       
                      affichage = tk.Label(fen,width=30, bg="white")
                      affichage.place(x="300", y="44")
                       
                      #Boutons Fen
                      btn_equivalence = tk.Button(fen, text="Traduction", fg="blue", width=20, command=afficher_traduction(dico_fr_pr, entree_utilisateur,affichage))
                      btn_equivalence.place(x="200", y="80")
                       
                      btn_quitter = tk.Button(fen, text="Quitter", fg="red", width=20, command=fen.destroy)
                      btn_quitter.place(x="200", y="290")
                       
                      btn_ajouter = tk.Button(fen, text="Ajouter",width=20,command = _pop2)
                      btn_ajouter.place(x="200", y="150")
                       
                      btn_dico = tk.Button(fen, text="Dictionnaire complet", fg="green", width=20, command = _pop)
                      btn_dico.place(x="200", y="220")
                       
                      fen.mainloop()

                      Voici la ligne de code que j'ai utilisé :

                      affichage2 = tk.Label(fenpop, width=70, bg="white", text=sorted(dico_fr_pr))




                      -
                      Edité par LucienDeRubènprey 13 novembre 2021 à 15:58:53

                      • Partager sur Facebook
                      • Partager sur Twitter
                        14 novembre 2021 à 10:44:47

                        Bonjour,

                        C'est époustouflant, c'est époustouflant ....

                        Ok, mais as-tu bien compris tous les détails, tes erreurs et la logique de tout ça ?

                        Saurais-tu refaire par toi-même ?

                        sorted(dico) renvoie uniquement une liste des clés triées, pour avoir tout le dictionnaire, il faut ajouter

                        quelquechose à sorted(), regarde ici : https://www.quennec.fr/book/export/html/672

                        Dans ta fonction _pop2(), btn_ajouter est inutile, il suffit des 2 Entry pour saisir les mots français et piar, et lier

                        l'Entry du texte piar à la touche Entrée du clavier (voit bind sur le Net), et dès qu'on tape Entrée après avoir 

                        saisi les 2 mots, on appelle une fonction qui ajoute la clé (français) et la valeur(piar) à dico_fr_pr

                        -
                        Edité par Phil_1857 14 novembre 2021 à 10:59:39

                        • Partager sur Facebook
                        • Partager sur Twitter
                          14 novembre 2021 à 11:09:35

                          Bonjour,

                          Vous avez raison je me perds dans mon enthousiasme. Il me semble avoir compris mes erreurs grâce à vos indications.

                          Votre lien m'a permis de ranger en ordre alphabétique le dictionnaire :

                          import tkinter as tk
                           
                          dico_fr_pr = {"homme":"akvi","femme":"akva"}
                            
                          def afficher_traduction(dictionnaire, entry, label):
                            
                              def wrap():
                                  mot_traduit = dictionnaire.get(entry.get().lower(), "Mot inconnu ou mal orthographié.")
                                  affichage["text"] = mot_traduit
                           
                              return wrap
                           
                          #Fenpop
                          def _pop():
                              fenpop = tk.Toplevel(fen)
                              fenpop.geometry("600x400")
                              fenpop.title("Dictionnaire complet en Piar")
                              
                              from collections import OrderedDict
                              dico_fr_pr2 = OrderedDict(sorted(dico_fr_pr.items(), key=lambda t: t[0]))
                              print(dico_fr_pr2)
                              OrderedDict([('homme', 'akvi'), ('femme', 'akva')])
                           
                              affichage2 = tk.Label(fenpop, width=70, bg="white", text=dico_fr_pr2)
                              affichage2.place(x="50", y="50")
                           
                              btn_quitter = tk.Button(fenpop, text="Quitter", fg="red", width=20, command=fenpop.destroy)
                              btn_quitter.place(x="220", y="290")
                           
                          #Fenpop2
                          def _pop2():
                              fenpop2 = tk.Toplevel(fen)
                              fenpop2.geometry("205x300")
                              fenpop2.title("Ajouter des mots au dictionnaire")
                           
                              entree_utilisateur2= tk.Entry(fenpop2, width=30)
                              entree_utilisateur2.place(x="10", y="40")
                           
                              textentry2= tk.Label(fenpop2, text="Ecrivez un mot en français :")
                              textentry2.place(x="12", y="15")
                           
                              affichage3 = tk.Label(fenpop2,text = 'Sa traduction en Piar :')
                              affichage3.place(x="12", y="100")
                              entree_utilisateur3= tk.Entry(fenpop2, width = 30)
                              entree_utilisateur3.place(x="12", y="120")
                              btn_quitter = tk.Button(fenpop2, text="Quitter",fg="red", width=20, command=fenpop2.destroy)
                              btn_quitter.place(x="12", y="200")
                              btn_ajouter = tk.Button(fenpop2, text="Ajouter",fg="blue", width=20)
                              btn_ajouter.place(x="12", y="160")
                          
                          #Fen
                          fen = tk.Tk()
                          fen.geometry("600x400")
                          fen.title("Traducteur Français/Piar")
                           
                          entree_utilisateur = tk.Entry(fen, width=30)
                          entree_utilisateur.place(x="10", y="40")
                          entree_utilisateur.focus()
                           
                          textentry=tk.Label(fen, text="Ecrivez un mot en français :")
                          textentry.place(x="12", y="15")
                           
                          affichage = tk.Label(fen,width=30, bg="white")
                          affichage.place(x="300", y="44")
                           
                          #Boutons Fen
                          btn_equivalence = tk.Button(fen, text="Traduction", fg="blue", width=20, command=afficher_traduction(dico_fr_pr, entree_utilisateur,affichage))
                          btn_equivalence.place(x="200", y="80")
                           
                          btn_quitter = tk.Button(fen, text="Quitter", fg="red", width=20, command=fen.destroy)
                          btn_quitter.place(x="200", y="290")
                           
                          btn_ajouter = tk.Button(fen, text="Ajouter",width=20,command = _pop2)
                          btn_ajouter.place(x="200", y="150")
                           
                          btn_dico = tk.Button(fen, text="Dictionnaire complet", fg="green", width=20, command = _pop)
                          btn_dico.place(x="200", y="220")
                           
                          fen.mainloop()

                          Cependant, il me reste une chose à trouver :

                          1- Que le bouton "Ajouter" puisse ajouter un mot inconnu et sa traduction dans le dictionnaire.

                          Merci bien

                          • Partager sur Facebook
                          • Partager sur Twitter
                            14 novembre 2021 à 11:52:02

                            Salut,

                            En récupérant les champs avec la méthode get() et pourquoi pas les passer en paramètre à une fonction qui les ajoutera au dictionnaire :

                            import tkinter as tk
                              
                            dico_fr_pr = {"homme":"akvi","femme":"akva"}
                            
                            
                            def add_to_dict(mot, traduction):
                                if mot or traduction:
                                    dico_fr_pr[mot] = traduction
                                    print(dico_fr_pr)
                                else:
                                    print("Problème..!")
                            
                            fen = tk.Tk()
                            fen.geometry("300x300")
                            fen.title("Ajouter des mots au dictionnaire")
                            mot = tk.Entry(fen, width=30)
                            mot.place(x="10", y="40")
                            textentry2= tk.Label(fen, text="Ecrivez un mot en français :")
                            textentry2.place(x="12", y="15")
                            affichage3 = tk.Label(fen,text = 'Sa traduction en Piar :')
                            affichage3.place(x="12", y="100")
                            traduction = tk.Entry(fen, width = 30)
                            traduction.place(x="12", y="120")
                            btn_quitter = tk.Button(fen, text="Quitter",fg="red", width=20, command=fen.destroy)
                            btn_quitter.place(x="12", y="200")
                            btn_ajouter = tk.Button(fen, text="Ajouter",fg="blue", width=20, command=lambda: add_to_dict(mot.get(), traduction.get()))
                            btn_ajouter.place(x="12", y="160")
                            fen.mainloop()



                            -
                            Edité par Diablo76 14 novembre 2021 à 14:59:59

                            • Partager sur Facebook
                            • Partager sur Twitter
                              14 novembre 2021 à 11:53:03

                              2 remarques:

                              _ en principe, on met les imports en début de code, donc tu peux remonter from collections ... en dessous de import tkinter

                              _ les positions des widgets sont des valeurs numériques donc pas besoin d'écrire x="12", y="20"   x=12, y=20 suffisent

                              _ tu peux enlever btn_ajouter dans pop2()

                              tu peux réduire la taille de tes fenêtres secondaires, ça fait plus joli:

                              Comme je te disais, 2 labels et 2 entry suffisent comme tu le vois sur mon image, après la définition de l'entry qui reçoit le mot en Piar,

                              il faut lier celle-ci (bind) à la touche Entrée du clavier en passant un nom de fonction en argument (voir exemples sur le Net)

                              Ensuite, définir cette fonction qui récupère les 2 valeurs des 2 entry (ça, tu sais le faire) et les ajouter au dictionnaire:

                              dictionnaire[mot_francais] = mot_piar

                              Méfie-toi, dans la réponse de Diablo, tout est en programme principal et pas dans le fonction pop2()   ;;; :-)

                              -
                              Edité par Phil_1857 14 novembre 2021 à 11:55:54

                              • Partager sur Facebook
                              • Partager sur Twitter
                                14 novembre 2021 à 12:21:46

                                Phil_1857 a écrit:

                                Méfie-toi, dans la réponse de Diablo, tout est en programme principal et pas dans le fonction pop2()   ;;; :-)

                                -
                                Edité par Phil_1857 il y a 23 minutes


                                Oui en effet mais c'est plus un exemple ou une idée de comment faire... ;)
                                • Partager sur Facebook
                                • Partager sur Twitter
                                  14 novembre 2021 à 14:37:31

                                  Bonjour,

                                  merci pour tes remarques, pour ce qui est de l'esthétique je le ferais en dernier.

                                  Je suis allé sur le net pour pouvoir faire en lien entre la définition de l'entry qui reçoit le mot en Piar et la touche Entrée du clavier.

                                  def callback(event):
                                      dico_fr_pr[textentry2] = affichage3
                                      fenpop2.bind('<Return>', callback)

                                  J'ai fais ça, mais je doute pas que ce soit faux car ça ne marche pas...

                                  Je sais sûrement le faire mais là je le nez dans le brouillard, car les infos que j'ai trouvé sur le web ne me semblait pas très clair :honte:...

                                  Encore une fois merci du temps et de la patience que vous m'accordez, je sais que ce ne dois pas être très facile pour vous !



                                  -
                                  Edité par LucienDeRubènprey 14 novembre 2021 à 14:38:47

                                  • Partager sur Facebook
                                  • Partager sur Twitter
                                    14 novembre 2021 à 15:06:06

                                    Tu ne t'inspires pas de mon exemple ci-dessus en utilisant get()

                                    ligne 48 :

                                    btn_ajouter = tk.Button(fen, text="Ajouter",fg="blue", width=20, command=lambda: add_to_dict(entree_utilisateur2.get(), entree_utilisateur3.get()))
                                    




                                    ensuite crée la fonction add_to dict() :

                                    def add_to_dict(mot, traduction):
                                        if mot or traduction:
                                            dico_fr_pr[mot] = traduction
                                            print(dico_fr_pr)
                                        else:
                                            print("Problème..!")



                                    -
                                    Edité par Diablo76 14 novembre 2021 à 15:08:18

                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                      14 novembre 2021 à 18:13:46

                                      ça ne marche pas... dès que j'introduis le bouton à la ligne 48, la ligne en dessous ne fonctionne plus (invalid syntax)...

                                      • Partager sur Facebook
                                      • Partager sur Twitter
                                        14 novembre 2021 à 20:56:05

                                        non mais , tu es sérieux ???

                                        -
                                        Edité par Diablo76 14 novembre 2021 à 20:56:37

                                        • Partager sur Facebook
                                        • Partager sur Twitter
                                          14 novembre 2021 à 22:30:10

                                          Hum...oui...désolé mais je suis vraiment un débutant en python...:honte:
                                          • Partager sur Facebook
                                          • Partager sur Twitter
                                            15 novembre 2021 à 7:13:04

                                            Alors reposte ton code modifié même s'il ne fonctionne pas.
                                            • Partager sur Facebook
                                            • Partager sur Twitter
                                              15 novembre 2021 à 8:06:58

                                              ça marche finalement, j'avais fais une faute d'égarement.

                                              Le seul problème c'est que les traductions rajoutées ne se conserve pas lorsqu'on ferme le programme et quand on ré-ouvre le programme...

                                              import tkinter as tk
                                              from collections import OrderedDict
                                              
                                              dico_fr_pr = {"homme":"akvi","femme":"akva"}
                                              
                                              def afficher_traduction(dictionnaire, entry, label):
                                              
                                                  def wrap():
                                                      mot_traduit = dictionnaire.get(entry.get().lower(), "Mot inconnu ou mal orthographié.")
                                                      affichage["text"] = mot_traduit
                                              
                                                  return wrap
                                              
                                              #Fenpop
                                              def _pop():
                                                  fenpop = tk.Toplevel(fen)
                                                  fenpop.geometry("600x400")
                                                  fenpop.title("Dictionnaire complet en Piar")
                                              
                                                  dico_fr_pr2 = OrderedDict(sorted(dico_fr_pr.items(), key=lambda t: t[0]))
                                                  print(dico_fr_pr2)
                                                  OrderedDict([('homme', 'akvi'), ('femme', 'akva')])
                                              
                                                  affichage2 = tk.Label(fenpop, width=70, bg="white", text=dico_fr_pr2)
                                                  affichage2.place(x="50", y="50")
                                              
                                                  btn_quitter = tk.Button(fenpop, text="Quitter", fg="red", width=20, command=fenpop.destroy)
                                                  btn_quitter.place(x="220", y="290")
                                                  
                                              def add_to_dict(mot, traduction):
                                                  if mot or traduction:
                                                      dico_fr_pr[mot] = traduction
                                                      print(dico_fr_pr)
                                                  else:
                                                      print("Problème..!")
                                              
                                              #Fenpop2
                                              def _pop2():
                                                  fenpop2 = tk.Toplevel(fen)
                                                  fenpop2.geometry("205x300")
                                                  fenpop2.title("Ajouter des mots au dictionnaire")
                                                  entree_utilisateur2= tk.Entry(fenpop2, width=30)
                                                  entree_utilisateur2.place(x="10", y="40")
                                              
                                                  textentry2= tk.Label(fenpop2, text="Ecrivez un mot en français :")
                                                  textentry2.place(x=12, y=15)
                                              
                                                  btn_ajouter = tk.Button(fenpop2, text="Ajouter",fg="blue", width=20, command=lambda: add_to_dict(entree_utilisateur2.get(), entree_utilisateur3.get()))
                                                  btn_ajouter.place(x="12", y="160")
                                              
                                                  affichage3 = tk.Label(fenpop2,text = 'Sa traduction en Piar :')
                                                  affichage3.place(x="12", y="100")
                                                  entree_utilisateur3= tk.Entry(fenpop2, width = 30)
                                                  entree_utilisateur3.place(x="12", y="120")
                                                  btn_quitter = tk.Button(fenpop2, text="Quitter",fg="red", width=20, command=fenpop2.destroy)
                                                  btn_quitter.place(x="12", y="200")
                                              
                                              
                                              #Fen
                                              fen = tk.Tk()
                                              fen.geometry("600x400")
                                              fen.title("Traducteur Français/Piar")
                                              
                                              entree_utilisateur = tk.Entry(fen, width=30)
                                              entree_utilisateur.place(x="10", y="40")
                                              entree_utilisateur.focus()
                                              
                                              textentry=tk.Label(fen, text="Ecrivez un mot en français :")
                                              textentry.place(x="12", y="15")
                                              
                                              affichage = tk.Label(fen,width=30, bg="white")
                                              affichage.place(x="300", y="44")
                                              
                                              #Boutons Fen
                                              btn_equivalence = tk.Button(fen, text="Traduction", fg="blue", width=20, command=afficher_traduction(dico_fr_pr, entree_utilisateur,affichage))
                                              btn_equivalence.place(x="200", y="80")
                                              
                                              btn_quitter = tk.Button(fen, text="Quitter", fg="red", width=20, command=fen.destroy)
                                              btn_quitter.place(x="200", y="290")
                                              
                                              btn_ajouter = tk.Button(fen, text="Ajouter",width=20,command = _pop2)
                                              btn_ajouter.place(x="200", y="150")
                                              
                                              btn_dico = tk.Button(fen, text="Dictionnaire complet", fg="green", width=20, command = _pop)
                                              btn_dico.place(x="200", y="220")
                                              
                                              fen.mainloop()
                                              



                                              • Partager sur Facebook
                                              • Partager sur Twitter
                                                15 novembre 2021 à 8:14:24

                                                Oui bien évidemment,  il faut les sauvegarder dans un fichier et aussi les charger en début de programme,  regarde du côté de JSON
                                                • Partager sur Facebook
                                                • Partager sur Twitter
                                                  15 novembre 2021 à 8:41:37

                                                  Pouvez-vous me montrer comment faire svp ?

                                                  Merci

                                                  • Partager sur Facebook
                                                  • Partager sur Twitter
                                                    15 novembre 2021 à 11:06:01

                                                    Bonjour,

                                                    Google est ton ami    :-)

                                                    • Partager sur Facebook
                                                    • Partager sur Twitter
                                                      15 novembre 2021 à 18:12:24

                                                      Oui merci,

                                                      Je n'arrive juste pas à comprendre comment télécharger Py to exe même si j'ai le site :

                                                      https://pypi.org/project/auto-py-to-exe/

                                                      ?

                                                      à chauqe fois que j'arrive au moment de demander dans quel fichier naviguer on me répond ça :


                                                      C:\Users\Red Computer>cd desktop/Traducteur
                                                      Le chemin d’accès spécifié est introuvable.


                                                      Le chemin d'accès spécifié est introuvable. Je ne comprends pas malgré mes recherches sur google

                                                      -
                                                      Edité par LucienDeRubènprey 15 novembre 2021 à 19:18:05

                                                      • Partager sur Facebook
                                                      • Partager sur Twitter
                                                        16 novembre 2021 à 9:41:05

                                                        Bonjour,

                                                        Pour JSON, tu as besoin de py to exe ?

                                                        Voici comment enregistrer un dictionnaire et le relire ensuite:

                                                        import json
                                                        
                                                        j_file = 'json_test.json'
                                                        employe = {"nom": "toto", "no": 1, "ok": True, "departement": "Gard"}
                                                        
                                                        print('\n*** Lecture fichier Json : {} ***\n'.format(j_file))
                                                        
                                                        with open(j_file, 'w') as f:
                                                            json.dump(employe, f)
                                                        
                                                        with open(j_file) as f:
                                                            data = json.load(f)
                                                            print(data)
                                                            for k, v in data.items(): print(k,':',v)
                                                        


                                                        Personnellement, j'ai inclus ça dans ton code et ça marche bien ...

                                                        -
                                                        Edité par Phil_1857 16 novembre 2021 à 9:46:27

                                                        • Partager sur Facebook
                                                        • Partager sur Twitter
                                                          17 novembre 2021 à 15:11:34

                                                          Bonjour Lucien,

                                                          Alors, as-tu de la réussite ?

                                                          Voici ma version:

                                                          -
                                                          Edité par Phil_1857 17 novembre 2021 à 17:05:32

                                                          • Partager sur Facebook
                                                          • Partager sur Twitter
                                                            18 novembre 2021 à 11:39:05

                                                            Désolé de ne pas vous 'avoir répondu plus tôt j'avais des soucis.

                                                            Je l'ai introduis, encore une fois ça l'ajoute au dictionnaire mais quand j'arrête le programme et que je le relance les mots ajoutés n'apparaissent plus...

                                                            Est -ce que vous pourrez m'envoyer votre code au complet pour comparer avec le mien svp?

                                                            De plus je ne vois pas ce que c'est censé faire json, car mon programme sans et avec fait la même chose 

                                                            Merci de votre aide et temps

                                                            Ps: j'essayais de transformer mon programme py en exe pour que se soit plus accessible

                                                            -
                                                            Edité par LucienDeRubènprey 18 novembre 2021 à 11:59:30

                                                            • Partager sur Facebook
                                                            • Partager sur Twitter
                                                              18 novembre 2021 à 11:48:57

                                                              Bonjour,

                                                              Ci-dessous mon code

                                                              Il faut d'abord créer un fichier texte nommé piar.json dans le même répertoire que le programme Python

                                                              Le remplir avec cette simple ligne:

                                                              {"homme": "akvi", "femme": "akva"}

                                                              Pour ajouter un mot dans la petite fenêtre secondaire, pas besoin de la souris:

                                                              le focus (le curseur de la souris) est déjà dans l'Entry pour le mot français

                                                              taper le mot français

                                                              appuyer sur la touche tabulation du clavier: le focus passe dans l'Entry pour le mot Piar

                                                              taper le mot Piar

                                                              appuyer sur la touche Entrée du clavier: le message "Mot ajouté !" apparait

                                                              Le focus est à nouveau dans la 1ere Entry si on veut ajouter un autre mot, sinon, fermer la fenêtre avec la croix en haut à droite

                                                              Pour commencer, ne modifie pas ton code, fais un copier/coller du mien dans un autre fichier et teste-le

                                                              import tkinter as tk	
                                                              import json
                                                              
                                                              j_file = 'piar.json'
                                                              
                                                              def lire_dico():
                                                                  ''' Lit le dictionnaire '''
                                                              
                                                                  with open(j_file) as f:
                                                                      return(json.load(f))
                                                              
                                                              def afficher_traduction(dictionnaire, francais):
                                                                  ''' Affiche la traduction en piar '''
                                                              
                                                                  def wrap():
                                                                      piar["text"] = dictionnaire.get(francais.get().lower(), "Mot inconnu ou mal orthographié")
                                                              
                                                                  return wrap
                                                              
                                                              def affiche_dic():
                                                                  ''' Crée une fenetre et affiche le dictionnaire complet'''
                                                              
                                                                  fenpop = tk.Toplevel(fen)
                                                                  fenpop.geometry("420x150+635+100")
                                                                  fenpop.title("Dictionnaire complet en Piar")
                                                              
                                                                  liste_dico = tk.Text(fenpop, width=48, height = 3)
                                                                  liste_dico.place(x=10, y=10)
                                                                  liste_dico.insert(0.0, sorted(dico_fr_pr.items(), key=lambda t: t[0]))
                                                              
                                                              def ajout_mot():
                                                                  ''' Ajoute un nouveau mot au dictionnaire '''
                                                              
                                                                  def maj_dico(event):
                                                                      ''' Met a jour le dictionnaire et l'enregistre '''
                                                              
                                                                      dico_fr_pr[E_francais.get()] = E_piar.get()
                                                              
                                                                      with open(j_file, 'w') as f:
                                                                          json.dump(dico_fr_pr, f)
                                                              
                                                                      L_msg['text'] = 'Mot ajouté !'
                                                                      E_francais.focus()
                                                              
                                                                  fenpop2 = tk.Toplevel(fen)
                                                                  fenpop2.geometry("350x100+635+100")
                                                                  fenpop2.title("Ajouter des mots au dictionnaire")
                                                              
                                                                  L_francais = tk.Label(fenpop2, text="Français : ")
                                                                  L_francais.place(x=12, y=15)
                                                              
                                                                  E_francais= tk.Entry(fenpop2, width=30)
                                                                  E_francais.place(x=100, y=15)
                                                                  E_francais.bind("<Tab>", lambda i : L_msg.config(text = ''))
                                                                  E_francais.focus()
                                                              
                                                                  L_piar = tk.Label(fenpop2, text="Piar : ")
                                                                  L_piar.place(x=12, y=40)
                                                              
                                                                  E_piar= tk.Entry(fenpop2, width=30)
                                                                  E_piar.place(x=100, y=40)
                                                                  E_piar.bind("<Return>", maj_dico)
                                                                  
                                                                  L_msg = tk.Label(fenpop2, text="")
                                                                  L_msg.place(x=12, y=65)
                                                              
                                                              dico_fr_pr = lire_dico()
                                                              
                                                              fen = tk.Tk()
                                                              fen.geometry("550x160+80+100")
                                                              fen.title("Traducteur Piar")
                                                              
                                                              prompt=tk.Label(fen, text="Ecrivez un mot en français :")
                                                              prompt.place(x=12, y=15)
                                                              
                                                              francais = tk.Entry(fen, width=30)
                                                              francais.place(x=10, y=40)
                                                              francais.focus()
                                                              
                                                              piar = tk.Label(fen,width=30, bg="white")
                                                              piar.place(x=300, y=40)
                                                              
                                                              b_trad = tk.Button(fen, text=">",width=4, command=afficher_traduction(dico_fr_pr, francais))
                                                              b_trad.place(x=228, y=37)
                                                              
                                                              b_ajouter = tk.Button(fen, text="Ajouter des mots au dictionnaire",command = ajout_mot)
                                                              b_ajouter.place(x=10, y=100)
                                                              
                                                              b_dico = tk.Button(fen, text="Afficher dictionnaire complet", fg="green", command = affiche_dic)
                                                              b_dico.place(x=350, y=100)
                                                              
                                                              fen.mainloop()
                                                              



                                                              -
                                                              Edité par Phil_1857 18 novembre 2021 à 11:52:53

                                                              • Partager sur Facebook
                                                              • Partager sur Twitter

                                                              programme de traduction

                                                              × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                                                              • Editeur
                                                              • Markdown