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

---

Salut,

Citation:

---

Envoyé par toumic

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

---

Cela suppose que vous avez fait une analyse des avantages/inconvénients de la chose. Vous pourriez les partager...

Sinon, plutôt qu'utiliser improprement l'héritage, vous pourriez déclarer Gam2 comme classe indépendante "collection de fonctions":

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(self.table)) self.b.pack() for i in range(10): self.table.append(i)     class Gam2: def brnch(cob): print('o', cob)   Gammic().mainloop()

---

çà marche aussi... et là, pas d'autres choix que d'utiliser "lambda" pour fabriquer la fonction/callback passé à "command".

- W

Maintenant c'est plus que résolu :)

Citation:

---

Envoyé par toumic

Maintenant c'est plus que résolu :)

---

Je m'explique au sujet du choix lambda en destination.

La classe commatique a comme base, une table construite dans la fonction chromatique de la gamme.
Cette gamme dans la classe principale a donc une fonction chromatique et une table utile au développement commatique.
Ce commatisme est volumineux en traitements, et donc il lui faut être une autre classe, et par obligation à référence chromatique.
Les commas ne viennent pas d'un vide, mais de la gamme en cours calculée par la classe Gammique.

Si l'opération "lambda" est facile, la création d'une classe fille "Commatique" héritière l'est moins.
Pour finir la classe Commatique = class Commatique(Gammique):, et sans perturber inutilement = Gammique().mainloop()
Va pouvoir se servir de tous les objets de la classe Gammique, etc.
Seulement je travaille avec Pycharm et il me conseille une méthode statique pour la fonction principale de Commatique.

Code:

---

1 2 3 4 5 6 7 8 9

class Commatique(Gammique):     @staticmethod def brnch_1(cob1): print('o', cob1) # print('p', cob2)     # class Gammique Gammique().mainloop()

---

Mon éditeur est OK, il n'attend plus que le code pour continuer et moi aussi :)

Salut,

Citation:

---

Envoyé par toumic

Si l'opération "lambda" est facile, la création d'une classe fille "Commatique" héritière l'est moins.

---

Ce n'est pas faute de vous avoir montré comment faire.

Citation:

---

Envoyé par toumic

Pour finir la classe Commatique = class Commatique(Gammique):, et sans perturber inutilement = Gammique().mainloop()
Va pouvoir se servir de tous les objets de la classe Gammique, etc.

---

Si vous passez par lambda sans avoir "instancié" proprement Gam2, il vous sera impossible d'accéder aux objets d'un Gammique sans jonglerie inutile est obscure.

Continuez votre route, vous verrez les écueils qui vous attendent.

- W

Citation:

---

Envoyé par wiztricks

Salut,



Ce n'est pas faute de vous avoir montré comment faire.



Si vous passez par lambda sans avoir "instancié" proprement Gam2, il vous sera impossible d'accéder aux objets d'un Gammique sans jonglerie inutile est obscure.

Continuez votre route, vous verrez les écueils qui vous attendent.

- W

---

Est-ce que si j'ajoute le def __init__(self): Gammique.__init__(self), çà évite les écueils ?

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

class Commatique(Gammique): """Branchement Commique""" def __init__(self): Gammique.__init__(self)       @staticmethod def brnch_1(cob1, cob2): print('o', cob1) print('p', cob2)     # class Gammique Gammique().mainloop()

---

Citation:

---

Envoyé par toumic

Est-ce que si j'ajoute le def __init__(self): Gammique.__init__(self), çà évite les écueils ?

---

Si vous aviez pris le temps de lire (et comprendre) un tuto. sur les classes et l'héritage, vous ne poseriez pas cette question.
D'autre part, si j'essayais de vous expliquer pourquoi çà ne change rien, il me faudrait utiliser des mots comme instance, méthode, surcharge, polymorphisme,... que vous ne comprendriez pas sans avoir travaillé sur les tutos de votre côté: çà ne vous avancera pas plus et pas la peine que j'y passe du temps.

- W

Si je ne rêve pas, grâce à la première réponse et à votre insistence que çà marche

Tout en restant dans ma même ligne de mire, et dans un but de réussite. En instance de la nouvelle classe plus sereine,
ce qui m'évite de chercher dans des solutions beaucoup plus divines...

Gammique. (__init__)
A été ajoutée la table à transférer sur Commatique

Code:

---

1 2 3

def cb_com2(self): self.com2 = Commatique() self.com2.brnch_1(self.co_tbgen)

---

Dans la fonction comma et son bouton d'appel Commatique

Code:

---

1 2 3

btcom_up = Button(frcom_up, text='Commane', height=1, width=15, bg='pink', command=self.cb_com2) btcom_up.pack(side=LEFT)

---

Pour finir par un truc comique comme çà

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

class Commatique(Gammique): """Branchement Commique""" def __init__(self): pass   # @staticmethod def brnch_1(self, c_oo): print('ooo', c_oo) # ('p', cob2) for i in range(12): pass # print(i, self.c_cob1[i])     # class Gammique Gammique().mainloop()

---

Et enfin la version simple qui a suivit son cours ici même

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 32 33 34 35 36 37

# !/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 = [] self.com2 = Gam2()   def cb_com2(self): self.com2.brnch(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.cb_com2) self.b.pack() for i in range(10): self.table.append(i)     class Gam2(Gammic): def __init__(self): pass def brnch(self, cob): print('ooo', cob)   Gammic().mainloop()

---

Citation:

---

Envoyé par toumic

Et enfin la version simple qui a suivit son cours ici même

---

Fabriquer une instance de Gammic et créer un autre instance de Gam2 qui hérite de Gammic tout en court-circuitant l'initialisation de la classe parente, c'est très inventif mais çà ne le fait toujours pas.

Continuez comme vous voulez, mais je n'essaierai de vous aider qu'à partir du moment où vous posterez un code bien construit et montrant que vous avez compris ce que vous aurez appris dans votre tuto. favori.
Bon courage.

- W

Citation:

---

Envoyé par wiztricks

Fabriquer une instance de Gammic et créer un autre instance de Gam2 qui hérite de Gammic tout en court-circuitant l'initialisation de la classe parente, c'est très inventif mais çà ne le fait toujours pas.

Continuez comme vous voulez, mais je n'essaierai de vous aider qu'à partir du moment où vous posterez un code bien construit et montrant que vous avez compris ce que vous aurez appris dans votre tuto. favori.
Bon courage.

- W

---

Maintenant çà doit aller, sans l'héritage

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 32 33 34 35

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

---