Revue de code d'un exercice du Swinnen - E2S1

Version imprimable

Voir 40 message(s) de cette discussion en une page

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:

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

Salut,

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

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:

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

22/02/2024, 09h25
scalpel

Citation:

Envoyé par wiztricks

... 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. :oops:

Citation:

Envoyé par wiztricks

... 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.

Citation:

Envoyé par wiztricks

... 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.

Citation:

Envoyé par wiztricks

... 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. 👍

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:

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é.

22/02/2024, 10h39
Sve@r
Bonjour

Citation:

Envoyé par scalpel

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) :D
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:

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

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:

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

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

Citation:

Envoyé par scalpel

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".
22/02/2024, 11h54
scalpel

Citation:

Envoyé par fred1599

... 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. :hola:

Citation:

Envoyé par Sve@r

... 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. :oops:

Citation:

Envoyé par scalpel

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:

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

22/02/2024, 15h20
scalpel

Citation:

Envoyé par wiztricks

... 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.

Citation:

Envoyé par wiztricks

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. :?

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:

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

22/02/2024, 16h47
scalpel
Je pense que cette fois-ci la réponse va être moins "diplomatique", mais tant pis je lâche ma question. ;)

Citation:

Envoyé par Sve@r

... 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:

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:

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 :oops:
22/02/2024, 16h55
scalpel

Citation:

Envoyé par 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

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. :oops:
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". :ccool:
22/02/2024, 17h49
Sve@r

Citation:

Envoyé par scalpel

Je me doute que cela ne fonctionnera pas :

Code:

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.

Citation:

Envoyé par scalpel

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).
22/02/2024, 18h05
papajoker

bonjour

Citation:

Envoyé par scalpel

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

Pas que des listes :lol:

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.
22/02/2024, 19h27
wiztricks
Citation:
Envoyé par scalpel

Je me doute que cela ne fonctionnera pas :

Code:

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:

1 2 iid = can.create_oval(205, 205, 295, 295, fill = 'yellow') listeAstres.append(iid)
on peut écrire ça en une ligne:

Code:

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

Merci 👍

Code:

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 :oops:

Citation:

Envoyé par Sve@r

... 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:

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

Citation:

Envoyé par scalpel

J'ai mis du temps à comprendre :oops:

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:

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:

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

23/02/2024, 11h17
scalpel

Citation:

Envoyé par wiztricks

... 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 :D

Merci pour :

Code:

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

A quoi sert le f ?

C'est une f-string :D

Code:

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

23/02/2024, 12h18
wiztricks

Citation:

Envoyé par scalpel

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

Voir 40 message(s) de cette discussion en une page