Sujet Précédent Sujet Suivant

Comment exploiter une variable globale dans une procédure déclencher par command

Résolu/Fermé
cvan85 Messages postés 54 Date d'inscription mardi 1 novembre 2011 Statut Membre Dernière intervention 7 juillet 2022 - 18 déc. 2020 à 16:24
Phil_1857 Messages postés 1687 Date d'inscription lundi 23 mars 2020 Statut Membre Dernière intervention 19 mars 2023 - 20 déc. 2020 à 08:53
Bonjour,
je souhaite pouvoir accéder et modifier une variable appelée matrice initialisée dans le programme principal, qui prend ses premières valeurs (1ère ligne de la matrice)dans une procédure: def lancement() et ses valeurs suivantes dans une autre procédure: def autre_tirage().
J'ai visiblement un problème de "visibilité" de ces variables mais je ne vois pas comment je pourrais contourner le problème.

Merci de votre aide

Claude 

#!/usr/bin/env python3.9
#######################
#                     #
# Jeu AZ  #
#                     #
#######################

from tkinter import *
import random 
import time

###### Définition des fonctions ##############
def aff_widg(canva):
    for i in range(5):
        for j in range(5):
            canva.create_rectangle((40*(i+1),40*(j+1)),((40*(i+1)+40),40*(j+1)+40))
    
#def maj_palette(co):
#########
# mettre à jour le dico  par +1  sur couleur tirée

    
def sel_coul():
    ind=random.randint(1,7)
    coul=choix[ind-1]
    palette[coul] +=1
    return coul

####Début de partie    
def lancement():
    palette.clear
    for c in range(7):
        palette[choix[c-1]] = 0
    for i in range(5):
        couleur=sel_coul()
        can_gen.create_rectangle(((40*(i+1),40),((40*(i+1)+40),40+40)), fill=couleur,width=2, outline='black')
        lig_courant[i]=couleur
    matrice[0]=lig_courant
    print ("matrice premier tirage: ",matrice[0] )
#old_lig_courant=lig_courant
    Label(can_gen, text= "Pour chaque ligne supplémentaire\n cochez 2 cases et validez",bg='#FEFEE2',fg='blue').place(x=40, y= 310)
        
    
    
def autre_tirage():
    global lig_courant
    global matrice
    ind_mat = 0
    nb_case = 0
    if (r_v_c1.get()):
        nb_case=nb_case + 1
    if (r_v_c2.get()):
        nb_case=nb_case + 1
    if (r_v_c3.get()):
        nb_case=nb_case + 1
    if (r_v_c4.get()):
        nb_case=nb_case + 1
    if (r_v_c5.get()):
        nb_case=nb_case + 1

    if nb_case != 2:
        Label(can_gen, text= "Attention ne cochez que 2 cases!     " ,bg='#FEFEE2',fg='red').place(x=40, y= 310) 
        r_v_c1.set(False)
        r_v_c2.set(False)
        r_v_c3.set(False)
        r_v_c4.set(False)
        r_v_c5.set(False) 
    else:
        if(matrice[1][0]=='vide'):
                print("pemière couleur de la colonne 1 = vide")
                lig=2
                ind_mat=0
        elif (matrice[2][0]=='vide'): 
                lig=3
                ind_mat=1
        elif (matrice[3][0]=='vide'):
                lig=4
                ind_mat=2
        elif (matrice[3][0]=='vide'):
                lig=5
                ind_mat=3
        print("Ligne traitée : ", lig)
        print ("Ligne 1 de la matrice: ",matrice[0])
        print ("Ligne 2 de la matrice: ",matrice[1])
        print ("Ligne 3 de la matrice: ",matrice[2])
        print ("Ligne 4 de la matrice: ",matrice[3])
        print ("Ligne 5 de la matrice: ",matrice[4])
        if (r_v_c1.get()):
            couleur=sel_coul()
            col=1
            can_gen.create_rectangle(((40*(col),40*(lig)),((40*(col)+40),40*(lig)+40)), fill=couleur,width=2, outline='black')
            lig_courant[0]=couleur
            r_v_c1.set(False)
        else:
            col=1
            can_gen.create_rectangle(((40*(col),40*(lig)),((40*(col)+40),40*(lig)+40)), fill=matrice[ind_mat][0],width=2, outline='black')
            
        if (r_v_c2.get()):
            couleur=sel_coul()
            col=2
            can_gen.create_rectangle(((40*(col),40*(lig)),((40*(col)+40),40*(lig)+40)), fill=couleur,width=2, outline='black')
            lig_courant[1]=couleur
            r_v_c2.set(False)
        else:
            col=2
            can_gen.create_rectangle(((40*(col),40*(lig)),((40*(col)+40),40*(lig)+40)), fill=matrice[ind_mat][1],width=2, outline='black')
            
        if (r_v_c3.get()):
            couleur=sel_coul()
            col=3
            can_gen.create_rectangle(((40*(col),40*(lig)),((40*(col)+40),40*(lig)+40)), fill=couleur,width=2, outline='black')
            lig_courant[2]=couleur
            r_v_c3.set(False)
        else:
            col=3
            can_gen.create_rectangle(((40*(col),40*(lig)),((40*(col)+40),40*(lig)+40)), fill=matrice[ind_mat][2],width=2, outline='black')
           
        if (r_v_c4.get()):
            couleur=sel_coul()
            col=4
            can_gen.create_rectangle(((40*(col),40*(lig)),((40*(col)+40),40*(lig)+40)), fill=couleur,width=2, outline='black')
            lig_courant[3]=couleur
            r_v_c4.set(False)
        else:
            col=4
            can_gen.create_rectangle(((40*(col),40*(lig)),((40*(col)+40),40*(lig)+40)), fill=matrice[ind_mat][3],width=2, outline='black')
            
        if (r_v_c5.get()):
            couleur=sel_coul()
            col=5
            can_gen.create_rectangle(((40*(col),40*(lig)),((40*(col)+40),40*(lig)+40)), fill=couleur,width=2, outline='black')
            lig_courant[4]=couleur
            r_v_c5.set(False)
        else:
            col=5
            can_gen.create_rectangle(((40*(col),40*(lig)),((40*(col)+40),40*(lig)+40)), fill=matrice[ind_mat][4],width=2, outline='black')
            
        matrice[ind_mat]=lig_courant
#old_lig_courant=lig_courant
        print ("Matrice après valid: ", matrice[ind_mat]) 
        print ("ind_mat = ",ind_mat)
#print ("old_lig_courant après valid : ",old_lig_courant)
            
def rien():
    return 1

####### Programme principal ###################### 
# Définitions des variables globales    
choix = ['blue','green','red','yellow','purple','pink','white']
palette = {}
lig_courant =['vide','vide','vide','vide','vide']
matrice = [['vide','vide','vide','vide','vide'],['vide','vide','vide','vide','vide'],['vide','vide','vide','vide','vide'],['vide','vide','vide','vide','vide'],['vide','vide','vide','vide','vide']]

####### Début du programme principal #############
fen1=Tk()
fen1.title("Jeu AZ V1.0")
fen1.geometry("420x470")
can_gen=Canvas(fen1, width=360, height=410, bg ="#FEFEE2")
can_gen.place(x=30,y=30)
aff_widg(can_gen)
r_v_c1 = BooleanVar(value=False)
r_v_c2 = BooleanVar(value=False)
r_v_c3 = BooleanVar(value=False)
r_v_c4 = BooleanVar(value=False)
r_v_c5 = BooleanVar(value=False)
c1 = Checkbutton(can_gen, text = "1", height = 2, width = 5,bg ="#FEFEE2",variable= r_v_c1).place(x=40,y=280)
c2 = Checkbutton(can_gen, text = "2", height = 2, width = 5,bg ="#FEFEE2",variable= r_v_c2).place(x=80,y=280)
c3 = Checkbutton(can_gen, text = "3", height = 2, width = 5,bg ="#FEFEE2",variable= r_v_c3).place(x=120,y=280)
c4 = Checkbutton(can_gen, text = "4", height = 2, width = 5,bg ="#FEFEE2",variable= r_v_c4).place(x=160,y=280)
c5 = Checkbutton(can_gen, text = "5", height = 2, width = 5,bg ="#FEFEE2",variable= r_v_c5).place(x=200,y=280)
valid = Button(can_gen, text = "Validez", height = 2, width = 7,bg ="#FEFEE2",fg='red',command = autre_tirage).place(x=295,y=280)

Button(can_gen, text='Démarrer\nune partie',bg='#FFE4C4',fg='red',command = lancement).place(x=10, y= 370)
Button(can_gen, text='FIN \nde partie',bg='#AD4F09',fg='red', command = fen1.quit).place(x=250,y=370)

####### Boucle d'attente d'évènements ##############
fen1.mainloop()

####### Effacement fenêtre - Sortie programme ######
fen1.destroy()
####################################################


Configuration: Macintosh / Safari 14.0.1

5 réponses

Réponse 1 / 5
Phil_1857 Messages postés 1687 Date d'inscription lundi 23 mars 2020 Statut Membre Dernière intervention 19 mars 2023 162
19 déc. 2020 à 17:35
Bonjour,

Ceci mis à part, on peut toujours passer un paramètre à une fonction lancée

par command en utilisant une fonction lambda: 

def lancement():
    ........

Button(main_win,  text='Démarrer', command=lambda : lancement(mat))
1
Réponse 2 / 5
Phil_1857 Messages postés 1687 Date d'inscription lundi 23 mars 2020 Statut Membre Dernière intervention 19 mars 2023 162
20 déc. 2020 à 08:53
Bonjour Claude,

Dans l'exemple que je t'ai donné, je m'aperçois que j'ai oublié le paramètre de la fonction: 

def lancement(mat):
    ........
1
Réponse 3 / 5
jee pee Messages postés 37294 Date d'inscription mercredi 2 mai 2007 Statut Modérateur Dernière intervention 20 mars 2023 8 916
Modifié le 18 déc. 2020 à 17:39
Bonjour,

Juste le principe sans m'attacher à ton code.

Voir : https://openclassrooms.com/fr/courses/235344-apprenez-a-programmer-en-python/232520-decouvrez-la-portee-des-variables-et-les-references

Donc definir la matrice dans le corps et après modifier la matrice avec une méthode (append, insert, remove, ...) 
def f1():
    print('f1 avant',matrice)
    matrice.append([1,2,3])
    print('f1 après',matrice)

def f2():
    print('f2 avant',matrice)
    matrice.append([4,5,6])
    print('f2 après',matrice)

# main
matrice=[]
print(matrice)
f1()
print('retour f1',matrice)
f2()
print('retour f2',matrice)
0
Réponse 4 / 5
cvan85
18 déc. 2020 à 18:06
Merci pour ce retour rapide.
Je regarde le contenu de ce lien et je mets en application.
Je reviendrai ici pour fermer le post en cas de résolution.
cdlt,
Claude
0

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question
Réponse 5 / 5
cvan85 Messages postés 54 Date d'inscription mardi 1 novembre 2011 Statut Membre Dernière intervention 7 juillet 2022 1
19 déc. 2020 à 18:06
Merci Phil, je regarde cette option.
J'avais par ailleurs un problème d'index incohérent qui faisait aussi que je ne me déplaçais pas comme il le fallait dans la matrice.

Bonnes fêtes de Noël.
0