Problème de boucle infinie

Version imprimable

Bonjour,

python 2.6 / Win7 / Pyscripter

Je souhaite faire tourner une boucle infinie dans mon application et récuperer des valeurs dans un fichier Txt. Je vous apporte une version edulcorer de mon code.
L'ennui, c'est que mon application plante au bout d'un certain nombre de boucle.
Au début, je pensais que cela pouvait provenir de ma fonction "EcrireDansFichier()". Mais non, car si je neutralise l'accès à cette fonction, j'observe le même phénomène. Curieusement, je n'ai aucun message d'erreur provenant de Pyscriter...
Le plantage m'est indiqué par le gestionnaire des tâches... qui me dit que mon application ne répond plus :cry:
Le nombre de boucle n'est pas constant, je ne comprends pas d'où ça peut provenir. A priori, j'ai pas l'impression d'avoir réinventer l'eau tiède avec mon code ^^
Si quelqu'un à une explication à me fournir, je suis preneur.
Merci pour vos réponses

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
#!/usr/bin/python
# -*- coding: iso-8859-15 -*-
 
import wx
 
class Bonjour(wx.Frame):
    def __init__(self, titre):
        wx.Frame.__init__(self, None,-1, title = titre, size = (200, 100))
        conteneur = wx.Panel(self,-1, size = self.GetClientSize())
        etiquette = wx.StaticText(conteneur,-1, "Bonjour tout le monde !",
                                   style = wx.ALIGN_CENTRE)
        etiquette.CentreOnParent()
 
class MonApp(wx.App):
    def OnInit(self):
        fen = Bonjour("Exemple 1")
        fen.Show(True)
        self.SetTopWindow(fen)
 
        Nbre_Partie = 0
        Game_en_cours = []
 
        while True: # Boucle infini
           Nbre_Partie = Nbre_Partie + 1
           Game_en_cours = Game(Nbre_Partie)
 
        return True
 
###---------------------------------------------------------------------------------------------
def Game(Nbre_Partie):
###---------------------------------------------------------------------------------------------
 
    # Initialisation
    Partie_en_cours = []
 
    FichierDebugPartie = '/Fichier_Debug_Partie.txt'
 
##---------------à Supprimer après Debug -----------------------------------------------------------------------------------
    EcrireDansFichier(FichierDebugPartie, "\n\n---------------------------------------------------------------------------")
    EcrireDansFichier(FichierDebugPartie, "-----  Nbre_Partie :  " + str(Nbre_Partie) + " ---------------------------------------------------")
    EcrireDansFichier(FichierDebugPartie, "---------------------------------------------------------------------------")
##---------------à Supprimer après Debug -----------------------------------------------------------------------------------
 
    return Partie_en_cours[:]
 
 
###-------------------------------------------------------------------------
def EcrireDansFichier(nomF1, ligne1):
    """     Ecrit "ligne" dans le Fichier "nomF" """
###-------------------------------------------------------------------------
    of1 = open(nomF1, 'a')
    of1.write(ligne1 + '\n')
    of1.close()
 
app = MonApp()
app.MainLoop()

24/06/2011, 13h50
kango

bonjour,

en mettant une boucle infinie dans ton code de cette façon, tu ne rends jamais la main à la boucle infinie chargée de générer les événements et les repaints dans ton interface graphique.

tu peux soit t'affranchir de ta boucle infinie, soit si tu en as absolument besoin, la basculer dans un thread (dans ce cas pense à ajouter un time.sleep(petite valeur non nulle) pour que le thread rende correctement la main).
24/06/2011, 15h39
PauseKawa

Bonjour,

Plutôt que time.sleep (bloquant) utilisez wx.CallLater pour répéter une fonction.

@+
24/06/2011, 16h24
Yachas

Merci pour vos réponses.
J'ai cherché des renseignements sur les tread, voir un tuto pour le naïf que je suis... afin de comprendre de quoi on parle, là....
J'avoue être un peu perdu... Pas un seul tuto parle de la même façon d'aborder les choses. Si vous avez une URL en français :ccool:
Pour résumer :
Soit j'utilise un tread pour remplacer ma boucle ?!?
Soit j'abandonne l'idée d'une boucle infinie ?!?

Euhhh ... Et comment je fais moi ?!?

arf... Pas trouvé wxCallLater non plus dans la Doc de wx :mouarf:
24/06/2011, 17h12
mont29

Bon, alors, si tu connais pas les threads, et n’es pas motivé pour les apprendre, ne t’y lance pas –*c’est un sujet délicat à maîtriser, il faut s’accrocher un peu, au début…

De toute façon, une boucle infinie, t’en as déjà une*: la main loop de wxApp*! Pourquoi ne pas, par exemple, utiliser l’évènement EVT_IDLE, en le “bindant” à un callback (qui fait une seule fois le contenu de ta boucle à chaque fois), direct dans ton objet app*? Comme ça, à chaque fois que la boucle principale se tourne les pouces, elle appelle ta fonction.

Si tu veux une exécution plus régulière, utilise un timer (PyTimer par ex.).
24/06/2011, 17h53
Yachas

Bon.... Ce n'est pas que je ne suis pas motivé pour me frotter aux Tread, c'est que je n'ai rien trouvé de facile à lire. Tous les tutos que j'ai trouvé avaient une manière différente d'aborder le problème.

Mont29, Je n'ai pas compris grand chose à ce que tu dis... :calim2:

l'idée générale de mon application, c'est de travailler en continu pendant que ma machine est en marche.
l'idée d'un tread semble prometteuse, pour ce que j'en ai compris. Cependant, je ne vois pas comment m'affranchir d'une boucle infinie dans le cas qui me préoccupe.
j'ai compris que j'ai une boucle infinie principale : la main loop de wxApp
Et que je lui impose une autre boucle infinie supplémentaire (Ligne 23) : while True: # Boucle infini
d'où conflit...
alors, comment utiliser un tread dans ma classe MonApp() ?
mystère et boule de gomme 8O
24/06/2011, 19h28
PauseKawa

Bon,

De toute manière et pour le moment pas de thread en Python (Comprendre GIL) donc lorsque vous utilisez un GUI pensez a utiliser l'existant.

La méthode la plus propre est sans doute celle décrite par wiztricks ici mais cela demande une certaine maîtrise.

La suivante c'est d'utiliser l'existant, soit wx.CallLater/CallAfter (Ce qui est fait dans la première méthode avec l'after de Tk).

@+

Ps: Je n'ai rien contre les threads
24/06/2011, 22h19
wiztricks

Salut,

[quote=PauseKawa;6082829]De toute manière et pour le moment pas de thread en Python (Comprendre GIL) donc lorsque vous utilisez un GUI pensez a utiliser l'existant.[/CODE]

Hum, Python donne accès au mécanisme de threading "offert" par l'OS. GIL 'sérialise' leur exécution et ne permet pas "à priori" de "profiter" de tous les CPU équipant les PC - depuis 2004 -.

Citation:

La méthode la plus propre est sans doute celle décrite par wiztricks ici mais cela demande une certaine maîtrise.

Ce truc date un peu. :( et n'est nécessaire que pour passer du GUI au thread lorsque le traitement va durer "assez" pour perturber les temps de réponse du GUI. Ce qui n'est "à priori" pas le cas lorsqu'on écrit quelques lignes dans un fichier.

Citation:

l'idée générale de mon application, c'est de travailler en continu pendant que ma machine est en marche.
l'idée d'un tread semble prometteuse, pour ce que j'en ai compris. Cependant, je ne vois pas comment m'affranchir d'une boucle infinie dans le cas qui me préoccupe.

Fastoche: boucle infinie = pas la main pendant que l'ordi boulotte dans son coin et "reboot" pour en sortir. Et comme ce n'est pas ce que vous voulez, vous êtes "affranchi".
Ce que vous voulez c'est une tache répétitive: toutes les x secondes (x décimal), vous écrivez votre fichier... et l'ennui d'avoir un GUI qui ne vous permet pas d'attendre x secondes avec 'sleep' comme vous pourriez le faire en "mode console".

Les wx.CallLater/CallAfter suggérés par PauseKawa sont justement les fonctions qui permettront de remplacer le sleep...

Cordialement,
- W
25/06/2011, 12h05
PauseKawa

Bonjour,

Citation:

Envoyé par wiztricks

Citation:

Envoyé par PauseKawa

De toute manière et pour le moment pas de thread en Python (Comprendre GIL) donc lorsque vous utilisez un GUI pensez a utiliser l'existant.

Hum, Python donne accès au mécanisme de threading "offert" par l'OS. GIL 'sérialise' leur exécution et ne permet pas "à priori" de "profiter" de tous les CPU équipant les PC - depuis 2004 -.

Merci pour la précision wiztricks, ma phrase pouvait prêter à confusion.

Bonjour,
Voilà où m'ont menées mes tribulations en matière de Tread :mrgreen:
J'ai essayé de me servir de vos conseils éclairés. Je fournie dans la foulée le fruit de mes cogitations, si cela peut peut être servir à quelqu'un ^^
Ce n'est sans doute pas un modèle de codage, mais ça a le mérite de répondre à ma demande.

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
#!/usr/bin/python
# -*- coding: iso-8859-15 -*-
 
import wx
import threading
import time
 
#classe qui défini notre thread
class MyThread (threading.Thread):
	#methode qui initialise la classe
	def __init__ (self):
                 self.ouvert = True
                 self.Nbre_Partie = 0
 
                 threading.Thread.__init__(self)
 
	#methode principale du thread
	def run(self):
             #ici on declare la fonction qui va etre executee par le thread.
             while self.ouvert : # Boucle infini
                 # Initialisation
                 Partie_en_cours = []
                 self.Nbre_Partie = self.Nbre_Partie + 1
                 FichierDebugPartie = '/Fichier_Debug_Partie.txt'
 
##---------------à Supprimer après Debug -----------------------------------------------------------------------------------
                 EcrireDansFichier1(FichierDebugPartie, "\n\n---------------------------------------------------------------------------")
                 EcrireDansFichier1(FichierDebugPartie, "-----  Nbre_Partie :  " + str(self.Nbre_Partie) + " ---------------------------------------------------")
                 EcrireDansFichier1(FichierDebugPartie, "---------------------------------------------------------------------------")
##---------------à Supprimer après Debug -----------------------------------------------------------------------------------
 
class Bonjour(wx.Frame):
    def __init__(self, titre):
        wx.Frame.__init__(self, None,-1, title = titre, size = (200, 100))
        conteneur = wx.Panel(self,-1, size = self.GetClientSize())
        etiquette = wx.StaticText(conteneur,-1, "Bonjour tout le monde !",
                                   style = wx.ALIGN_CENTRE)
        etiquette.CentreOnParent()
 
 
class MonApp(wx.App):
    def OnInit(self):
 
        #creation de notre thread
        Game = MyThread()
        Game.start()
 
        fen = Bonjour("Exemple 1")
        fen.Show(True)
        self.SetTopWindow(fen)
 
        return True
 
###-------------------------------------------------------------------------
def EcrireDansFichier1(nomF1, ligne1):
    """     Ecrit "ligne" dans le Fichier "nomF" """
###-------------------------------------------------------------------------
    of1 = open(nomF1, 'a')
    of1.write(ligne1 + '\n')
    of1.close()
 
app = MonApp()
app.MainLoop()

Et donc, 2 petites questions...

je n'ai pas très bien compris intérêt d'un time.sleep(), en tout cas, mon code fonctionne sans...

De même, pour l'usage d'un wx.CallLater/CallAfter, je n'ai pas très bien compris l'utilisation d'une telle méthode et à quoi cela pourrait me servir .

si quelqu'un peut m'apporter quelques éclaircissements, merci d'avance
Et si cette même personne peut me le montrer dans mon code et me l'expliquer :mouarf:
merci d'avance

Bonjour,

Un petit exemple sur votre code (sans doute nul, je ne pratique pas wx)

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
#!/usr/bin/python
# -*- coding: iso-8859-15 -*-
#
#
import wx
 
 
class Bonjour(wx.Frame):
    def __init__(self, titre):
        wx.Frame.__init__(self, None,-1, title = titre, size = (200, 100))
        conteneur = wx.Panel(self,-1, size = self.GetClientSize())
        etiquette = wx.StaticText(conteneur,-1, "Bonjour tout le monde !",
                                   style = wx.ALIGN_CENTRE)
        etiquette.CentreOnParent()
 
 
class MonApp(wx.App):
    def OnInit(self):
        fen = Bonjour("Exemple 1")
        fen.Show(True)
        self.SetTopWindow(fen)
        self.Nbre_Partie = 0
        self.Game_en_cours = []
        wx.CallAfter(self.mafonction)
        return True
 
    def mafonction(self):
        self.Nbre_Partie += 1
        self.Game_en_cours = Game(self.Nbre_Partie)
        wx.CallLater(60, self.mafonction)
 
###---------------------------------------------------------------------------------------------
def Game(Nbre_Partie):
###---------------------------------------------------------------------------------------------
 
    # Initialisation
    Partie_en_cours = []
 
    FichierDebugPartie = 'Fichier_Debug_Partie.txt'
 
##---------------à Supprimer après Debug -----------------------------------------------------------------------------------
    EcrireDansFichier(FichierDebugPartie, "\n\n---------------------------------------------------------------------------")
    EcrireDansFichier(FichierDebugPartie, "-----  Nbre_Partie :  " + str(Nbre_Partie) + " ---------------------------------------------------")
    EcrireDansFichier(FichierDebugPartie, "---------------------------------------------------------------------------")
##---------------à Supprimer après Debug -----------------------------------------------------------------------------------
 
    return Partie_en_cours[:]
 
###-------------------------------------------------------------------------
def EcrireDansFichier(nomF1, ligne1):
    """     Ecrit "ligne" dans le Fichier "nomF" """
###-------------------------------------------------------------------------
    with open(nomF1, 'a') as of1:
        of1.write(ligne1 + '\n')
 
app = MonApp()
app.MainLoop()

A vrais dire l'idée c'est d'utiliser le timer du gestionnaire d’événement (mainloop) pour programmer l’exécution d'une fonction.

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
import wx
 
class Frame(wx.Frame):
    def __init__(self):
        wx.Frame.__init__(self, None, title="wx test")
        self.counter = 0
        p = wx.Panel(self)
        self.st = wx.StaticText(p, -1, str(self.counter), (25,25))
        self.timer = wx.Timer(self)
        self.timer.Start(360)
        self.Bind(wx.EVT_TIMER, self.Cycle)
        self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
 
    def OnCloseWindow(self, evt):
        self.timer.Stop()
        del self.timer
        self.Destroy()
 
    def Cycle(self, evt):
        self.counter += 1
        self.st.SetLabel(str(self.counter))
 
app = wx.App(False)
frm = Frame()
frm.Show()
app.MainLoop()

@+

Edit : J'avais mélanger les codes... :oops:

28/06/2011, 08h22
Yachas

Bonjour,
Merci pour ces deux exemples.
Je constate une énorme économie de code et une sacrée simplification ^^
Cependant, après avoir testé les deux applications, je trouve que le code avec wx.CallLater beaucoup moins rapide. Même en jouant sur la variable "60".
28/06/2011, 10h43
mont29

Oui, forcément, wxCallLater (ou sa version sleep() ) n’est pas adaptée si tu as des tâches lourdes à exécuter –*pour cela, pas de miracles, c’est threads (ou même processus, si tu veux bénéficier des procs multi-cores sous python ;) ).

La question est donc de savoir si exécuter une “boucle” toutes les quelques millisecondes te suffit, ou s’il t’en faut plusieurs milliers (ou plus) par seconde*! :D