Discussion :

[hyuga33]

Bonjour,
je voudrais savoir si il est facile de passer de méthodes procédurales à une programmation objet?
J'ai besoin de le faire et j'ai vraiment du mal.
En fait, je crée un jeu donc je suis partis sur des méthodes procédurales qui marchent et maintenant je dois le programmer en poo.
Merci de votre aide.
P.S: Je débute en python

[clic4]

Salut !

Techniquement, transformer les fonctions que tu as écrites en méthodes de classe n'est pas bien compliqué. Après tout, les méthodes d'un objet ne sont que des fonctions attachées à une classe... donc le passage en POO peut se limiter à une ou deux structures de base et quelques copier/coller de tes méthodes procédurales.

Ce que je ne comprends pas bien c'est pourquoi tu DOIS programmer en POO (ce que je te conseille tout de même ). Est-ce lié à un besoin ou à une obligation formelle (comme dans un cours) ?

Dans les deux cas, le passage vers la POO est l'occasion de repenser ton code pour l'adapter au mieux à ce paradigme de programmation. Quelles classes/objets vas-tu créer ? Quelles seront leurs méthodes et propriétés ? Comment ces classes s'articulent-elles ? Que peut-on simplifier, etc.

Sans exemple concret de ton projet il est difficile d'en dire davantage. Encore une fois, si c'est réécrire ton code en POO pour faire le la POO, cela ne devrait pas te prendre trop de temps... si tu veux tirer partie de cet outil cela passe forcement par une réflexion sur ton code.

En espérant n'avoir pas dis trop de bêtises ^^

[hyuga33]

Merci de ta réponse.
Tout d'abord, je dois passer en POO car c'est un projet et que j'aimerais apprendre à maitriser cette partie de python.
Je veux créer aux moins deux classes: une pour l'interface graphique et une pour le jeu en lui-même.
Je dois utiliser une classe image pur créer le plateau de jeu et les bouttons.
L'autre classe comprendra les commandes de jeu. Le jeu est une variante de puissance 4.
Mais j'ai vraiment du mal à comprendre les interactions entre les classes.

[clic4]

Tout ça me rappelle mes propres interrogations lorsque j'ai commencé à coder en POO ^^. La question qui me revenait sans cesse était de savoir comment communiquer entre mes classes.
Au sujet des interactions entre les classes, je distingue à présent surtout l'héritage et l'encapsulage (ou composition... je ne suis pas très doué question vocabulaire).

Pour le premier, une classe Fils hérite d'une autre classe Pere. Fils possède toutes les méthodes et propriétés de Pere. La classe Fils peut évidemment posséder des méthodes ou propriétés qui lui sont propres ou des méthodes et propriétés de Pere légèrement différentes. L'héritage consiste surtout à adapter ou modifier une classe existante pour en faire une variante.

L'encapsulage c'est simplement d'attribuer à un objet l'instance d'une autre classe. Un objet Parent contient un ou plusieurs autres objets, c'est une de ses propriétés au même titre qu'un integer, une string, etc.

Dans ton exemple, la classe d'affichage contiendrait la classe contenant le moteur du jeu. Dans l'affichage tu récupères les événements (clique souris, etc.) et déclenche les méthodes de ta classe contenant la logique du jeu.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
class MoteurJeu:
    def __init__(self):
        """ Logique du jeu, calcul des coups, etc. """
        pass
 
    def placerPiece(self, piece, position):
        """ Placer une pièce sur le plateau. """
 
    ...
 
 
class Affichage:
    def __init__(self):
        self.moteur = MoteurJeu()
 
    def ajouterPiece(self):
        """ Ajouter une pièce sur le plateau lorsque le joueur clique. """
        # Trouver la position de la pièce et déterminer le type de pièce
        ...
        # Appeler la méthode de l'instance de MoteurJeu pour placer la pièce
        self.moteur.placerPiece(maPiece, positionPiece)

Grosso modo hein ^^

[hyuga33]

Je vais essayer comme ça, j'espére avoir compris mais dans tous les cas ça vas être dur. C'est comme ça qu'on aprend!!
Merci.

[kango]

L'encapsulage c'est simplement d'attribuer à un objet l'instance d'une autre classe. Un objet Parent contient un ou plusieurs autres objets, c'est une de ses propriétés au même titre qu'un integer, une string, etc.

bonjour,

je ne suis pas tout à fait d'accord avec ceci
l'encapsulage est un concept d'abstraction. je vais faire une analogie simple pour que ce soit plus clair.

tu as ton permis et tu conduis une voiture ? tu ne sais pas exactement comment marche un moteur, une boite de vitesse ou un embrayage, pourtant tu SAIS conduire !

c'est tout simplement que la voiture est un objet complexe certes mais qui se conduit en utilisant des "interfaces" simples:

- pédales
- volant
- levier de vitesse

chacune de ces interfaces est associée à une (ou plusieurs) action simple:

- accélérer, freiner, débrayer
- tourner
- changer de vitesse

tout ce qui est complexe dans une voiture (c'est à dire: ce qui se passe quand tu appuies sur la pédale d'accélérateur) est "masqué" au conducteur, il n'en a pas besoin pour utiliser l'objet voiture.

l'encapsulation c'est ça: cacher à l'utilisateur de l'objet les détails dont il n'a pas besoin et lui donner des interfaces simples pour exécuter des actions sur l'objet.

mais si on "découpe" un peu, on peut considérer que le moteur est aussi un objet mais que l'utilisateur de cet objet ce n'est pas toi, mais la voiture. c'est à dire qu'il expose au reste de la voiture des méthodes pour que la voiture puisse l'utiliser: les courroies, le branchement au démarreur, à l'embrayage...

une voiture est donc un agrégat d'objets complexe que l'on peut utiliser facilement.

la poo c'est pareil: on masque la complexité et on fournit des méthodes simples pour utiliser l'objet.

[hyuga33]

Meci de votre aide.
Mais je n'y arrive pas, je comprends comment marche à peu prés les classes entre elles mais après je ne vois pas comment définir clairement mes méthodes. J'ai des messages d'erreur qui dissent que je ne déclare pas certains objets alors que je pense l'avoir fait.
Je continue!!

[PauseKawa]

Bonsoir hyuga33,

Le plus simple n'est il pas de donner du code en exemple/question (De préférence une question par sujet) si tu n'y arrive pas ?
L'exemple par le code (et l'explication de celui-ci) c'est la meilleure façon à mon avis.
Je ne vais pas polémiquer sur les réponses mais l'abstrait n'aide pas 'au début' (Et je suis un perpétuel débutant).

@+

[PauseKawa]

Bonjour hyuga33,

Normal, paint n'est pas visible pour Initiation(). Ce n'est sans doute qu'un rappel mais les variables locales (et je parlerais plus d'un 'niveau' de visibilité plutôt que global/local)/fonctions à l'intérieur d'un objet ne sont pas visibles de l'extérieur, sauf si on fais en sorte que oui. :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
        self.gridB = TextGrid(root, widget=Button, size=(7,1), font=fnt, width=9,
                command=Calcul.paint)
        for p, color in enumerate(self.colors):
....
class Calcul():

ou plutot

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
    def __init__(self):
 
        self.calcul=Calcul
        self.lecture_option()
 
    def lecture_option(self):
 
....
        self.gridB = TextGrid(root, widget=Button, size=(7,1), font=fnt, width=9,
                command=self.calcul.paint)

Avec ce bout de code cela devrais aller pour paint.
Il te reste TextGrid.

Je te conseille ce sujet ou encore celui ci sur la portée des variables/objets.

@+ et bon code

[hyuga33]

Merci PauseKawa!!
En fait le fait de mettre:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

self.calcul=Calcul

permet de créer une variable locale par rapport à une autre classe. J'ai bien compris?

Pour T, je vois pas bien comment faire. J'ai l'impression que c'est une classe "particuliére" et qu'on l'appele simplement avec un objet=T(). J'essaie de comprendre.

@+

[exe2bin]

Salut ,
pourquoi ne vas-tu pas faire un tour du coté des tutoriels ou alors
je te conseille d'acheter un livre ; celà semble un bon investissement
pour te permettre de toucher du doigt les subtilités de la poo.

[PauseKawa]

Bonjour,

Bon, vite fais sur ton code (et il y a pas mal à revoir, sans critique car je n'est pas le niveau pour cela)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
# -*- coding: cp1252 -*-
# ==============================================================================
# puissance4 : 
# ==============================================================================
""" """
__author__  = ""
__version__ = ""
__date__    = ""
# ------------------------------------------------------------------------------
from Tkinter import *
 
class Centremoi():
    def __init__(self, monwidget):
        monwidget.update_idletasks()
        monwidget.geometry("%dx%d+%d+%d" % (monwidget.winfo_reqwidth(),monwidget.winfo_reqheight(), (monwidget.winfo_screenwidth()-monwidget.winfo_reqwidth())/2, (monwidget.winfo_screenheight()-monwidget.winfo_reqheight())/2 ) )
        monwidget.resizable(width=False, height=False)
 
 
 
 
class TextGrid(Frame):
  config = {'border':1, 'widget':Label, 'text':'' , 'size':(2,2), 'command':''}
 
 
  def __init__(self, master, **keys):
    for key in self.config:
      if key not in keys: keys[key] = self.config[key]
    self.grid, self.size, self.init = {}, keys['size'], keys['text']
    widget, command, (cols,rows) = keys['widget'], keys['command'], keys['size']
    del keys['widget'], keys['command'], keys['size']
    Frame.__init__(self, master, border=keys['border'], relief=SOLID)
 
 
    for col in range(cols):
      for row in range(rows):
        if command:
            keys['command'] = lambda cell=(col,row): command(cell)
        self.grid[col,row] = widget(self, keys) 
        self.grid[col,row].grid(column=col, row=row, sticky=N+S+W+E)
    for n in range(cols): self.columnconfigure(n, weight=1)
    for n in range(rows): self.rowconfigure(n, weight=1)
 
 
  def __getitem__(self, key):
    if isinstance(key, str): 
      return Frame.__getitem__(self, key)
    col, row = key[:2]; prop = key[2] if len(key) == 3 else 'text'
    return self.grid[col,row][prop] 
 
 
  def __setitem__(self, key, val):
    if isinstance(key, str):
      Frame.__setitem__(self, key, val); return
    col, row = key[:2]; prop = key[2] if len(key) == 3 else 'text'
    self.grid[col,row][prop] = val
 
 
 
 
class Initiation(Tk):
 
    def __init__(self,parent):
        Tk.__init__(self, parent)
        self.parent = parent
        self.size, self.fnt = (7,7), "Arial 14"
        self.colors = ('RED','RED','RED','RED','RED','RED','RED')
        self.color1 = 'RED'
        self.color2 = 'BLUE'
        self.joueur1 = 0
        self.joueur2 = 0
        self.gridB = TextGrid(self, widget=Button, size=(7,1), font=self.fnt, width=9,
                command=Calcul().paint)
        for p, color in enumerate(self.colors):
            self.gridB[p,0] = 'RED'
            self.gridB[p,0,'bg'] = 'GREY'
        self.gridB.pack(side=TOP, fill=BOTH, padx=5, pady=5)
 
        self.gridA = TextGrid(self, size=self.size, font=self.fnt, width=4, height=2, relief=SOLID)
        for p in range(7):
            for k in range(7):
                self.gridA[p,k,'bg'] = 'GREY'
        self.gridA.pack(side=TOP, fill=BOTH, expand=YES, padx=5, pady=5)
 
 
 
 
class Calcul():
 
    def paint(self, button):
        temp,self.tem=[],[]
        val = button[0]
 
        if root.gridB[val,0] == 'Stop':
            temp = [7]
 
        for v in range(7):
            if root.gridB[v,0] != 'Stop':
                self.tem.append(root.gridB[v,0])
 
        self.color = self.tem[0]
 
        if len(temp) == 0:
            if self.tem[0] == root.color1:
                self.joueur=root.joueur1
            else:
                self.joueur=root.joueur2
            self.remplir(button)
            self.gagner(button)
 
    def remplir(self, button):
 
        val = button[0]
        k = 6
 
        while k:
            if root.gridA[val,k,'bg'] == 'GREY':
                root.gridA[val,k,'bg'] = self.color
                break
            else:
                k -= 1
            if k == 0:
                root.gridA[val,k,'bg'] = self.color
                root.gridB[val,0,'bg'] = 'YELLOW'
                root.gridB[val,0] = 'Stop'
 
    def change(self):
        if self.tem[0] == root.color1:
            self.color='BLUE'
        else:
            self.color='RED'
        cols, rows = root.size
        for p in range(rows):
            if root.gridB[p,0] != 'Stop':
                root.gridB[p,0] = self.color
 
    def gagner(self, button): # 
        val = button[0]
        print val
        print button
 
        for val in range(7):
            for k in range(4):
                if (root.gridA[val,k,'bg']== self.color) and (root.gridA[val,k+1,'bg']== self.color) and (root.gridA[val,k+2,'bg']== self.color) and (root.gridA[val,k+3,'bg']== self.color):
                    self.joueur += 1
                    break
        for val in range (7):
            for k in range(4):
                if (root.gridA[k,val,'bg']== self.color) and (root.gridA[k+1,val,'bg']== self.color) and (root.gridA[k+2,val,'bg']== self.color) and (root.gridA[k+3,val,'bg']== self.color):
                    self.joueur += 1
                    break
        for val in range(4):
            for k in range(4):
                if (root.gridA[val,k,'bg']==self.color) and (root.gridA[val+1,k+1,'bg']==self.color) and (root.gridA[val+2,k+2,'bg']==self.color) and (root.gridA[val+3,k+3,'bg']==self.color):
                    self.joueur += 1
                    break
        for val in range(4):
            for k in range(6,2,-1):  
                if (root.gridA[val,k,'bg']==self.color) and (root.gridA[val+1,k-1,'bg']==self.color) and (root.gridA[val+2,k-2,'bg']==self.color) and (root.gridA[val+3,k-3,'bg']==self.color):
                    self.joueur += 1
                    break
 
        if self.joueur == 3:
            self.fenetre()
        else: self.change()
 
    def fenetre(self):
        scor=Toplevel()
        #root.withdraw()
        scor.withdraw()
        scor.title('scores')
        if self.color == 'RED': gagnants = 'rouges'
        else: gagnants = 'bleus'
        Label(scor, text= 'Les '+gagnants+' ont gagné', font='Arial 50', width=25, border=2, relief=SOLID).pack(side=TOP, fill=BOTH, pady=5, padx=5)
        scor.protocol('WM_DELETE_WINDOW', scor.quit) # Cela ne sert a rien...
        scor.minsize(scor.winfo_width(), scor.winfo_height())
        Centremoi(scor)
        scor.deiconify()
 
 
 
# ==============================================================================
if __name__ == "__main__": # testcode for class 'TextGrid'
 
  # ----------------------------------------------------------------------------
    root=Initiation(None)
    root.withdraw()
    root.title("TextGrid")
    root.minsize(root.winfo_width(), root.winfo_height())
    root.resizable(1,1)
    root.protocol("WM_DELETE_WINDOW", root.quit) # Cela ne sert a rien...
    Centremoi(root)
    root.deiconify()
    root.mainloop()

Désolé, cela n'est pas terrible mais j'ai fais en sorte de rester le plus près du code d'origine.

@+

Ps : Ton test dans gagner() est à revoir il me semble.

[PauseKawa]

Bonjour hyuga33,

Merci!!
J'ai à peu près compris. La classe Centremoi est la seule que je ne comprends pas vraiment.
Donc j'ai finis le jeu: un puissance 4 auquel on rajoute des slides(3 par joueur) qui déplacent toutes les cases à droites ou à gauches et il faut faire 3 alignements pour gagner.

Pour ce qui est de Centremoi laisse tomber si tu le souhaite. C'est une classe perso qui me permet de centrer les fenêtres Tk/Toplevel après l'utilisation du géométry manager (pack, grid ou place) suivant les besoins de la dite fenêtre (winfo_reqwidth/winfo_reqheight). Je l'avais laissée en place car je lui envoi la fenêtre (monwidget) et j'avais pensé cela intéressant pour toi.

Je pense qu'il y a une erreur de logique dans gagner().

Quel est ton problème avec ImageGrid ?

@+

[hyuga33]

Bon j'ai résolu le problème de gagner en créeant une liste d'éléments dans laquelle je stocke les cases gagnantes. De plus quand je fais un slid je remets les compteurs à 0 puis je regarde toutes les nouvelles combinaison ainsi créer.

Maintenant j'essaie de créer une classe ouvrant une fenêtre avant le début du jeu. Dans cette classe je veux pouvoir mettre le nombre de colonnes et de lignes à rentrer par l'utilisateur.
J'arrive à avoir une fenêtre avec le bouton 'lancer le jeu' qui quand je clique dessus lance le jeu. Mais le jeu ne marche pas. Un message d'erreur me dit que root n'est pas déclaré.

Ensuite, j'essaie toujours d'utiliser les .gif pour rendre le jeu plus agréable mais sans succés.

Bonne soirée.

[PauseKawa]

Bonsoir,

Maintenant j'essaie de créer une classe ouvrant une fenêtre avant le début du jeu. Dans cette classe je veux pouvoir mettre le nombre de colonnes et de lignes à rentrer par l'utilisateur.

Une classe ? Pourquoi ne pas faire un withdraw()/tafenetre/deiconify() de ton root avec un Toplevel ?

Donne du code.

@+

Ps : Pas plusieurs fenêtres Tk, du Toplevel.

[hyuga33]

C'est bon, je pense avoir un peu compris! Enfin, j'espére..
j'ai fait

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
  def opentop():
    root=Initiation(None)
    root.withdraw()
    root.title("Sliding Rows")
    root.minsize(root.winfo_width(), root.winfo_height())
    root.resizable(1,1)
    root.deiconify()
    root.mainloop()         
 
  para=Tk()
  b= Button(para,text="Nouvelle fenetre",command=opentop)
  b.pack()
  para.mainloop()

Mais ça ne marche pas, comme d'habitude j'y arrive pas.
J'ai bien la première fenêtre qui apparait et quand je clique sur Nouvelle fenetre ma fenêtre de jeu apparait. Mais dès que je clique sur une case pour joueur,il y a un message d'erreur que je ne comprends.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
Exception in Tkinter callback
Traceback (most recent call last):
  File "C:\Python26\lib\lib-tk\Tkinter.py", line 1410, in __call__
    return self.func(*args)
  File "C:\Users\Damien\Desktop\temp41.py", line 24, in <lambda>
    keys['command'] = lambda cell=(col,row): command(cell)
  File "C:\Users\Damien\Desktop\temp41.py", line 116, in paint
    if root.gridB[val,0] == 'Stop':
  File "C:\Users\Damien\Desktop\temp41.py", line 35, in __getitem__
    return self.grid[col,row][prop]
  File "C:\Python26\lib\lib-tk\Tkinter.py", line 1206, in cget
    return self.tk.call(self._w, 'cget', '-' + key)
TclError: invalid command name ".61260864.61261424"

[hyuga33]

Je suis toujours bloqué sur la création de cette fenêtre.. Du coup j'ai clarifié mon code et enlevé les bugs. Donc tout marche nickel mais je ne peux toujours pas faire choisir la taille de la grille de jeu par l'utilisateur. Je veux le faire demander par une fenêtre qui s'ouvre avant le lancement du jeu.