Discussion :

[scalpel]

Bonjour à tous.tes,

Suite à vos retours très formateurs sur mon exercice précédent, je me suis employé à mettre en application tous vos conseils dans l'exercice suivant.
Je ne vais pas vous envoyer tous mes exercices, mais il est important pour moi de vous partager celui-ci afin de savoir si je prends la bonne orientation.

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
# révolutions de mercure et venus autour du soleil
# imports
from tkinter import Tk, Canvas
from math import sin, cos, pi
 
# fonctions
def revolution(nom, x1, y1, angle, pas, dec, coul, taille, memx1=245, memy1=154, incrangle=5):
    'révolution astre'
    memx1,  memy1 = x1, y1
    if angle < 360 : angle += incrangle
    else : angle = 5    
    radian = angle * (2*pi) / 360
    x1, y1 = x1 + pas * cos(radian), y1 + pas * sin(radian)
    can.itemconfigure(nom, fill = coul)
    can.coords(nom, x1, y1 + dec, x1 + taille, y1 + dec + taille)
    fen.after(100, revolution, nom, x1, y1, angle, pas, dec, coul, taille, memx1, memy1, incrangle)
 
# programme principal    
fen = Tk()  # racine des widgets
 
# widgets
can=Canvas(fen, bg = 'black', height = 500, width = 500)
can.pack()
 
for i in range(3):
    globals()['astre' + str(i)] = can.create_oval(205, 205, 295, 295, fill = 'yellow')  # création des 3 astres
 
revolution(astre1, 245, 145, 5, 8, 0, 'grey', 30)        # lance la révolution de mercure
revolution(astre2, 245, 145, 5, 16, -95 ,'orange', 40)   # Lance la révolution de venus
 
# réceptionnaire d'événements
fen.mainloop()

[wiztricks]

Salut,

S'appliquer a ne pas utiliser de variables globales jusqu'à pousser à l'extrême avec:

Code :

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

1
2
for i in range(3):
    globals()['astre' + str(i)] = can.create_oval(205, 205, 295, 295, fill = 'yellow')  # création des 3 astres

ou (apparemment) les derniers paramètres de la fonction revolution... n'a de sens que par jeu...

Par contre, côte programmation, vous n'avez toujours pas compris comment utiliser une liste comme collection:

Code :

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

1
2
3
4
5
6
7
balles = []
for i in range(3):
    iid = can.create_oval(205, 205, 295, 295, fill = 'yellow') 
    balles.append(iid)
 
revolution(balles[1], 245, 145, 5, 8, 0, 'grey', 30)        # lance la révolution de mercure
revolution(balles[2], 245, 145, 5, 16, -95 ,'orange', 40)

Et nombreux vous ont suggéré d'avancer côté constructions de vos propres classes...

- W

[scalpel]

... S'appliquer a ne pas utiliser de variables globales jusqu'à pousser à l'extrême avec: ...

C'était pour économiser deux répétitions, c'est d'autant plus ridicule, que je n'ai pas vraiment compris comment cela fonctionne.
J'ai reproduit un bout de code que j'ai croisé dans un exemple.

... ou (apparemment) les derniers paramètres de la fonction revolution... n'a de sens que par jeu...

Ce sont ceux qui mont causés le plus de difficultés à mettre en place, sinon je n'arrivait pas à manipuler les deux astres avec la même fonction.
Sans ces paramètres, l'incrémentation des angles et des coordonnées était commune aux deux astres en mouvements.

... Par contre, côte programmation, vous n'avez toujours pas compris comment utiliser une liste comme collection: ...

Tu peux m'en dire un peu plus, je ne vois pas ou une liste aurait un intérêt dans mon bout de code.

... Et nombreux vous ont suggéré d'avancer côté constructions de vos propres classes...

Tu veux dire qui faut que j'arrête de "patiner" sur les exercices et que j'avance dans le cours ?


Merci beaucoup pour l'ensemble ces retours. 👍

[fred1599]

Bonjour,

L'utilisation de globals() pour créer dynamiquement des variables n'est pas une pratique recommandée car elle rend le code moins lisible et plus difficile à déboguer. Il est préférable d'utiliser des structures de données comme les listes ou les dictionnaires pour gérer des collections d'objets similaires.

La fonction revolution est assez complexe avec un grand nombre de paramètres. Simplifier cette fonction pourrait rendre le code plus lisible.

Une proposition de 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
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
from tkinter import Tk, Canvas
from math import sin, cos, pi
 
COULEUR_SOLEIL = 'yellow'
COULEUR_MERCURE = 'grey'
COULEUR_VENUS = 'orange'
 
TAILLE_SOLEIL = 50
TAILLE_MERCURE = 10
TAILLE_VENUS = 20
 
DISTANCE_MERCURE = 40
DISTANCE_VENUS = 70
 
CANVAS_WIDTH = 500
CANVAS_HEIGHT = 500
CENTRE_X = CANVAS_WIDTH // 2
CENTRE_Y = CANVAS_HEIGHT // 2
 
def revolution(id_astre, angle, distance, taille, incrangle=5):
    """Révolution d'un astre"""
    angle += incrangle % 360
    radian = angle * (2 * pi) / 360
    x = CENTRE_X + distance * cos(radian)
    y = CENTRE_Y + distance * sin(radian)
    can.coords(id_astre, x - taille / 2, y - taille / 2, x + taille / 2, y + taille / 2)
    fen.after(100, revolution, id_astre, angle, distance, taille, incrangle)
 
def creer_et_revolutionner_astre(couleur, taille, distance):
    id_astre = can.create_oval(0, 0, taille, taille, fill=couleur)
    revolution(id_astre, 0, distance, taille)
 
fen = Tk()
can = Canvas(fen, bg='black', height=CANVAS_HEIGHT, width=CANVAS_WIDTH)
can.pack()
 
# Création du Soleil
can.create_oval(CENTRE_X - TAILLE_SOLEIL / 2, CENTRE_Y - TAILLE_SOLEIL / 2, 
                CENTRE_X + TAILLE_SOLEIL / 2, CENTRE_Y + TAILLE_SOLEIL / 2, fill=COULEUR_SOLEIL)
 
# Création et révolution des astres
creer_et_revolutionner_astre(COULEUR_MERCURE, TAILLE_MERCURE, DISTANCE_MERCURE)
creer_et_revolutionner_astre(COULEUR_VENUS, TAILLE_VENUS, DISTANCE_VENUS)
 
fen.mainloop()

J'ai retiré les nombres magiques qui nuisent à la lisibilité en utilisant les constantes.

La fonction creer_et_revolutionner_astre encapsule la création d'un astre et l'initiation de sa révolution, rendant le code plus lisible et facile à comprendre.
La fonction revolution reçoit maintenant des paramètres clairement définis pour chaque astre, réduisant la complexité et améliorant la lisibilité.

[Sve@r]

Bonjour

Tu peux m'en dire un peu plus, je ne vois pas ou une liste aurait un intérêt dans mon bout de code.

Hé bien voilà (je vais critiquer mais je vais tenter de le faire avec diplomatie car en réalité j'aime bien ce que tu écris)
Tu as utilisé globals() pour tenter de simuler un tableau, en écrivant globals()["astre %d" % i]=truc et en faisant varier "i" pour avoir au final un code équivalent à astre1=xxx; astre2=yyy; ....
C'est très ingénieux, mais justement c'est là qu'un tableau est utile.
Compare...

Code python :

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

1
2
for i in range(5):
	globals()["var%d"]="Hello %d" % i

vs

Code python :

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

1
2
3
var=list()
for i in range(5):
	var.append("Hello %d" % i)

Certes le code avec tableaux est plus long d'une ligne mais ensuite, pour le traiter, tu gagnes énormément. Exemple

Code python :

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

1
2
for i in range(5):
	print(globals()["var%d"])

vs

Code python :

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

1
2
for v in var:
	print(v)

Quelque part je suis sûr que tu verras rapidement les inconvénients de ta façon de faire, super ingénieuse je ne dis pas (perso j'ai mis un paquet d'années avant de découvrir globals()) mais où cette ingéniosoté pourrait se sublimer si tu prenais un peu le temps de réfléchir aux tableaux (aux listes) et à leur façon de les utiliser. En résumé dès que tu as "n" éléments de même nature à traiter séquentiellement il te faut immédiatement penser liste (ou tuple quand tu les connaitras).

Et pour la ligne en plus, quand tu auras vu les listes en intension...var=list("Hello %d" % i for i in range(5)).

Et quand tu auras appris les objets, tu créeras un objet "planete" contenant tous les attributs associés à une planète (position, nom, caractéristiques etc) et au lieu de passer 50 paramètres à ta fonction tu lui passeras simplement "une" planète.

Tu vas voir, tout un monde va s'ouvrir à toi avec Python mais il te faut te concentrer sur les fondamentaux (listes, tuples, dictonnaires).

C'est d'autant plus ridicule, que je n'ai pas vraiment compris comment cela fonctionne.

Une variable est créée dans un espace de noms (les noms des variables) et cet espace est accessible via la fonction globals(). Cette fonction te retourne un dictionnaire où la clef est le nom de la variable et la valeur est la valeur de la variable. Ainsi écrire nom="Alfred" crée une variable "nom" contenant la string "Alfred" tu peux retrouve cette variable et sa valeur dans globals()["nom"].
Et ça marche aussi dans l'autre sens => rajouter une nouvelle clef au dictionnaire produit le même résultat que créer réellement la variable. Ainsi on peut aussi écrire à la place globals()["nom"]="Alfred".

[scalpel]

... Une proposition de code ...

Merci beaucoup pour cette proposition, elle me permet d'identifier clairement mes erreurs d'analyse.

J'ai mis 3 jours pour terminer mon exercice, je pense que tu as du mettre moins de 30 minutes.

... je vais critiquer mais je vais tenter de le faire avec diplomatie ...

Tes "critiques" sont toujours pour moi très constructives.
Je lis ce retour avec beaucoup d'intérêt, mais il va falloir que je le fasse une dizaine de fois pour être sur de bien tout comprendre et ne rien louper.

[wiztricks]

Tu peux m'en dire un peu plus, je ne vois pas ou une liste aurait un intérêt dans mon bout de code.

C'est bien le problème!
Vous fabriquez une collection d'objets semblables: a1, a2, a3,...

Qu'est ce qui matérialise la collection là dedans?
Des variables où un indice est collé à un préfixe.

N balles => N variables.... et autant de fonction revolution "en vol" qui réalisent la relation "est associé à un état de la balle K".

Ces relations entre... sont réalisées par le code, via de l'implicite.

Pas de problème: ça marche... mais si on secoue le code, on risque de casser cette relation implicite et passer pas mal de temps à mettre au point de petits changements. C'est la raison pour laquelle on s'applique à séparer code et données: fabriquer plus robuste.

Avoir une relation plus explicite suppose associer les paramètres/valeurs/attributs de la K^ième au K^ième item d'une liste. Et comme il peut y avoir plusieurs paramètres, soit on a K listes soit on a K entrées par liste.

Après il faut apprendre à simplifier votre code en réduisant les données à l'essentiel.
Une planète, c'est la distance au soleil et un rayon.

Dans un modèle simplifié, ce qui bouge entre les instants T et T+1, c'est l'angle.
Si je dis qu'a l'instant 0, l'angle est 0, je sais placer ma planète connaissant (ds, angle) ou ds est la distance au soleil en calculant: x = ds*cos(angle), y = ds*sin(angle).

Si j'intègre toutes ces remarques dans le code, j'obtiens:

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
37
38
39
40
41
42
43
44
45
# révolutions de mercure et venus autour du soleil
# imports
from tkinter import Tk, Canvas
 
import math
from math import sin, cos, pi
 
INCRANGLE = 5
 
angles = [ math.radians(a) for a in range(0, 360+5, 5) ]
cossin = [ (cos(r), sin(r)) for r in angles ]
 
# fonctions
def revolution(balles, index = 0):
    'révolution astre'
 
    if index >= len(cossin):
        index = 0
 
    for i in range(1, len(balles)):
        iid, ds, r = balles[i]
        x, y = ds * cossin[index][0], ds * cossin[index][1]
        can.coords(iid, x - r, y - r, x + r, y + r)
 
    fen.after(100, revolution, balles, index+1)
 
# programme principal    
fen = Tk()  # racine des widgets
 
# widgets
can=Canvas(fen, bg = 'black', height = 500, width = 500, scrollregion=(-250, -250, 250, 250))
can.pack()
 
balles = []
for i, (color, ds, r) in enumerate(
            [('yellow', 0, 45), 
             ('grey', 60, 5), 
             ('orange', 200, 15) ]):
    iid = can.create_oval(ds - r, -r, ds + r, r, fill = color)  # création des 3 astres
    balles.append([iid, ds, r])
 
revolution(balles)
 
# réceptionnaire d'événements
fen.mainloop()

Et vous voyez que "simplifier" est une approche du problème sur plusieurs directions.

- W

[scalpel]

... Avoir une relation plus explicite suppose associer les paramètres/valeurs/attributs de la K^ième au K^ième item d'une liste. Et comme il peut y avoir plusieurs paramètres, soit on a K listes soit on a K entrées par liste...

Ce n'est pas évident de digérer tout ceci, mais là je pense avoir compris l'intérêt des listes.

Après il faut apprendre à simplifier votre code en réduisant les données à l'essentiel.
Une planète, c'est la distance au soleil et un rayon.

J'espère être plus à mon aise dans la partie "manipulation des fichiers", car en plus d'être une "bille" en programmation, je le suis également en géométrie.

[Sve@r]

Je me suis inspiré du code de wiztricks pour faire évoluer l'idée
Celle-ci intègre la durée de révolution d'une planète autour du soleil

Code python :

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
37
38
39
40
41
42
43
44
45
46
47
# révolutions de planètes autour du soleil
# imports
from tkinter import Tk, Canvas
 
import math
from math import sin, cos, pi
 
# fonctions
def revolution(balles, index = 0):
	'révolution astre'
 
	for (iid, ds, r, cossin) in balles:
		if cossin is None: continue
		idx=index%len(cossin)
		(x, y) = (ds * cossin[idx][0], ds * cossin[idx][1])
		can.coords(iid, x - r, y - r, x + r, y + r)
	# for
 
	fen.after(100, revolution, balles, index+1)
# for
 
# programme principal	
fen = Tk()  # racine des widgets
 
# widgets
can=Canvas(fen, bg = 'black', height = 500, width = 500, scrollregion=(-250, -250, 250, 250))
can.pack()
 
balles = []
for (color, ds, rayon, revol) in (
	('yellow', 0, 45, 0), 
	('grey', 60, 5, 18), 
	('orange', 200, 15, 40),
	('blue', 250, 18, 60),
):
	iid = can.create_oval(ds - rayon, -rayon, ds + rayon, rayon, fill = color)  # création d'un astre
	if revol:
		angles = tuple(math.radians(i) for i in range(0, 360, 360//revol))
		cossin = tuple((cos(r), sin(r)) for r in angles)
	else: cossin = None
	balles.append((iid, ds, rayon, cossin))
# for
 
revolution(balles)
 
# réceptionnaire d'événements
fen.mainloop()

[scalpel]

Je pense que cette fois-ci la réponse va être moins "diplomatique", mais tant pis je lâche ma question.

... Tu as utilisé globals() pour tenter de simuler un tableau, en écrivant globals()["astre %d" % i]=truc et en faisant varier "i" pour avoir au final un code équivalent à astre1=xxx; astre2=yyy; ....
C'est très ingénieux, mais justement c'est là qu'un tableau est utile.
Compare...

Je suis convaincu de l'intérêt de passer par des listes ou des tableaux, mais je ne comprends pas comment les utiliser pour stocker le type d'information dont j'ai besoins pour déclarer mes vidgets.
Pour remplacer ceci :

Code :

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

1
2
3
 
for i in range(3):
        globals()['astre' + str(i)] = can.create_oval(205, 205, 295, 295, fill = 'yellow')

Je me doute que cela ne fonctionnera pas :

Code :

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

1
2
3
4
 
listeAstres=list()
for i in range(3):
    listeAstres.append('astre' + str(i) + ' = can.create_oval(205, 205, 295, 295, fill = \'yellow\')')

Pour le moment, je n'ai appris à les utiliser que de cette façon.

C'est là que je constate qu'il me manque les bases

[scalpel]

Je me suis inspiré du code de wiztricks pour faire évoluer l'idée
Celle-ci intègre la durée de révolution d'une planète autour du soleil

Avec aussi peu de code c'est bluffant, je vais essayer de comprendre le fonctionnement.

Quand je vois le niveau des intervenants dans mes sujets, j'espère mes questions ridicules ne vous font pas perdre votre temps.
Je vous assure, ça me met la pression, je passe plus de temps et d'énergie à comprendre vos réponses qu'a faire mes exercices.

Mais je progresse et "je m'éclate".

[Sve@r]

Je me doute que cela ne fonctionnera pas :

Code :

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

listeAstres.append('astre' + str(i) + ' = can.create_oval(205, 205, 295, 295, fill = \'yellow\')')

Le "i" ne sert qu'à compter, il ne sert pas pour "ajouter" un élément. D'ailleurs certains codeurs utilisent for _ in ... pour montrer que cette variable sans nom n'a pas de but autre que faire exister la boucle.

Et pour ton instruction: listeAstres.append(can.create_oval(205, 205, 295, 295, fill = 'yellow')). Avec la liste nommée "listeAstres" tu n'as plus besoin de variable "astre1", "astre2" etc.

Avec aussi peu de code c'est bluffant

Tout est dans les listes (enfin dans mon cas les tuples qui ne sont que des listes non modifiables donc plus économiques)... et dans l'unpacking (pouvoir écrire par exemple (x, y, z)=iterable de 3 valeurs et récupérer alors chaque valeur dans chaque variable x, y et z).

[papajoker]

bonjour

mais là je pense avoir compris l'intérêt des listes.

Pas que des listes

Cette notion n'est pas liée à python : c'est un automatisme que l'on retrouve dans tous langages. C'est de l'algorithmie (de la logique de base pour tout programmeur).

Dès que nous avons (pouvons avoir) plusieurs variables avec la même fonctionnalité, nous les regroupons toujours dans une famille. Cette famille est en terme générique un conteneur, un tableau, un ensemble. Tu utilises le mot que tu désires en fonction de ton image mentale, tes acquis précédents.

Python, lui, a quelques structures qui peuvent faire ce travail : les listes, tuples, dictionnaires, ensembles et autres. Ici, au niveau de python, la différence n'est pas évidente mais la raison d'être est toujours la même : regrouper des variables (en générique : des éléments) très proches.

Note: en python, par convention, on nomme ces variables en ajoutant un s (fichiers, planetes, personnes, boutons, ...) donc nous repérons tout de suite la nature de cette variable (générique: un conteneur, un tableau). Et rien que par son nom, nous connaissons la nature des éléments à l'intérieur

Dès que nous pouvons avoir plusieurs variables, nous créons ce conteneur. Ce qui nous permet une énorme souplesse par la suite :
- quelle planete dans cet "ensemble" est la plus proche du soleil
- quelle planete dans cet "ensemble" est la plus proche de la terre
...
- affecter une couleur a toutes les planetes, à tous les boutons ...
...

Avec cette structure, notre code sera le même quel que soit le nombre d'éléments à l'intérieur. 0..1 ou 1..5000, cela ne change rien pour nous. Nous avons donc un code plus propre et beaucoup plus évolutif.

C'est pourquoi les listes, tuples, dictionnaires sont la base dans python : puisque nous les utilisons sans arrêt.

[wiztricks]

Je me doute que cela ne fonctionnera pas :

Code :

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

1
2
3
4
 
listeAstres=list()
for i in range(3):
    listeAstres.append('astre' + str(i) + ' = can.create_oval(205, 205, 295, 295, fill = \'yellow\')')

Il faut partir de l'intention.

Si on crée une liste astres, c'est pour remplacer les variables astre1, astre2, astre3,... par les items d'un tableau/liste astres[1], astres[2], astres[3],....
Du coup, inutile de fabriquer la chaine de caractères 'astre' + str(i) qui servaient à fabriquer les variables astre1, astre2, astre3 en les ajoutant comme clefs dans le dictionnaire globals().

Et pour ce faire, on crée un item du Canvas pour en récupérer l'identifiant que l'on pourra stocker dans une liste.
Ce sont 2 opérations/instructions:

Code :

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

1
2
      iid = can.create_oval(205, 205, 295, 295, fill = 'yellow')
      listeAstres.append(iid)

on peut écrire ça en une ligne:

Code :

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

      listeAstres.append(can.create_oval(205, 205, 295, 295, fill = 'yellow'))

Et on itère sur ces 2 instructions pour créer des disques et stocker leurs identifiants.

- W

[scalpel]

Merci 👍

Code :

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

1
2
3
4
5
6
astres = list()
for i in range(3) :
    astres.append(can.create_oval(205, 205, 295, 295, fill = 'yellow')) 
 
revolution(astres[1], 245, 145, 5, 8, 0, 'grey', 30)        # lance la révolution de mercure
revolution(astres[2], 245, 145, 5, 16, -95 ,'orange', 40)   # Lance la révolution de venus

Une belle famille "atres" et avec un s pour la repérer.

J'ai mis du temps à comprendre

[scalpel]

... Je me suis inspiré du code de wiztricks pour faire évoluer l'idée ...

Je me suis mis ce code de cotés pour plus tard, car pour le moment je ne parviens pas à comprendre.

Je sent pourtant bien qu'il y à des choses très très intéressantes, par exemple ceci :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
balles = []
for (color, ds, rayon, revol) in (
	('yellow', 0, 45, 0), 
	('grey', 60, 5, 18), 
	('orange', 200, 15, 40),
	('blue', 250, 18, 60),
):
	iid = can.create_oval(ds - rayon, -rayon, ds + rayon, rayon, fill = color)  # création d'un astre
	if revol:
		angles = tuple(math.radians(i) for i in range(0, 360, 360//revol))
		cossin = tuple((cos(r), sin(r)) for r in angles)
	else: cossin = None
	balles.append((iid, ds, rayon, cossin))

[wiztricks]

J'ai mis du temps à comprendre

Comprendre c'est maîtriser 2 types de difficultés: savoir utiliser une liste *et* identifier une collection de... pouvant être représentée sous forme de liste (ou avec une autre collection si appropriée).
Dit autrement, il y a la pratique du langage et celle de la programmation qui reformule un besoin en collection qui se reformulera en liste ou pas (et qui organise le cheminement entre ces étapes).

Et la 3ième difficulté sera de relire de façon critique votre code.
Si j'écris:

Code :

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

1
2
3
4
5
6
astres = list()
for i in range(3) :
    astres.append(can.create_oval(205, 205, 295, 295, fill = 'yellow')) 
 
revolution(astres[1], 245, 145, 5, 8, 0, 'grey', 30)        # lance la révolution de mercure
revolution(astres[2], 245, 145, 5, 16, -95 ,'orange', 40)   # Lance la révolution de venus

ma liste ne sert qu'à stocker les identifiants retournés par .create_oval.
On peut s'en passer grâce aux fonctionnalités du canvas:

Code :

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

1
2
3
4
5
for i in range(3) :
    can.create_oval(205, 205, 295, 295, fill = 'yellow', tags=('astres', f'astre{i}',)) 
 
revolution('astre1', 245, 145, 5, 8, 0, 'grey', 30)        # lance la révolution de mercure
revolution('astre2', 245, 145, 5, 16, -95 ,'orange', 40)   # Lance la révolution de venus

note: dans mon code, j'utilise une liste pour stocker non seulement l'identifiant mais aussi distance au soleil et rayon du disque. C'est ce qui fait que je peux simplifier les paramètres passés à l'appel de revolution pour illustrer ce que peut vouloir dire association implicite / explicite.

Tout ça pour dire que la programmation est un apprentissage de l'humilité: on comprend sans en savoir jamais assez et condamné à faire avec ce qu'on sait.

- W

[scalpel]

... la programmation est un apprentissage de l'humilité: on comprend sans en savoir jamais assez et condamné à faire avec ce qu'on sait...

Je suis tenté d'utiliser cette maxime comme signature

Merci pour :

Code :

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

can.create_oval(205, 205, 295, 295, fill = 'yellow', tags=('astres', f'astre{i}',))

A quoi sert le f ?

[Arioch]

C'est une f-string

Code :

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

1
2
3
4
>>> year = 2016
>>> event = 'Referendum'
>>> f'Results of the {year} {event}'
'Results of the 2016 Referendum'

[wiztricks]

A quoi sert le f ?

A signaler une opération de formattage de la chaine de caractère où on fabrique une chaine de caractères avec une mixture de constantes et de variables. Ça ne fait rien de plus que: 'astre' + str(i)

- W