Besoin d'aide pour programme en python

minnitch Messages postés 9 Date d'inscription   Statut Membre Dernière intervention   -  
 trifou -
Bonjour/Bonsoir à toutes et à tous,

Je suis actuellement en train de réaliser un programme en python, dans le cadre de mes études. Cependant, je rencontre quelques problèmes quant à la réalisation de ce dernier, c'est pourquoi je me permets de vous écrire sur ce forum. La consigne donnée est la suivante :



Je rencontre donc des problèmes pour la réalisation du second script. En effet, je ne parviens pas à coder la partie me permettant de vérifier que le mot proposé par le joueur est compatible avec le tirage effectué précédemment. De plus, je ne parviens pas à réaliser le code me permettant de trouver les mots les plus longs possibles avec mes lexiques.

Je vous mets ci-joint le code de mon script2, en espérant que quelqu'un puisse me venir en aide et m'aiguiller un peu.

Par avance, merci 

# coding: utf-8
from tkinter import *
from tkinter.messagebox import *
import random
from script1 import * ### pas sur que ça fonctionne 

with codecs.open("lexique_gen.txt", "r", "utf8") as f:
    text = f.readlines()
    lexique_gen = []
    for w in text:
        lexique_gen.append(w.strip())
        
with codecs.open("lexique_spe.txt", "r", "utf8") as f:
    text = f.readlines()
    lexique_spe = []
    for w in text:
        lexique_spe.append(w.strip())

n = ["n","r","s","t"]*6
l = ["l"]*5
dm = ["d","m"]*3
g = ["g","b","c","p","f","h","v"]*2
e = ["e"]*15
a = ["a"]*9
i = ["i","o","u"]*6
consonnes = n+l+dm+g+["j","q","k","w","x","z"]
voyelles = e+a+i+["y"]

tirage = []
root = Tk()

motsLexique = {}

vocab = {}

#définition de l'action du bouton Valider
def reponseL():
    reponse = rep.get()
    for v in tirage:
        vocab[v] = tirage.count(v)
    for t in reponse:
        if v in vocab :
            showinfo("Bravo!", "Ton mot est compatible avec le tirage")
            break
        
            if reponse in lexique_gen:
                showinfo("Bravo!", "Ton mot est dans le lexique!")

            else:
                showinfo("NON")
                Champ.delete(0, END)
                root.update()
        
        else:
            showinfo("Booo", "Ton mot n'est pas possible avec ce tirage")
            break
            #verifier = False



   # if reponse in lexique_gen:
    #    showinfo("Bravo!", "Ton mot est compatible avec le tirage!")

    #else:
     #   showinfo("NON")
      #  Champ.delete(0, END)
       # root.update()
        
#définition de l'action du bouton Consonne
def lettreC():
    if len(tirage) < 9:
        lettre = random.choice(consonnes)
        tirage.append(lettre)
        label1.config(text="Lettres choisies: "+" ".join(tirage))
    else:
        showinfo("Fin","Fin de tirage de lettres, propose un mot!")

#définition de l'action du bouton Voyelle
def lettreV():
    if len(tirage) < 9:
        lettre = random.choice(voyelles)
        tirage.append(lettre)
        label1.config(text="Lettres choisies: "+" ".join(tirage))
    else:
        showinfo("Fin","Fin de tirage de lettres, propose un mot!")

#définition du bouton "Consonne"
bouton1 = Button(root, text="Consonne", fg="red", width=8, height=2, command = lettreC)  
bouton1.place(relx=0.1, rely=0.1, x=10)

#définition du bouton "Voyelle"
bouton2 = Button(root, text="Voyelle", fg="green", width=8, height=2, command = lettreV) 
bouton2.place(relx=0.6, rely=0.1, x=10)

#définition du bouton "Valider"
bouton3 = Button(root, text ='Valider', width=8, height=2, fg="red4", font="bold", command = reponseL)
bouton3.place(relx=0.2, rely=0.9, x=10)

#définition du bouton "Rejouer"
bouton4 = Button(root, text ='Rejouer', width=8, height=2, fg="red4", font="bold", command = ...)
bouton4.place(relx=0.7, rely=0.9, x=10)

#définition du "Champ de saisie"
rep = StringVar()
Champ = Entry(root, textvariable= rep, show='', bg ='bisque', fg='maroon')
Champ.place(relx=0.2, rely=0.7, x=10) #, anchor=W)

#définition de l'étiquette "Tirage"
label1 = Label(root, text="Le tirage: "+" ".join(tirage), #n'a pas encore commencé. Choisis tes lettres.",
               fg="blue", height=2) 
label1.place(relx=0.1, rely=0.5, x=10)

#définition de l'étiquette "Quel mot proposes-tu?"
label2 = Label(root, text = "Quel mot proposes-tu?", font=("comic sans ms","12","bold"), fg="White", bg="blue")
label2.place (relx=0.1, rely=0.6, x=10)

#définition de l'étiquette "Mots proposés :"
label3 = Label (root, text ="Mots proposés :", font=("comic sans ms","12","bold"), fg="White", bg="blue")
label3.place (relx=0.7, rely=0.4, x=10)

# parametrage de la fenêtre
root.title("Initiation tk")     # titre
root.minsize(700,450)       # taille initiale
root.configure(background='Grey') # couleur de fond

# boucle pour actualiser la fenêtre
root.mainloop()









#partie de code permettant de vérifier que c'est le mot le plus long
    #for m in lexiques:
     #   ws = "".join(sorted(list(m)))
    #if ws in motsLexique:
     #   motsLexique[ws].append(m)
    #else:
#        motsLexique[ws] = [m]
        
#possible = []
#long = ""
#for mot in lexiques: #lexique:
 #   vocab = {}
  #  for v in tirage:
   #     vocab[v] = tirage.count(v)
    #verifier = True
    #for l in mot:
     #   if l in vocab and vocab[l] > 0:
      #      vocab[l] = vocab[l] - 1
       # else:
        #    verifier = False
         #   break
#    if verifier == True:
 #       possible = possible + lexiques[mot]
  #      if len(mot) > len(long):
   #         long = mot
#possible = set(possible)
#showinfo("Voici la liste de mots possibles avec le tirage:", " ".join(possible))
#if long != "":
 #   showinfo("mot le plus long avec ce tirage", random.choice(lexiques[long])) #long

4 réponses

  1. trifou
     
    Bonjour,

    Admettons un 
    tirage = ['r', 'e', 's', 'h', 'a', 'i', 't', 'm', 'e']

    Admettons un 
    mot_propose = 'maitresse'


    Comment vérifier que toutes les lettres de 
    mot_propose
    sont dans 
    tirage
    .
    En fait, il y a plusieurs façons de faire, une solution simple est d'utiliser un dict pour compter les lettres. 

    lettres_mot_propose = dict.fromkeys(mot_propose, 0)
for lettre in mot_propose:
    lettres_mot_propose[lettre] += 1


    On a alors le nombre des fréquences des lettres du mot propose, il ne reste plus qu'à vérifier que le nombre de chaque lettre correspond dans le tirage. 

    for lettre, nombre in lettres_mot_propose.items():
    nombre_lettres_tirage = tirage.count(lettre)
    if nombre > nombre_lettres_tirage:
        print(lettre, 'pas bonne')


    En ce qui concerne le second problème, il faut être plus précis, d'après ce que j'en comprends, on peut résoudre cela avec le même procédé.
    0
  2. minnitch Messages postés 9 Date d'inscription   Statut Membre Dernière intervention  
     
    Bonjour!

    Tout d'abord, merci pour votre réponse!
    J'ai appliqué ce que vous m'avez proposé cependant cela ne fonctionne pas.
    Je vous mets le code que j'ai entré ci-dessous, voyez-vous d'où viens mon erreur? 

    def reponseL():
    reponse = rep.get()
    lettres_reponse = dict.fromkeys(reponse,0)  
    for lettre in reponse:
        lettres_reponse[lettre] += 1
    for lettre, nombre in lettres_reponse.items():
        nombre_lettres_tirage = tirage.count(lettre)
        if nombre == nombre_lettres_tirage:
            showinfo("Bravo!", "Ta réponse est compatible avec le tirage")
            break
        else:
            showinfo("Booo", "Ta réponse n'est pas compatible avec le tirage")
            break


    En ce qui concerne mon second problème :
    Une fois que j'ai effectué la vérification de la compatibilité entre réponse et tirage, je dois regarder si la réponse du joueur correspond au mot le plus long possible et réalisable avec le tirage effectué plus tôt. Si le mot est le plus long mot possible alors le joueur à gagner, sinon le programme doit aller chercher dans le lexique quel est le mot le plus long possible et réalisable avec le tirage. J'espère être compréhensible

    Merci encore
    0
    1. trifou
       
      Regarde bien mon code, je n'ai pas fait un test d'égalité, mais de supériorité, et si supérieur, c'est que la réponse est incorrecte, i.e au moins une lettre du mot saisi n'est pas dans le tirage. 

      def reponseL():
    reponse = rep.get()
    lettres_reponse = dict.fromkeys(reponse,0)
    for lettre in reponse:
        lettres_reponse[lettre] += 1
    for lettre, nombre in lettres_reponse.items():
        nombre_lettres_tirage = tirage.count(lettre)
        if nombre > nombre_lettres_tirage:
            showinfo("Booo", "Ta réponse n'est pas compatible avec le tirage")
            return False
    showinfo("Bravo!", "Ta réponse est compatible avec le tirage")
    return True
      0
    2. trifou
       
      Et pour obtenir le plus grand mot de ton lexique contenant les lettres du tirage, il faut faire la même chose, faire un dict des fréquences de lettres du tirage, un second dict des fréquences pour un mot du lexique et comparer les 2.

      Comparer se résumera à retourner le nombre de points commun entre un mot du lexique et le tirage en se servant de ces 2 dict.
      0
    3. minnitch Messages postés 9 Date d'inscription   Statut Membre Dernière intervention   > trifou
       
      En effet, autant pour moi, cela fonctionne!
      Un grand merci!!
      0
    4. minnitch Messages postés 9 Date d'inscription   Statut Membre Dernière intervention   > trifou
       
      D'accord, très bien, merci
      Et pensez-vous qu'avec ce code ci-dessous, il serait possible de trouver le mot le plus long ? 

         
     possible = []
        long = ""
        for mot in lexiques: #lexique:
            vocab = {}
            for v in tirage:
                vocab[v] = tirage.count(v)
            verifier = True
            for l in mot:
                if l in vocab and vocab[l] > 0:
                    vocab[l] = vocab[l] - 1
                else:
                    verifier = False
                    break
            if verifier == True:
                possible = possible + lexiques[mot]
                if len(mot) > len(long):
                    long = mot
        possible = set(possible)
        showinfo("Voici la liste de mots possibles avec le tirage:", " ".join(possible))
        if long != "":
            showinfo("mot le plus long avec ce tirage", random.choice(lexiques[long])) #long
      0
    5. trifou > minnitch Messages postés 9 Date d'inscription   Statut Membre Dernière intervention  
       
      Comme on dit, tous les chemins mènent à Rome.
      Si tu obtiens le résultat attendu, alors c'est parfait ;)
      Le but étant de comprendre ce que tu réalises.

      Mais, quelques bémols.
      • Pourquoi lexiques est un dictionnaire ?
      • Pour ajouter un élément à une liste, on utilise append => 
        possible.append(lexiques[mot])
      • Pourquoi transformer possible en set ? lexiques étant un dict, il ne peut y avoir de doublons, et d'ailleurs y a-t-il des doublons dans ton fichier de lexiques ?
      0
  3. minnitch Messages postés 9 Date d'inscription   Statut Membre Dernière intervention  
     
    Je suis navrée, j'essaie de comprendre mais je trouve ça complexe.
    Je comprends ton code (du moins, je crois) mais je dois t'avouer que j'ai vraiment du mal quant à son adaptation à mon programme
    0
    1. minnitch Messages postés 9 Date d'inscription   Statut Membre Dernière intervention  
       
      Je ne comprends pas pourquoi on crée de nouvelles fonctions. N'est-il pas possible d'intégrer la partie du code permettant de trouver le mot le plus long à l'intérieur de la fonction reponseL ?

      Présentement, mon code suit cette structure : 

      # coding: utf-8
      from tkinter import *
      from tkinter.messagebox import *
      import codecs, random
      from script1 import * ### SCRIPT 1 À MODIFIER

      with codecs.open("lexique_gen.txt", "r", "utf8") as f:
          text = f.readlines()
          lexique_gen = []
          for w in text:
              lexique_gen.append(w.strip())

      with codecs.open("lexique_spe.txt", "r", "utf8") as f:
          text = f.readlines()
          lexique_spe = []
          for w in text:
              lexique_spe.append(w.strip())
                    
      n = ["n","r","s","t"]*6
      l = ["l"]*5
      dm = ["d","m"]*3
      g = ["g","b","c","p","f","h","v"]*2
      e = ["e"]*15
      a = ["a"]*9
      i = ["i","o","u"]*6
      consonnes = n+l+dm+g+["j","q","k","w","x","z"]
      voyelles = e+a+i+["y"]
      tirage = []
      motsLexique = {}
      root = Tk()


      def reponseL():
          reponse = rep.get()

      ### Code permettant de vérifier la compatibilité entre la réponse donnée par le joueur et le tirage
          lettres_reponse = dict.fromkeys(reponse,0)
          for lettre in reponse:
              lettres_reponse[lettre] += 1
          for lettre, nombre in lettres_reponse.items():
              nombre_lettres_tirage = tirage.count(lettre)
              if nombre > nombre_lettres_tirage:
                  showinfo("Booo", "Ta réponse n'est pas compatible avec le tirage")
                  return False

          showinfo("Bravo!", "Ta réponse est compatible avec le tirage")
          
      ### Code permettant de vérifier que mot donné par joueur = dans lexiques
          if reponse.lower() in lexique_spe:
              showinfo("Bravo!", "Ton mot est dans le lexique spécialisé!")
              root.destroy()
        
                      #INSÉRER CODE PERMETTANT DE TROUVER MOT LE + LONG 
                  
          elif reponse.lower() in lexique_gen:
              showinfo("Bravo!", "Ton mot est dans le lexique général!")
              root.destroy()

                      #INSÉRER CODE PERMETTANT DE TROUVER MOT LE + LONG

          else:
              showinfo("Boo!","Ton mot n'est dans aucun des deux lexiques!")
              Champ.delete(0, END)
              root.destroy()
          return True 


      ###ça je ne sais pas à quoi ça sert mais je pense qu c'est important 
          #    for m in lexiques:
          #        ws = "".join(sorted(list(m)))
          #        if ws in vocab:
          #            vocab[ws].append(m)
          #        else:
          #            vocab[ws] = [m]


      ### Code permettant de trouver le mot le plus long, À ADAPTER ET À PLACER DANS NOTRE PROGRAMME        
      #        possible = []
       #       long = ""
        #      for mot in motsLexique: #lexique:
         #         vocab = {}
          #        for v in tirage:
           #           vocab[v] = tirage.count(v)
            #      verifier = True
             #     for l in mot:
              #        if l in vocab and vocab[l] > 0:
               #           vocab[l] = vocab[l] - 1
                #      else:
                 #         verifier = False
                  #        break
      #            if verifier == True:
       #               possible = possible.append(lexiques[mot])
        #              if len(mot) > len(long):
         #                 long = mot
          #    possible = set(possible)
           #   showinfo("Voici la liste de mots possibles avec le tirage:", " ".join(possible))
            #  if long != "":
             #     showinfo("mot le plus long avec ce tirage", random.choice(lexiques[long])) #long
          
      #définition de l'action du bouton Consonne
      def lettreC():
          if len(tirage) < 9:
              lettre = random.choice(consonnes)
              tirage.append(lettre)
              label1.config(text="Lettres choisies: "+" ".join(tirage))
          else:
              showinfo("Fin","Fin de tirage de lettres, propose un mot!")

      #définition de l'action du bouton Voyelle
      def lettreV():
          if len(tirage) < 9:
              lettre = random.choice(voyelles)
              tirage.append(lettre)
              label1.config(text="Lettres choisies: "+" ".join(tirage))
          else:
              showinfo("Fin","Fin de tirage de lettres, propose un mot!")
      # image
      bg_image = PhotoImage(file ="terrain.png")
      x = Label(root, image = bg_image)
      x.pack(expand=True)                           # side=LEFT

      #définition du bouton "Consonne"
      bouton1 = Button(root, text="Consonne", fg="red", width=12, height=4,
                       command = lettreC)
      bouton1.place(relx=0.6, rely=0.4, x=10)


      #définition du bouton "Voyelle"
      bouton2 = Button(root, text="Voyelle", fg="green",font="bold", width=12, height=4,
                       command = lettreV) 
      bouton2.place(relx=0.75, rely=0.4, x=10)


      #définition du bouton "Valider"
      bouton3 = Button(root, text ='Valider', width=10, height=2, fg="red4", font="bold",
                       command = reponseL)
      bouton3.place(relx=0.63, rely=0.26, x=10)


      #définition du bouton "Rejouer"
      bouton4 = Button(root, text ='Rejouer', width=12, height=4, fg="red4", font="bold",
                       command = ...)
      bouton4.place(relx=0.85, rely=0.8)


      #définition du "Champ de saisie"
      rep = StringVar()
      Champ = Entry(root, textvariable= rep, show='', bg ='lightyellow')
      Champ.place(relx=0.4, rely=0.25, x=10, width=300, height=50) #, anchor=W)


      #définition de l'étiquette "Tirage"
      label1 = Label(root, text="Le tirage: "+" ".join(tirage), #n'a pas encore commencé. Choisis tes lettres.",
                     fg="black", bg="darkseagreen", height=3) 
      label1.place(relx=0.3, rely=0.1, x=10)


      #définition de l'étiquette "Quel mot proposes-tu?"
      label2 = Label(root, text = "Quel mot proposes-tu?", font="bold",
                     fg="white", bg="forestgreen")
      label2.place (relx=0.35, rely=0.2, x=10)


      #définition de l'étiquette "Mots proposés :"
      label3 = Label (root, text ="Mots proposés :",
                      fg="blue", bg="white")
      label3.place (relx=0.1, rely=0.6, x=10)


      # parametrage de la fenêtre
      root.title("Initiation tk")     # titre
      root.minsize(700,450)       # taille initiale
      root.configure(background='Grey') # couleur de fond

      # boucle pour actualiser la fenêtre
      root.mainloop()





      Je renouvelle ma question (dans le cas où je n'aurai pas été assez précise et surtout incompréhensible) :

      Serait-il possible de coder, aux endroits où il est indiqué "INSÉRER CODE PERMETTANT DE TROUVER MOT LE + LONG", la partie permettant de trouver le mot le plus long pour mes deux lexiques ?
      0
      1. trifou > minnitch Messages postés 9 Date d'inscription   Statut Membre Dernière intervention  
         
        Bonjour,

        Si tu ne mets pas ton code entre les balises codes du forum (bouton ▼ ou ❮❯) , il est illisible.

        Citation
        Je suis navrée, j'essaie de comprendre mais je trouve ça complexe.
        Je comprends ton code (du moins, je crois) mais je dois t'avouer que j'ai vraiment du mal quant à son adaptation à mon programme

        Ce n'est pas mon code, mais le tien (que j'ai ajusté), que tu as dit avoir vu en cours, donc ton prof a dû quand même expliquer la logique de ce code, et vu ce qui est demandé de faire dans ton exercice, c'est que tu devrais avoir vu les bases pour comprendre le déroulement de ce qu'il s'y passe, ton prof ne vous a certainement pas lâché en pleine nature sans au minimum un couteau et de quoi faire du feu. Rien ne t'empêche aussi d'ajouter des prints pour voir comment ça se passe.

        Citation
        Je ne comprends pas pourquoi on crée de nouvelles fonctions.

        Même chose, en cours, ton prof a dû aborder les fonctions, à quoi elles servent, quand les utiliser, etc.
        Programmer, c'est faire des tas de fonctions.

        Rien qu'au début de ton code, il y a ouverture de 2 fichiers dont le code est identique à part le nom du fichier, alors paf, on se fait une fonction. 

        def get_lexique(file_name):
    lexique = []
    with codecs.open(file_name, "r", "utf8") as f:
        text = f.readlines()
        for w in text:
            lexique.append(w.strip())
    return lexique


        Et pour obtenir les deux lexiques, on utilise cette fonction. 

        lexique_spe = get_lexique("lexique_spe.txt")
lexique_gen = get_lexique("lexique_gen.txt")


        En utilisant une fonction, on ne répète pas inutilement une même portion de code, mais en plus cela permettra facilement de charger un autre lexique en appelant simplement cette fonction.
        0
  4. minnitch Messages postés 9 Date d'inscription   Statut Membre Dernière intervention  
     
    Autant pour moi, mon programme a cette tête là : 

    # coding: utf-8
from tkinter import *
from tkinter.messagebox import *
import codecs, random
from script1 import * ### IMPORTATION DU SCRIPT1 NE FONCTIONNE PAS

with codecs.open("lexique_gen.txt", "r", "utf8") as f:
    text = f.readlines()
    lexique_gen = []
    for w in text:
        lexique_gen.append(w.strip())

with codecs.open("lexique_spe.txt", "r", "utf8") as f:
    text = f.readlines()
    lexique_spe = []
    for w in text:
        lexique_spe.append(w.strip())
              
n = ["n","r","s","t"]*6
l = ["l"]*5
dm = ["d","m"]*3
g = ["g","b","c","p","f","h","v"]*2
e = ["e"]*15
a = ["a"]*9
i = ["i","o","u"]*6
consonnes = n+l+dm+g+["j","q","k","w","x","z"]
voyelles = e+a+i+["y"]
tirage = []
motsLexique = {}
root = Tk()


def reponseL():
    reponse = rep.get()

### Code permettant de vérifier la compatibilité entre la réponse donnée par le joueur et le tirage
    lettres_reponse = dict.fromkeys(reponse,0)
    for lettre in reponse:
        lettres_reponse[lettre] += 1
    for lettre, nombre in lettres_reponse.items():
        nombre_lettres_tirage = tirage.count(lettre)
        if nombre > nombre_lettres_tirage:
            showinfo("Booo", "Ta réponse n'est pas compatible avec le tirage")
            return False

    showinfo("Bravo!", "Ta réponse est compatible avec le tirage")
    
### Code permettant de vérifier que mot donné par joueur = dans lexiques
    if reponse.lower() in lexique_spe:
        showinfo("Bravo!", "Ton mot est dans le lexique spécialisé!")
        root.destroy()
  
                #INSÉRER CODE PERMETTANT DE TROUVER MOT LE + LONG 
            
    elif reponse.lower() in lexique_gen:
        showinfo("Bravo!", "Ton mot est dans le lexique général!")
        root.destroy()

                #INSÉRER CODE PERMETTANT DE TROUVER MOT LE + LONG

    else:
        showinfo("Boo!","Ton mot n'est dans aucun des deux lexiques!")
        Champ.delete(0, END)
        root.destroy()
    return True 


###ça je ne sais pas à quoi ça sert mais je pense qu c'est important 
    #    for m in lexiques:
    #        ws = "".join(sorted(list(m)))
    #        if ws in vocab:
    #            vocab[ws].append(m)
    #        else:
    #            vocab[ws] = [m]


### Code permettant de trouver le mot le plus long, À ADAPTER ET À PLACER DANS NOTRE PROGRAMME        
#        possible = []
 #       long = ""
  #      for mot in motsLexique: #lexique:
   #         vocab = {}
    #        for v in tirage:
     #           vocab[v] = tirage.count(v)
      #      verifier = True
       #     for l in mot:
        #        if l in vocab and vocab[l] > 0:
         #           vocab[l] = vocab[l] - 1
          #      else:
           #         verifier = False
            #        break
#            if verifier == True:
 #               possible = possible.append(lexiques[mot])
  #              if len(mot) > len(long):
   #                 long = mot
    #    possible = set(possible)
     #   showinfo("Voici la liste de mots possibles avec le tirage:", " ".join(possible))
      #  if long != "":
       #     showinfo("mot le plus long avec ce tirage", random.choice(lexiques[long])) #long
    
#définition de l'action du bouton Consonne
def lettreC():
    if len(tirage) < 9:
        lettre = random.choice(consonnes)
        tirage.append(lettre)
        label1.config(text="Lettres choisies: "+" ".join(tirage))
    else:
        showinfo("Fin","Fin de tirage de lettres, propose un mot!")

#définition de l'action du bouton Voyelle
def lettreV():
    if len(tirage) < 9:
        lettre = random.choice(voyelles)
        tirage.append(lettre)
        label1.config(text="Lettres choisies: "+" ".join(tirage))
    else:
        showinfo("Fin","Fin de tirage de lettres, propose un mot!")
# image
bg_image = PhotoImage(file ="terrain.png")
x = Label(root, image = bg_image)
x.pack(expand=True)                           # side=LEFT

#définition du bouton "Consonne"
bouton1 = Button(root, text="Consonne", fg="red", width=12, height=4,
                 command = lettreC)
bouton1.place(relx=0.6, rely=0.4, x=10)


#définition du bouton "Voyelle"
bouton2 = Button(root, text="Voyelle", fg="green",font="bold", width=12, height=4,
                 command = lettreV) 
bouton2.place(relx=0.75, rely=0.4, x=10)


#définition du bouton "Valider"
bouton3 = Button(root, text ='Valider', width=10, height=2, fg="red4", font="bold",
                 command = reponseL)
bouton3.place(relx=0.63, rely=0.26, x=10)


#définition du bouton "Rejouer"
bouton4 = Button(root, text ='Rejouer', width=12, height=4, fg="red4", font="bold",
                 command = ...)
bouton4.place(relx=0.85, rely=0.8)


#définition du "Champ de saisie"
rep = StringVar()
Champ = Entry(root, textvariable= rep, show='', bg ='lightyellow')
Champ.place(relx=0.4, rely=0.25, x=10, width=300, height=50) #, anchor=W)


#définition de l'étiquette "Tirage"
label1 = Label(root, text="Le tirage: "+" ".join(tirage), #n'a pas encore commencé. Choisis tes lettres.",
               fg="black", bg="darkseagreen", height=3) 
label1.place(relx=0.3, rely=0.1, x=10)


#définition de l'étiquette "Quel mot proposes-tu?"
label2 = Label(root, text = "Quel mot proposes-tu?", font="bold",
               fg="white", bg="forestgreen")
label2.place (relx=0.35, rely=0.2, x=10)


#définition de l'étiquette "Mots proposés :"
label3 = Label (root, text ="Mots proposés :",
                fg="blue", bg="white")
label3.place (relx=0.1, rely=0.6, x=10)


# parametrage de la fenêtre
root.title("Initiation tk")     # titre
root.minsize(700,450)       # taille initiale
root.configure(background='Grey') # couleur de fond

# boucle pour actualiser la fenêtre
root.mainloop()


    Oui, je comprends le fonctionnement d'une fonction mais j'ai du mal au niveau de l'application. J'ai essayé de créer une fonction permettant d'ouvrir mes deux fichiers .txt mais je n'y suis pas parvenue.

    Penses-tu qu'il me faut reprendre mon programme actuel (celui juste au-dessus)?
    J'entends par là faire une fonction qui permet de vérifier que la réponse du joueur est compatible avec le tirage, en faire une seconde qui permet de vérifier que réponse est dans les deux lexiques et une autre qui irait chercher quel est le mot le plus long?
    Si oui, il faut donc relier les fonctions entre elles mais comment faire?
    0
    1. trifou
       
      Il faudrait faire du ménage dans ton code, il y a beaucoup de choses inutiles, il y a quoi en fait dans le module script1 ?

      Oui, pour tes questions sur les fonctions à faire. Je ne comprends pas ce qui te pose problème, ni ce que tu entends par relier.
      0
      1. minnitch Messages postés 9 Date d'inscription   Statut Membre Dernière intervention   > trifou
         
        Vraiment? J'ai pourtant l'impression que tout est utile dans mon code actuel..
        Dans mon script1, j'apporte des modifications à mes deux lexiques notamment la substitution des caractères accentués par des caractères non-accentués (par exemple : é ; è ; ê ; ë qui deviennent "e").

        Pour te répondre, j'ai du mal à imaginer la structure que peut avoir mon code au final (en utilisant plusieurs fonctions différentes).
        Si je reprends intégralement mon code en faisant des fonctions pour chaque action que je souhaite réaliser (comme tu me suggères de le faire), il faut bien qu'il y ait un lien entre chacune de ces fonctions, non?
        Si oui, j'ai du mal à comprendre comment ce lien doit être fait et à quel endroit les fonctions doivent "s'appeler" (si je puis dire).
        0
      2. trifou > minnitch Messages postés 9 Date d'inscription   Statut Membre Dernière intervention  
         
        Bonjour,

        Je parle de nettoyage en supprimant tout les blocs de codes commentés.
        De toute façon tu n'as toujours rien fait de plus, ni aucun changement par rapport à ton 1er script.

        Et qu'il y a-t-il de difficile à commencer par écrire. 

        def reponse_est_valide(reponse, tirage):
    # Retourne True si les lettres de reponse sont dans tirage, sinon False

def get_mots_max(lexique, tirage):
    # Retourne les mots max du lexique en fonction du tirage

def desactiver_validation_reponse():
    # Désactive le bouton de validation réponse
    # Désactive le champ de saisie de la réponse

def activer_validation_reponse():
    # Active le bouton de validation réponse
    # Active le champ de saisie de la réponse

def reponseL():
    desactiver_validation_reponse()
    reponse = rep.get().lower()
    if reponse_est_valide(reponse, tirage):
        if reponse in lexique_spe:
            mots_max = get_mots_max(lexique_spe, tirage)
            # Afficher les mots max
            if reponse in mots_max:
                # Afficher un message "bien joué"
            else:
                # Afficher un message "perdu"
        elif reponse in lexique_gen:
            mots_max = get_mots_max(lexique_spe, tirage)
            # Afficher les mots max
            if reponse in mots_max:
                # Afficher un message "bien joué"
            else:
                # Afficher un message "perdu"
        else:
            activer_validation_reponse()
            # Afficher un message demandant un autre mot  
    else:
        activer_validation_reponse()
        # Afficher un message d'erreur de mot incorrect


        L'affichage de message, peut très bien se faire avec une fonction qui changerait le texte d'un label, et en fonction du type du message, changerait aussi la couleur du texte du label.

        Tout est question de logique de ce qui doit être effectué grosso modo en suivant l’énoncé de l'exercice, il est même évident que l'on pourrait changer les conditions 
        if/elif reponse in ...
        et mettre ça dans une boucle ou une autre fonction, puisque ça fait la même chose sur différents lexiques.
        Maintenant à part te dire d'expérimenter, tester, je ne vois pas ce que je pourrais te dire de plus.
        Je t'ai fourni quelques briques de ton application, si tu n'es pas capable de l'intégrer à ton mur, ça va être compliqué, je te conseille donc de revoir tes cours, suivre un tuto sur internet.
        0

Discussions similaires

le mot secret ne s'affiche pas, comment pourrais-je faire?
v.b.06 -
elevedeprime -

5 réponses
Correction python
Arcadi -
mamiemando -

5 réponses
afficher un message sur python ""
Tim -
Enzo -

2 réponses
Bloqué à de la programmation Python
Fffhbcdfffv -
PierrotLeFou -

2 réponses
TV LG "Non programmé"
Chantal Joubert -
Mancini -

5 réponses