Bouton activé sans clic, de classe à classe

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:

---

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

---

Code:

---

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:

---

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:

---

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

Citation:

---

Envoyé par toumic

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

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:

---

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

---

Citation:

---

Envoyé par wiztricks

"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:

---

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

---

Citation:

---

Envoyé par toumic

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 ?

Citation:

---

Envoyé par toumic

Voir bout de code :

Code:

---

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 :mrgreen:

Citation:

---

Envoyé par bistouille

Pourquoi utiliser une méthode statique ?



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

---

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:

---

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:

---

lambda

---

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

Code:

---

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

---

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 :aie:

Citation:

---

Envoyé par 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 :aie:

---

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

Citation:

---

Envoyé par toumic

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:

---

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:

---

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:

---

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

Citation:

---

Envoyé par wiztricks

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:

---

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:

---

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:

---

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 :aie:

Code:

---

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

---

Citation:

---

Envoyé par toumic

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:

---

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

Citation:

---

Envoyé par wiztricks

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:

---

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:

---

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

---

Salut,

Citation:

---

Envoyé par toumic

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

Bonjour

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

Code:

---

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

---

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.

Citation:

---

Envoyé par 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.

---

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 ?

Citation:

---

Envoyé par toumic

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:

---

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:

---

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

---

Citation:

---

Envoyé par toumic

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

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

Code:

---

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:

---

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]

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

Code:

---

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

---