Voila, j'ai developpe une interface graphique en python ( sous Linux
).
J'ai scinde le code en different modules distinct representant chacun
une fenetre de l'interface.
Un dernier module est responsable de la gestion des evenements dans
l'interface.
Mon probleme est le suivant.
Lorsque je lance l'interface, j'importe le module de fonction.
Celui-ci ayant besoin de certains elements de l'interface, il importe
le module d'interface.
Bilan des operations ca coince.
Je ne vois pas comment resoudre ce probleme.
Je vous donne un exemple tres simplifie de ce que j'essais de faire:
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Eric Brunel
Mamantins wrote:
Bonjour a tous.
Voila, j'ai developpe une interface graphique en python ( sous Linux ). J'ai scinde le code en different modules distinct representant chacun une fenetre de l'interface. Un dernier module est responsable de la gestion des evenements dans l'interface.
Mon probleme est le suivant. Lorsque je lance l'interface, j'importe le module de fonction. Celui-ci ayant besoin de certains elements de l'interface, il importe le module d'interface.
Bilan des operations ca coince. Je ne vois pas comment resoudre ce probleme.
Je vous donne un exemple tres simplifie de ce que j'essais de faire:
Une autre solution, sans doute plus "élégante", serait de réorganiser un peu le module gui, de mettre ta fonction give dans une classe, d'instancier cette classe au démarrage de l'appli et de passer l'instance à l'instance de Gui:
--gui.py-------------------------------------------- from Tkinter import *
class Gui(Tk): def __init__(self, myFct): Tk.__init__(self) self.fct = myFct self.frame = Frame(self) ... # Tout pareil après...
if __name__ == '__main__': fct = Fct() ----------------------------------------------------
et tu lances: python fct.py
Comme ça, tu peux appeler toutes les méthodes que tu veux sur ton objet "fonctionnel" sans avoir besoin d'importer le module. Ca permet aussi de séparer le coté interface du coté fonctionnel: tout ce dont ton objet gui a besoin, c'est d'un objet qui implémente les méthodes qu'il appelle (ici, la méthode "give"), sans que gui.py dépende de fct.py, puisqu'il ne l'importe plus jamais.
HTH -- - Eric Brunel <eric (underscore) brunel (at) despammed (dot) com> - PragmaDev : Real Time Software Development Tools - http://www.pragmadev.com
Mamantins wrote:
Bonjour a tous.
Voila, j'ai developpe une interface graphique en python ( sous Linux
).
J'ai scinde le code en different modules distinct representant chacun
une fenetre de l'interface.
Un dernier module est responsable de la gestion des evenements dans
l'interface.
Mon probleme est le suivant.
Lorsque je lance l'interface, j'importe le module de fonction.
Celui-ci ayant besoin de certains elements de l'interface, il importe
le module d'interface.
Bilan des operations ca coince.
Je ne vois pas comment resoudre ce probleme.
Je vous donne un exemple tres simplifie de ce que j'essais de faire:
Une autre solution, sans doute plus "élégante", serait de réorganiser un peu le
module gui, de mettre ta fonction give dans une classe, d'instancier cette
classe au démarrage de l'appli et de passer l'instance à l'instance de Gui:
--gui.py--------------------------------------------
from Tkinter import *
class Gui(Tk):
def __init__(self, myFct):
Tk.__init__(self)
self.fct = myFct
self.frame = Frame(self)
... # Tout pareil après...
if __name__ == '__main__':
fct = Fct()
----------------------------------------------------
et tu lances:
python fct.py
Comme ça, tu peux appeler toutes les méthodes que tu veux sur ton objet
"fonctionnel" sans avoir besoin d'importer le module. Ca permet aussi de séparer
le coté interface du coté fonctionnel: tout ce dont ton objet gui a besoin,
c'est d'un objet qui implémente les méthodes qu'il appelle (ici, la méthode
"give"), sans que gui.py dépende de fct.py, puisqu'il ne l'importe plus jamais.
HTH
--
- Eric Brunel <eric (underscore) brunel (at) despammed (dot) com> -
PragmaDev : Real Time Software Development Tools - http://www.pragmadev.com
Voila, j'ai developpe une interface graphique en python ( sous Linux ). J'ai scinde le code en different modules distinct representant chacun une fenetre de l'interface. Un dernier module est responsable de la gestion des evenements dans l'interface.
Mon probleme est le suivant. Lorsque je lance l'interface, j'importe le module de fonction. Celui-ci ayant besoin de certains elements de l'interface, il importe le module d'interface.
Bilan des operations ca coince. Je ne vois pas comment resoudre ce probleme.
Je vous donne un exemple tres simplifie de ce que j'essais de faire:
Une autre solution, sans doute plus "élégante", serait de réorganiser un peu le module gui, de mettre ta fonction give dans une classe, d'instancier cette classe au démarrage de l'appli et de passer l'instance à l'instance de Gui:
--gui.py-------------------------------------------- from Tkinter import *
class Gui(Tk): def __init__(self, myFct): Tk.__init__(self) self.fct = myFct self.frame = Frame(self) ... # Tout pareil après...
if __name__ == '__main__': fct = Fct() ----------------------------------------------------
et tu lances: python fct.py
Comme ça, tu peux appeler toutes les méthodes que tu veux sur ton objet "fonctionnel" sans avoir besoin d'importer le module. Ca permet aussi de séparer le coté interface du coté fonctionnel: tout ce dont ton objet gui a besoin, c'est d'un objet qui implémente les méthodes qu'il appelle (ici, la méthode "give"), sans que gui.py dépende de fct.py, puisqu'il ne l'importe plus jamais.
HTH -- - Eric Brunel <eric (underscore) brunel (at) despammed (dot) com> - PragmaDev : Real Time Software Development Tools - http://www.pragmadev.com
thinnes.alexandre
Merci pour le coup de main ^_^
Je vais rendre mon code plus elegant je crois. Vu le nombre de fonction que j'ai developpe.
A plus tard. Alexandre
Eric Brunel wrote in message news:<4190860a$0$9813$...
Mamantins wrote:
Bonjour a tous.
Voila, j'ai developpe une interface graphique en python ( sous Linux ). J'ai scinde le code en different modules distinct representant chacun une fenetre de l'interface. Un dernier module est responsable de la gestion des evenements dans l'interface.
Mon probleme est le suivant. Lorsque je lance l'interface, j'importe le module de fonction. Celui-ci ayant besoin de certains elements de l'interface, il importe le module d'interface.
Bilan des operations ca coince. Je ne vois pas comment resoudre ce probleme.
Je vous donne un exemple tres simplifie de ce que j'essais de faire:
Une autre solution, sans doute plus "élégante", serait de réorganiser un peu le module gui, de mettre ta fonction give dans une classe, d'instancier cette classe au démarrage de l'appli et de passer l'instance à l'instance de Gui:
--gui.py-------------------------------------------- from Tkinter import *
class Gui(Tk): def __init__(self, myFct): Tk.__init__(self) self.fct = myFct self.frame = Frame(self) ... # Tout pareil après...
if __name__ == '__main__': fct = Fct() ----------------------------------------------------
et tu lances: python fct.py
Comme ça, tu peux appeler toutes les méthodes que tu veux sur ton objet "fonctionnel" sans avoir besoin d'importer le module. Ca permet aussi de séparer le coté interface du coté fonctionnel: tout ce dont ton objet gui a besoin, c'est d'un objet qui implémente les méthodes qu'il appelle (ici, la méthode "give"), sans que gui.py dépende de fct.py, puisqu'il ne l'importe plus jamais.
HTH
Merci pour le coup de main ^_^
Je vais rendre mon code plus elegant je crois.
Vu le nombre de fonction que j'ai developpe.
A plus tard.
Alexandre
Eric Brunel <eric_brunel@despammed.com> wrote in message news:<4190860a$0$9813$8fcfb975@news.wanadoo.fr>...
Mamantins wrote:
Bonjour a tous.
Voila, j'ai developpe une interface graphique en python ( sous Linux
).
J'ai scinde le code en different modules distinct representant chacun
une fenetre de l'interface.
Un dernier module est responsable de la gestion des evenements dans
l'interface.
Mon probleme est le suivant.
Lorsque je lance l'interface, j'importe le module de fonction.
Celui-ci ayant besoin de certains elements de l'interface, il importe
le module d'interface.
Bilan des operations ca coince.
Je ne vois pas comment resoudre ce probleme.
Je vous donne un exemple tres simplifie de ce que j'essais de faire:
Une autre solution, sans doute plus "élégante", serait de réorganiser un peu le
module gui, de mettre ta fonction give dans une classe, d'instancier cette
classe au démarrage de l'appli et de passer l'instance à l'instance de Gui:
--gui.py--------------------------------------------
from Tkinter import *
class Gui(Tk):
def __init__(self, myFct):
Tk.__init__(self)
self.fct = myFct
self.frame = Frame(self)
... # Tout pareil après...
if __name__ == '__main__':
fct = Fct()
----------------------------------------------------
et tu lances:
python fct.py
Comme ça, tu peux appeler toutes les méthodes que tu veux sur ton objet
"fonctionnel" sans avoir besoin d'importer le module. Ca permet aussi de séparer
le coté interface du coté fonctionnel: tout ce dont ton objet gui a besoin,
c'est d'un objet qui implémente les méthodes qu'il appelle (ici, la méthode
"give"), sans que gui.py dépende de fct.py, puisqu'il ne l'importe plus jamais.
Je vais rendre mon code plus elegant je crois. Vu le nombre de fonction que j'ai developpe.
A plus tard. Alexandre
Eric Brunel wrote in message news:<4190860a$0$9813$...
Mamantins wrote:
Bonjour a tous.
Voila, j'ai developpe une interface graphique en python ( sous Linux ). J'ai scinde le code en different modules distinct representant chacun une fenetre de l'interface. Un dernier module est responsable de la gestion des evenements dans l'interface.
Mon probleme est le suivant. Lorsque je lance l'interface, j'importe le module de fonction. Celui-ci ayant besoin de certains elements de l'interface, il importe le module d'interface.
Bilan des operations ca coince. Je ne vois pas comment resoudre ce probleme.
Je vous donne un exemple tres simplifie de ce que j'essais de faire:
Une autre solution, sans doute plus "élégante", serait de réorganiser un peu le module gui, de mettre ta fonction give dans une classe, d'instancier cette classe au démarrage de l'appli et de passer l'instance à l'instance de Gui:
--gui.py-------------------------------------------- from Tkinter import *
class Gui(Tk): def __init__(self, myFct): Tk.__init__(self) self.fct = myFct self.frame = Frame(self) ... # Tout pareil après...
if __name__ == '__main__': fct = Fct() ----------------------------------------------------
et tu lances: python fct.py
Comme ça, tu peux appeler toutes les méthodes que tu veux sur ton objet "fonctionnel" sans avoir besoin d'importer le module. Ca permet aussi de séparer le coté interface du coté fonctionnel: tout ce dont ton objet gui a besoin, c'est d'un objet qui implémente les méthodes qu'il appelle (ici, la méthode "give"), sans que gui.py dépende de fct.py, puisqu'il ne l'importe plus jamais.