Discussion :

[develuc]

je cherche à tracer deux droites en animation: d'abord l'une puis l'autre. Mais seule la deuxième ligne est tracée. Si je supprime le tracé de la deuxième, il trace bien la première. Impossible de tracer d'abord la première, puis la seconde et d'obtenir deux droites parallèles.
Merci de votre aide.

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
32
from tkinter import *
''' tracer deux lignes horizontales parallèles en animation'''
def anim1():
    global xo,yo,x1,y1,x2,y2,dx,dy,flag
    x1=x1+dx                                    
    if x1>x2:flag=0
    y1=y1+dy
    if y1>y2:flag=0
    can1.create_line(xo,yo,x1,y1)
    if flag>0:
        fen1.after(10,anim1)                            
 
fen1=Tk()                                         # creation du widget principal
fen1.title("essai d'animation")
can1=Canvas(fen1,bg='ivory',height=600,width=800) # widget enfant
can1.pack(side=LEFT)
 
# première ligne
xo,yo=10,10                                      # coordonnées de l'origine
x1,y1=10,10                                      # coordonnées intermédiaires
x2,y2=400,100                                    # coordonnées du point à atteindre
dx,dy,flag=5,0,1                                 # pas du déplacement et commutateur
anim1()
 
# deuxième ligne
xo,yo=10,50
x1,y1=10,50
x2,y2=400,100
dx,dy,flag=5,0,1    
anim1()
 
fen1.mainloop()

[PauseKawa]

Bonjour,

after() n'est pas bloquant pour l'interpréteur donc lorsque vous passez le premier anim1() et que vous sortez de la fonction Python continu à lire le code et vos valeurs (xo etc) sont remplacée par celles de la seconde ligne.
Un simple input entre les deux bloque l'interpréteur (il attend votre entrée) et vous montre que .after() est 'indépendant', comprendre par là que c'est l'interpréteur tcl/tk qui gère les événements.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# première ligne
xo,yo=10,10 # coordonnées de l'origine
x1,y1=10,10 # coordonnées intermédiaires
x2,y2=400,100 # coordonnées du point à atteindre
dx,dy,flag=5,0,1 # pas du déplacement et commutateur
anim1()
#################### ici
v = input()
# deuxième ligne
xo,yo=10,50
x1,y1=10,50
x2,y2=400,100
dx,dy,flag=5,0,1
anim1()

vous devez attendre la fin d'une ligne pour commencer l'autre.

@+

Ps: Pensez à la balise code (# en haut au dessus du texte)

[develuc]

Non, je suis désolé, mais ça ne fonctionne pas. J'obtiens la même chose...

[PauseKawa]

Bonjour,

Non, je suis désolé, mais ça ne fonctionne pas. J'obtiens la même chose...

Sans doute du fait que je ne vous apporte pas une 'solution' mais une 'explication'. Pour la 'solution' j'attendais la votre.
Pour l'explication voici quelques print pour essayer de vous rendre cela plus visuel.

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
32
33
34
35
36
from tkinter import *
 
''' tracer deux lignes horizontales parallèles en animation'''
def anim1():
    global xo, yo, x1, y1, x2, y2, dx, dy, flag
    print(xo, yo, x1, y1) ########################## <
    x1 += dx
    if x1 > x2:
        flag = 0
    y1 += dy
    if y1 > y2:
        flag=0
    can1.create_line(xo, yo, x1, y1)
    if flag > 0:
        fen1.after(10, anim1)
 
fen1=Tk() # creation du widget principal
fen1.title("essai d'animation")
can1=Canvas(fen1, bg='ivory', height=600, width=800) # widget enfant
can1.pack(side=LEFT)
 
 
# première ligne
xo, yo = 10, 10 # coordonnées de l'origine
x1, y1= 10, 10 # coordonnées intermédiaires
x2, y2= 400, 100 # coordonnées du point à atteindre
dx, dy, flag = 5, 0, 1 # pas du déplacement et commutateur
anim1()
print('new line') ########################################### <
# deuxième ligne
xo, yo = 10, 50
x1, y1 = 10, 50
x2, y2 = 400, 100
dx, dy, flag = 5, 0, 1
anim1()
fen1.mainloop()

Sortie

Code :

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

1
2
3
4
5
6
7
8
10 10 10 10
new line
10 50 10 50
10 50 15 50
10 50 20 50
10 50 25 50
10 50 30 50
...

A vous de comprendre avec ce qui est dit plus haut.

Pour la solution, et il en existe pas mal, je pense que je passerais par une liste de liste (vos xo...) ou je traiterais chaque élément avant de le supprimer.

@+

[PauseKawa]

Re,

Je parle de liste de liste pour un traitement séquentiel (Qui le sera de toute manière: Par séquentiel ici comprendre traiter ligne après ligne).
Pour du 'simultané' je passerai par une instance de classe par ligne, ou même plus, une poller_routine avec une visit_method pour le tracé.

@+

[PauseKawa]

Bon, ok: C'est pas cool comme réponse mais je préfère un 'je ne comprend pas' à 'cela ne fonctionne pas'.

Une réponse 'simple' à votre question sur base de liste:

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
from tkinter import *
 
''' tracer deux lignes horizontales parallèles en animation'''
def anim1(l):
    l[2] += l[6]
    l[3] += l[7]
    can1.create_line(l[0], l[1], l[2], l[3])
    if l[2] < l[4] and l[3] < l[5]:
        fen1.after(10, lambda: anim1(l))
 
fen1=Tk() # creation du widget principal
fen1.title("essai d'animation")
can1=Canvas(fen1, bg='ivory', height=600, width=800) # widget enfant
can1.pack(side=LEFT)
anim1([10, 10, 10, 10, 400, 100, 5, 0])
anim1([10, 50, 10, 50, 400, 100, 5, 0])
fen1.mainloop()

@+ et bon 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
from tkinter import *
 
''' tracer deux lignes horizontales parallèles en animation'''
def anim1(l):
    l[2] += l[6]
    l[3] += l[7]
    can1.create_line(l[0], l[1], l[2], l[3])
    if l[2] < l[4] and l[3] < l[5]:
        fen1.after(10, lambda: anim1(l))
 
fen1 = Tk()
fen1.title("essai d'animation")
can1 = Canvas(fen1, bg='ivory', height=600, width=800)
can1.pack(side=LEFT)
for l in ([10, 10, 10, 10, 400, 100, 5, 0], [10, 50, 10, 50, 400, 100, 5, 0]):
    anim1(l)
fen1.mainloop()

[develuc]

Merci pour ces réponses détaillées.
Ok pour 'comprendre' et 'fonctionne'.
J'ai réussi à tracer les deux courbes en même temps comme ce que vous me proposer, tout simplement par une boucle for...next, mais j’apprécie votre façon très élégante d'utiliser une liste.
Mais mon problème n'est pas là:
Je n'arrive pas à tracer les deux lignes L'UNE APRES L'AUTRE.
Il trace le début de la première et aussitôt passe à la seconde, et je ne comprends pas pourquoi!
Si je rajoute, sur vos conseils, une ligne input, il me demande tout de suite l'input AVANT de tracer LES courbes.
Je ne comprends pas pourquoi il ne trace pas la première courbe et me pose ensuite la question?

[develuc]

Ce que je ne comprends pas, c'est ceci:
Dans votre code vous avez deux appels de fonction anim1 en ligne 15 et 16.
Donc le programme lit la première qui lui demande de tracer une droite, puis ENSUITE lit la deuxième qui lui demande de tracer une deuxième droite.
Or il trace les deux ensemble!
Donc, ça , je ne comprends pas pourquoi ni comment!
Si je comprenais ça, je trouverais sans doute une solution à mon problème!

Cordialement

[wiztricks]

Salut,

Dans votre code vous avez deux appels de fonction anim1 en ligne 15 et 16.
Donc le programme lit la première qui lui demande de tracer une droite, puis ENSUITE lit la deuxième qui lui demande de tracer une deuxième droite.
Or il trace les deux ensemble!

Ok, relisez le code:

Code :

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

1
2
for l in ([10, 10, 10, 10, 400, 100, 5, 0], [10, 50, 10, 50, 400, 100, 5, 0]):
    anim1(l)

çà appelle 2 fois anim1 avec des listes différentes...
La magie est dans "anim1":

Code :

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

1
2
3
def anim1(l):
...
        fen1.after(10, lambda: anim1(l))

qui se rappelle lui même tant que le tracé n'est pas terminé.
Comme chaque passage dans anim1 ne fait qu'un petit boût et attend 10ms pour tracer le bout suivant, les tracés se font "en même temps".
- W

[PauseKawa]

Bonsoir,

Maintenant que wiztricks vous a répéter que .after() n'est pas géré par Python si l'on a : l = [[10, 10, 10, 10, 400, 100, 5, 0], [10, 50, 10, 50, 400, 100, 5, 0]] (pour rester dans les listes)
Vous comprendrez que si vous traitez l[x] à chaque fois (l[x][y]) et que lorsque vous en avez fini avec l[x] vous le supprimez (l.pop(x)/l.pop() > (Stacks & Queues)) vous pouvez utiliser votre liste comme file d'attente pour votre animation.

A vous

[wiztricks]

Salut,

Maintenant que wiztricks vous a répéter que .after() n'est pas géré par Python

Etre géré par Python ou d'autres indiens n'a pas grande importance.

L'important est qu'il s'agit d'un "timer".
Son appel va déclencher dans 10 ms un nouvel appel à une "chose".
La "chose" construite par "lambda" est une nouvelle fonction.
Elle est construite à partir d'anim1 et d'une liste de valeurs en paramètres.

Il est certes plus rapide et bien plus précis d'écrire cela ainsi:

Code :

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

1
2
3
def anim1(l):
      ...
      fen1.after(10, lambda: anim1(l))

Je ne suis pas certain qu'on ne puisse pas raconter cela avec une partition musicale, mais c'est pas le bon forum ;-(

- W

[PauseKawa]

Bonsoir,

Je ne suis pas certain qu'on ne puisse pas raconter cela avec une partition musicale, mais c'est pas le bon forum ;-(

En gros oui: La gestion des événements programmés est une partition lue par le(les) gestionnaire(s) d’événement (que cela soit l'interpréteur Python ou Tcl).
J'aime bien cette métaphore (Et cela apporte une touche musicale à mon approche zen attitude de Python).

Le gros problème de develuc c'est ici:

Ce que je ne comprends pas, c'est ceci:
Dans votre code vous avez deux appels de fonction anim1 en ligne 15 et 16.
Donc le programme lit la première qui lui demande de tracer une droite, puis ENSUITE lit la deuxième qui lui demande de tracer une deuxième droite.
Or il trace les deux ensemble!
Donc, ça , je ne comprends pas pourquoi ni comment!
Si je comprenais ça, je trouverais sans doute une solution à mon problème!

Sauf 'blocage' (if, pile comme dit plus haut, etc) le 'code' (dans ce cas, passons outre pour le PO) est lu 'ligne par ligne': Comme vous ne bloquez pas le départ de la seconde ligne le code 'suit son cours'.

J'espère que cela est assez imagé.

@+

[develuc]

Un grand merci à vous deux, et pour les explications, et pour la patience!
Je vais méditer tout cela.

[PauseKawa]

Bonjour,

Un petit coup de pouce basé sur les listes (puisque j'étais parti sur cela).

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
from tkinter import *
 
 
''' tracer deux lignes horizontales parallèles en animation'''
def anim1():
    if l:
        l[0][2] += l[0][6]
        l[0][3] += l[0][7]
        can1.create_line(l[0][0], l[0][1], l[0][2], l[0][3])
        if l[0][2] >= l[0][4] and l[0][3] >= l[0][5]:
            l.pop(0)
        fen1.after(10, anim1)
 
 
fen1 = Tk()
fen1.title("essai d'animation")
can1 = Canvas(fen1, bg='ivory', height=600, width=800)
can1.pack(side=LEFT)
l = [[10, 10, 10, 10, 400, 10, 5, 0], [10, 50, 10, 50, 400, 10, 5, 0],
     [10, 100, 10, 100, 400, 10, 5, 0], [10, 150, 10, 150, 400, 10, 5, 0]]
anim1()
fen1.mainloop()

Comme vous le voyez ici anim1 ne travaille que sur le premier élément (liste[index]) de la liste et le retire (pop(0)) lorsque la condition est atteinte (if l[0][2] >= l[0][4] and l[0][3] >= l[0][5]). Cela tourne jusqu'au moment ou la liste est vide (if l).
Vous noterez la dépendance de la condition au contenu de la liste (...400, 10...) et cela fonctionne ici car nous savons qu'il c'est une incrémentation (>=)

Code :

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

1
2
l = [[10, 10, 10, 10, 400, 10, 5, 0], [10, 50, 10, 50, 400, 10, 5, 0],
     [10, 100, 10, 100, 400, 100, 5, 5], [10, 150, 10, 150, 400, 100, 5, 5]]

Maintenant il est aussi possible d'utiliser lambda pour la condition

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
from tkinter import *
 
 
''' tracer deux lignes horizontales parallèles en animation'''
def anim1():
    if l:
        l[0][2] += l[0][6]
        l[0][3] += l[0][7]
        can1.create_line(l[0][0], l[0][1], l[0][2], l[0][3])
        if cond(l):
            l.pop(0)
        fen1.after(10, anim1)
 
 
fen1 = Tk()
fen1.title("essai d'animation")
can1 = Canvas(fen1, bg='ivory', height=600, width=800)
can1.pack(side=LEFT)
l = [[10, 10, 10, 10, 400, 10, 5, 0], [10, 50, 10, 50, 400, 10, 5, 0],
     [10, 100, 10, 100, 400, 100, 5, 5], [10, 150, 10, 150, 400, 100, 5, 5]]
cond = lambda lst: lst[0][2] >= lst[0][4] and lst[0][3] >= lst[0][5]
anim1()
fen1.mainloop()

A noter:
Je n'utilise pas ici d'arguments pour anim1 car cond et l sont dans son espace de nom global.
Nous travaillons ici sur une même et seule liste l. Pas bien grave puisque seul la fonction anim1 la modifie. Attention si vous utilisez plusieurs fonctions pour un même objet.

Voila pour ce qui est des listes.

@+ et bon code

[develuc]

Je viens, grâce à vous de faire un bond prodigieux dans mes capacités en Python!
Le vieux débutant est très contant!
Merci

[PauseKawa]

Bonsoir,

Dans ce cas puis je vous recommander d'éviter une erreur que j'ai commis en tant qu’autodidacte ? Ne pas suivre un tuto.
Vous allez me dire qu'avec notre expérience (j'ai encore le temps pour la retraite mais je suis bien loin de la période fac ) nous n'en avons pas besoin mais c'est une erreur: Plus que de présenter le langage cela apporte aussi la 'philosophie du langage' (Je suis trop 'zen' ? Je sais.).
Puisque vous partez sur Tkinter je me permet de vous proposer celui de Gérard Swinnen.

Bon code et @+

[develuc]

merci pour vos encouragements.
J'ai 'avalé' le G.Swinnen avec grand plaisir. J'ai démarré Python au début de 2010 et je me régale! J'ai déjà "écrit" de très nombreux scripts et je trouve toujours de quoi me décrasser les méninges!. Mai c'est parfois difficile pour un débutant âgé!.
Merci et A+ avec plaisir.

[PauseKawa]

Mai c'est parfois difficile pour un débutant âgé!.

C'est bien souvent plus dur pour les jeunes

@+ et bon code