Besoin d'aide pour programme en python

Signaler
Messages postés
9
Date d'inscription
dimanche 5 janvier 2020
Statut
Membre
Dernière intervention
7 janvier 2020
-
 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

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é.
Messages postés
9
Date d'inscription
dimanche 5 janvier 2020
Statut
Membre
Dernière intervention
7 janvier 2020

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
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
minnitch
Messages postés
9
Date d'inscription
dimanche 5 janvier 2020
Statut
Membre
Dernière intervention
7 janvier 2020
> trifou
En effet, autant pour moi, cela fonctionne!
Un grand merci!!
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.
minnitch
Messages postés
9
Date d'inscription
dimanche 5 janvier 2020
Statut
Membre
Dernière intervention
7 janvier 2020
> 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
> minnitch
Messages postés
9
Date d'inscription
dimanche 5 janvier 2020
Statut
Membre
Dernière intervention
7 janvier 2020

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 ?
Messages postés
9
Date d'inscription
dimanche 5 janvier 2020
Statut
Membre
Dernière intervention
7 janvier 2020

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
minnitch
Messages postés
9
Date d'inscription
dimanche 5 janvier 2020
Statut
Membre
Dernière intervention
7 janvier 2020

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 ?
> minnitch
Messages postés
9
Date d'inscription
dimanche 5 janvier 2020
Statut
Membre
Dernière intervention
7 janvier 2020

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.
Messages postés
9
Date d'inscription
dimanche 5 janvier 2020
Statut
Membre
Dernière intervention
7 janvier 2020

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?
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.
minnitch
Messages postés
9
Date d'inscription
dimanche 5 janvier 2020
Statut
Membre
Dernière intervention
7 janvier 2020
> 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).
> minnitch
Messages postés
9
Date d'inscription
dimanche 5 janvier 2020
Statut
Membre
Dernière intervention
7 janvier 2020

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.