Discussion :

[Invité]

Bonjour

Il y a un problème d'exécution instantanée dans ce code
Le "print" s'exécute sans aucune intervention de l'utilisateur

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
# !/usr/bin/env python 3.5
# -*- coding: utf-8 -*-
 
from tkinter import *
 
class Gammic(Tk):
    def __init__(self):
        Tk.__init__(self)
        self.title(' :')
        self.ccc = None
        self.btc = Button(self, text='Comic', width=15, command=self.comic)
        self.btc.pack()
 
    def comic(self):
        if self.ccc is not None:
            self.ccc.destroy()
        self.ccc = Toplevel(self)
        self.ccc.geometry('600x666')
        self.btc2 = Button(self.ccc, text='Comic2', width=15, command=Gam2.brnch(self))
        self.btc2.pack()
 
class Gam2(Gammic):
    def __init__(self):
        Gammic.__init__(self)
    def brnch(self):
        print('o')
 
Gammic().mainloop()

[YCL-1]

Code :

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

self.btc2 = Button(self.ccc, text='Comic2', width=15, command=Gam2.brnch(self))

Bonjour,

c'est là que vient le problème.

En passant la commande avec les parenthèses (et les arguments requis) ça appelle la fonction plutôt que de pointer sur la fonction qui sera appelée au moment de cliquer.

Malheureusement tkinter ne dispose pas d'argument permettant de faire passer les arguments qui seront appelés par commande.

De plus j'y vois un autre problème, Game2 doit être instancié avant de pouvoir appeler la fonction brnch.

Si vous ne souhaitez pas garder l'instance vous pouvez utiliser lambda :

Code :

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

self.btc2 = Button(self.ccc, text='Comic2', width=15, command=lambda: Gam2().brnch())

L'argument self de brnch est passé automatiquement par l'instance Game2()

Mais le mieux serait de créer une fonction dans la classe Gammic pour conserver l'instance de Game2 :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
    def comic(self):
        if self.ccc is not None:
            self.ccc.destroy()
        self.ccc = Toplevel(self)
        self.ccc.geometry('600x666')
        self.btc2 = Button(self.ccc, text='Comic2', width=15, command=self.cb_game2)
        self.btc2.pack()
 
    def cb_game2(self):
        self.gam2 = Gam2()
        self.gam2.brnch()

Pour plus d'informations sur les callbacks tkinter : http://effbot.org/zone/tkinter-callbacks.htm

[wiztricks]

Le "print" s'exécute sans aucune intervention de l'utilisateur

"Gam2.brnch(self)" appelle la fonction Gam2.brnch avec pour argument "self". Si vous voulez que ce soit la méthode "brnch" associé à l'objet "self", il faudrait écrire "self.brnch" - sans parenthèses - après avoir instancié "Gam2" et non "Gammic". Si tout ce que je raconte vous semble étrange, (re)lisez votre tuto. sur les classes.

- W

[Invité]

Merci pour vos éclaircissements qui ont permis d'accéder à la solution

La fonction brnch fonctionne maintenant.
Tout d'abord le retrait de "(self)", puis "@staticmethod" pour instancier je ne sais pas quoi

Mais çà fonctionne

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
# !/usr/bin/env python 3.5
# -*- coding: utf-8 -*-
 
from tkinter import *
 
class Gammic(Tk):
    def __init__(self):
        Tk.__init__(self)
        self.title(' :')
        self.ccc = None
        self.btc = Button(self, text='Comic', width=15, command=self.comic)
        self.btc.pack()
 
    def comic(self):
        if self.ccc is not None:
            self.ccc.destroy()
        self.ccc = Toplevel(self)
        self.ccc.geometry('600x666')
        self.btc2 = Button(self.ccc, text='Comic2', width=15, command=Gam2.brnch)
        self.btc2.pack()
 
class Gam2(Gammic):
    def __init__(self):
        Gammic.__init__(self)
 
    @staticmethod
    def brnch():
        print('o')
 
Gammic().mainloop()

[Invité]

"Gam2.brnch(self)" appelle la fonction Gam2.brnch avec pour argument "self". Si vous voulez que ce soit la méthode "brnch" associé à l'objet "self", il faudrait écrire "self.brnch" - sans parenthèses - après avoir instancié "Gam2" et non "Gammic". Si tout ce que je raconte vous semble étrange, (re)lisez votre tuto. sur les classes.

- W

J'ai finalement instancié "Gam2" et non "Gammic", car vos conseils fonctionnent.
Comme "pycharm" corrige au fur et à mesure mes disfonctionnements, et qui en allant plus vite que la musique.
Je ne fais que suivre ses arrangements de structuration, en ayant modifié l'instanciation "Gam2" par "Gammic"
la correction me propose l'utilisation d'une super classe.

Je vais essayer de comprendre pourquoi utiliser une super classe
Voir bout de code :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
class Commatique(Gammique):
    """Branchement commatique"""
 
    def __init__(self):
        Commatique.__init__(self)
        super().__init__()
 
    @staticmethod
    def brnch_1():
        print('n')
 
# class Gammique
Gammique().mainloop()

[bistouille]

La fonction brnch fonctionne maintenant.
Tout d'abord le retrait de "(self)", puis "@staticmethod" pour instancier je ne sais pas quoi

Pourquoi utiliser une méthode statique ?

Voir bout de code :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
class Commatique(Gammique):
    """Branchement commatique"""
 
    def __init__(self):
        Commatique.__init__(self)
        super().__init__()
 
    @staticmethod
    def brnch_1():
        print('n')
 
# class Gammique
Gammique().mainloop()

Si tu instancies Commatique, il risque d'y avoir un problème

[Invité]

Pourquoi utiliser une méthode statique ?



Si tu instancies Commatique, il risque d'y avoir un problème

J'ai retiré la méthode statique, et remis l'instance "gammic" à la place de "Gam2"
(j'en reviens au programme court)

Mais je me retrouve à utiliser une fonction sans le "self" entre les "()"
Là j'entre dans un domaine qui m'est inconnu

Est-ce viable ?

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
# !/usr/bin/env python 3.5
# -*- coding: utf-8 -*-
 
from tkinter import *
 
class Gammic(Tk):
    def __init__(self):
        Tk.__init__(self)
        self.title(' :')
        self.ccc = None
        self.btc = Button(self, text='Comic', width=15, command=self.comic)
        self.btc.pack()
 
    def comic(self):
        if self.ccc is not None:
            self.ccc.destroy()
        self.ccc = Toplevel(self)
        self.ccc.geometry('600x666')
        self.btc2 = Button(self.ccc, text='Comic2', width=15, command=Gam2.brnch)
        self.btc2.pack()
 
class Gam2(Gammic):
    def __init__(self):
        Gammic.__init__(self)
 
    def brnch():
        print('o')
 
Gammic().mainloop()

En essayant "

Code :

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

lambda

" la fonction est devenue "normale" avec le "(self)"

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
# !/usr/bin/env python 3.5
# -*- coding: utf-8 -*-
 
from tkinter import *
 
class Gammic(Tk):
    def __init__(self):
        Tk.__init__(self)
        self.title(' :')
        self.ccc = None
        self.btc = Button(self, text='Comic', width=15, command=self.comic)
        self.btc.pack()
 
    def comic(self):
        if self.ccc is not None:
            self.ccc.destroy()
        self.ccc = Toplevel(self)
        self.ccc.geometry('600x666')
        self.btc2 = Button(self.ccc, text='Comic2', width=15,
                           command=lambda : Gam2.brnch(self))
        self.btc2.pack()
 
class Gam2(Gammic):
    def __init__(self):
        Gammic.__init__(self)
 
    def brnch(self):
        print('o')
 
Gammic().mainloop()

[bistouille]

Bah non.

Pour moi le but de passer une méthode à une commande de button, c'est de pouvoir travailler avec différents attributs/méthodes d'un objet, sinon, autant passer une simple fonction.
Mais comme je ne sais ce que tu veux obtenir au final.

Y'a t-il lieu d'avoir un héritage de Gammic par Gam2 ?
A-priori non.

Donc je pense que c'est plutôt une composition dont tu as besoin ici et non un héritage.
Mais n'étant pas un foudre de guerre en objet, je me trompe peut-être

[wiztricks]

J'ai retiré la méthode statique, et remis l'instance "gammic" à la place de "Gam2"
(j'en reviens au programme court)

Mais je me retrouve à utiliser une fonction sans le "self" entre les "()"
Là j'entre dans un domaine qui m'est inconnu

Est-ce viable ?

Pour que ce soit viable, il faudrait que vous compreniez ce que vous faites et pour çà, passer du temps à travaillez avec un tuto. est indispensable mais "apprendre à programmer" est visiblement une musique qui vous passe par dessus la tête.
Si vous leviez un peu la tête de votre guidon, vous écririez une chose équivalente:

Code :

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

1
2
3
4
>>> class A:
...    def f(self):
...        self.g()
...

Dans ce cas, si la méthode "g" pas définie dans A, c'est que vous laissez le boulot à la classe qui en héritera:

Code :

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

1
2
3
4
5
6
>>> class B(A):
...     def g(self):
...        print('g')
...
>>> B().f()
g

Et vous pourriez même faire de g une méthode "abstraite" de A histoire qu'on oublie pas:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
>>> class A:
...    def f(self):
...        self.g()
...    def g(self):
...        raise NotImplementedError
...
>>> A().f()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in f
  File "<stdin>", line 5, in g
NotImplementedError

- W