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

[Invité]

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

Ce petit bout de programme a été fait pour exécuter une fonction, ou bien l'appel à celle-ci
Gammic a du contenu à traiter avec la classe Gam2, c'est aussi en rapport d'un commentaire (classe "Gammic" trop chargée)
Ainsi cette nouvelle classe "Gam2" va aider à alléger ce lourd début, et combien initiatique

Gam2 fait sa première ouverture, merci de m'avoir indiqué, ceci : Si tu instancies Commatique, il risque d'y avoir un problème

[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

[Invité]

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

Merci pour le vélo çà fait longtemps que je n'en ai pas fait.
Je lève la tête sur le tuto, et il est lu tous les matins,,, je ne l'ai pas lu
Même si l'exemple est explicite, il reste éloigné car sans bouton, sans __init__,,,
Pour le moment, et sans autre apport.
Comme je suis un programmeur cycliste, je fonce sur cette idée "lambda"
Jusqu'au prochain virage, heu problème

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()

[wiztricks]

Même si l'exemple est explicite, il reste éloigné car sans bouton, sans __init__,,,
Pour le moment, et sans autre apport.

Apprendre, c'est acquérir cette capacité de distinguer un détail de construction (2 lignes à changer) un concept qui pourra être répété (surcharge, méthode abstraite) en faisant abstraction du reste (les 30 autres lignes de votre code).

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=self.brnch)
        self.btc2.pack()
 
class Gam2(Gammic):
    def __init__(self):
        Gammic.__init__(self)
 
    def brnch(self):
        print('o')
 
Gam2().mainloop()

Ecrire "lambda : Gam2.brnch(self)", c'est associer l'objet self à la fonction "Gam2.brnch", ce que fait très aussi bien "self.brnch".

- W

[Invité]

Apprendre, c'est acquérir cette capacité de distinguer un détail de construction (2 lignes à changer) un concept qui pourra être répété (surcharge, méthode abstraite) en faisant abstraction du reste (les 30 autres lignes de votre code).

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=self.brnch)
        self.btc2.pack()
 
class Gam2(Gammic):
    def __init__(self):
        Gammic.__init__(self)
 
    def brnch(self):
        print('o')
 
Gam2().mainloop()

Ecrire "lambda : Gam2.brnch(self)", c'est associer l'objet self à la fonction "Gam2.brnch", ce que fait très aussi bien "self.brnch".

- W

Ce que je n'aime pas : Gam2().mainloop(). À chaque fonction ajoutée = changement #().mainloop()
Puis, il restait une erreur à propos de static (Pycharm) sur la fonction brnch(), sans parler des autres
Apparemment, IDLE Python a moins de rigueur que Pycharm au niveau des corrections

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
# !/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('300x30+300+50')
        self.btc2 = Button(self.ccc, text='Comic2', width=15,
                           command=lambda : Gam2.brnch())
        self.btc2.pack()
 
class Gam2(Gammic):
    def __init__(self):
        Gammic.__init__(self)
 
    @staticmethod
    def brnch():
        print('o')
 
Gammic().mainloop()

[wiztricks]

Salut,

Ce que je n'aime pas : Gam2().mainloop(). À chaque fonction ajoutée = changement #().mainloop()

Ajouter une méthode n'impose pas de créer une nouvelle classe fille: pas besoin d'un Gam3, elle peut aller dans Gam2...
De toutes façons, c'est comme çà que fonctionne l'héritage...
Si çà ne vous plait pas, c'est que vous avez besoin d'un autre type de relation entre vos classe.
Modulo que vous en ayez effectivement besoin car, aujourd'hui vous avez une immense classe Gammic qui n'est instanciée qu'une seule fois: "class" vous complique la vie sans apporter grand chose.

- W

[Invité]

Bonjour

Ce n'est peut-être pas l'idéal, mais cette méthode fait passer un tuple à Gam2

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
from tkinter import *
 
class Gammic(Tk):
    def __init__(self):
        Tk.__init__(self)
        self.title(' :')
        self.ccc = None
        self.a = Button(self, text='Comic', width=15, command=self.Comic)
        self.a.pack()
        self.table = []
 
    def Comic(self):
        if self.ccc is not None:
            self.ccc.destroy()
        self.ccc = Toplevel(self)
        self.ccc.geometry('600x666')
        self.b = Button(self.ccc, text='Comic2', width=15,
                        command = lambda : Gam2.brnch(cob))
        self.b.pack()
        for i in range(5):
            self.table.append(i)
        cob = self.table
 
class Gam2(Gammic):
    def brnch(cob):
        print('o', cob)
 
Gammic().mainloop()

[bistouille]

Manifestement je ne comprends pas la logique de ton code si toutefois il y en a une.

Je vois pas en quoi fourrer ta méthode dans une classe enfante qui hérite de la classe où se situe l'appel à cette méthode procure un avantage quelconque, en plus l'héritage ne sert à rien puisque tu ne t'en sert pas.

[Invité]

Manifestement je ne comprends pas la logique de ton code si toutefois il y en a une.

Je vois pas en quoi fourrer ta méthode dans une classe enfante qui hérite de la classe où se situe l'appel à cette méthode procure un avantage quelconque, en plus l'héritage ne sert à rien puisque tu ne t'en sert pas.

Ce que je tentais de faire était de passer une table réalisée dans la classe parente, dans la classe enfante.
La classe parente a plusieurs filières de développements, et la classe enfant va développer cette table récupérée pour développer un autre niveau de cette partie qui traite des commas. En fait çà évite d'avoir une classe parente surchargée en développements.

Ce petit bout ne fait que montrer le chemin d'un autre contexte, qui lui aussi s'avèrera compliqué avec de nombreuses lignes de code.

Sinon et autrement, qu'est ce qui te gêne ?

[wiztricks]

Ce que je tentais de faire était de passer une table réalisée dans la classe parente, dans la classe enfante.
La classe parente a plusieurs filières de développements, et la classe enfant va développer cette table récupérée pour développer un autre niveau de cette partie qui traite des commas. En fait çà évite d'avoir une classe parente surchargée en développements.

Si vous utilisiez l'héritage normalement, vous écririez simplement:

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
from tkinter import *
 
class Gammic(Tk):
    def __init__(self):
        Tk.__init__(self)
        self.title(' :')
        self.ccc = None
        self.a = Button(self, text='Comic', width=15, command=self.Comic)
        self.a.pack()
        self.table = []
 
    def Comic(self):
        if self.ccc is not None:
            self.ccc.destroy()
        self.ccc = Toplevel(self)
        self.ccc.geometry('600x666')
        self.b = Button(self.ccc, text='Comic2', width=15,
                        command = self.brnch)
        self.b.pack()
        for i in range(5):
            self.table.append(i)
 
 
class Gam2(Gammic):
    def brnch(self):
        print('o', self.table)
 
Gam2().mainloop()

self.table étant un attribut de la classe parente, pas besoin de le passer en paramètre via une fonction: la classe fille peut y accéder directement.
Et si le gros soucis est d'avoir à écrire Gam2().mainloop() au lieu de Gammic().mainloop(). Il y a plein de solutions comme:

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
from tkinter import *
 
class GammicBase(Tk):
    def __init__(self):
        Tk.__init__(self)
        self.title(' :')
        self.ccc = None
        self.a = Button(self, text='Comic', width=15, command=self.Comic)
        self.a.pack()
        self.table = []
 
    def Comic(self):
        if self.ccc is not None:
            self.ccc.destroy()
        self.ccc = Toplevel(self)
        self.ccc.geometry('600x666')
        self.b = Button(self.ccc, text='Comic2', width=15,
                        command = self.brnch)
        self.b.pack()
        for i in range(5):
            self.table.append(i)
 
 
class Gam2::
    def brnch(self):
        print('o', self.table)
 
class Gammic(Gam2, Base):
     pass
 
Gammic().mainloop()

Ce petit bout ne fait que montrer le chemin d'un autre contexte, qui lui aussi s'avèrera compliqué avec de nombreuses lignes de code.

Sinon et autrement, qu'est ce qui te gêne ?

Si vous ne vous appliquez pas à construire vos classes proprement, le jour où vous aurez besoin d'aide, pas grand monde perdra du temps à essayer de comprendre ce que vous voulez faire. C'est un peu comme si vous écriviez à quelqu'un une lettre bourrée de fautes d'orthographes: il va tiquer sur la forme et n'essaiera pas de décoder ce que vous avez écrit: poubelle. En programmation, c'est pareil: vous aurez certainement des invitations à lire des tutos... mais pas grand monde perdra son temps à essayer de vous décoincer si vous même ne prenez pas le temps d'apprendre le minimum par vous même.

Bon courage.
- W

[Invité]

Poursuivre dans le bon sens, comme cette solution l'indique

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
from tkinter import *
 
class Gammic(Tk):
    def __init__(self):
        Tk.__init__(self)
        self.title(' :')
        self.ccc = None
        self.a = Button(self, text='Comic', width=15, command=self.Comic)
        self.a.pack()
        self.table = []
 
    def Comic(self):
        if self.ccc is not None:
            self.ccc.destroy()
        self.ccc = Toplevel(self)
        self.ccc.geometry('600x666')
        self.b = Button(self.ccc, text='Comic2', width=15,
                        command = self.brnch)
        self.b.pack()
        for i in range(5):
            self.table.append(i)
 
 
class Gam2(Gammic):
    def brnch(self):
        print('o', self.table)
 
Gam2().mainloop()

Alors je suppose que lorsque j'ajouterais une autre classe pour développer un système tétracordique
J'écrirais ceci

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
# ...
class Gam2(Gammic):
    def brnch(self):
        print('o', self.table)
        # ...
 
class Terta2(Gammic):
    def brntr(self):
        print('o', self.tetra)
        # ...
 
Tetra2().mainloop()

[/CODE]

[Invité]

Après une mûre réflexion, et encore une fois "lambda" GAGNANT !

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
# !/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.a = Button(self, text='Comic', width=15, command=self.Comic)
        self.a.pack()
        self.table = []
 
    def Comic(self):
        if self.ccc is not None:
            self.ccc.destroy()
        self.ccc = Toplevel(self)
        self.ccc.geometry('600x666')
        self.b = Button(self.ccc, text='Comic2', width=15,
                        command = lambda : Gam2.brnch(cob))
        self.b.pack()
        for i in range(10):
            self.table.append(i)
        cob = self.table
 
class Gam2(Gammic):
    def brnch(cob):
        print('o', cob)
 
Gammic().mainloop()