Discussion :

[scalpel]

Bonjour à tous.tes,

J'ai pratiquement terminée la partie traitant de "l'utilisation des fenêtres et du graphismes", j'ai surtout terminé mon plus "gros" exercice.
Il fonctionne bien, mais j'aurai aimé avoir votre avis sur la façon dont j'aborde la programmation.
Afin d'essayer pour la suite d'éviter mes probables grosses erreurs d'algorithme.

Serait-il possible que je vous partage mon code (195 lignes), juste pour un survol de celui-ci ?

[wiztricks]

Serait-il possible que je vous partage mon code (195 lignes), juste pour un survol de celui-ci ?

Pourquoi demander la permission?

- W

[fred1599]

oui comme là plupart des services équivalents... mais quel est le problème à partager ce type d'information ?

[fred1599]

Bonjour,

Serait-il possible que je vous partage mon code (195 lignes), juste pour un survol de celui-ci ?

Ce que tu souhaites s'appelle une revue de code dans le métier... Pas de soucis, envoi !

[scalpel]

Parce que je sollicite déjà souvent . Là je ne suis pas chez moi, je vous partage mon code dès demain.
Merci pour votre disponibilité 👍

[Sve@r]

Bonjour

Parce que je sollicite déjà souvent .

Ici on est tous volontaires. Si tu sollicites soit on connait et on te répondra, soit on ne connait pas et on ne te répondra pas. Mais on ne t'enverra pas chier.

[MPython Alaplancha]

Bonjour,

j'ai surtout terminé mon plus "gros" exercice.
Il fonctionne bien,

C'est cool, mes félicitations !

[scalpel]

Encore merci à tous pour votre disponibilité, sans ce forum ce serait pour moi mission impossible.

Voici donc mon exercice :

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
# ======================== Jeux de balles - début de codage le 10/02/2024 - terminé le 17/02/2024 =================================
 
# importe les modules
from tkinter import *
from random import *
 
# ================================================== définition des fonctions =====================================================
 
# === affiche la règle du jeu ===
def regleJeu():
    texteRegle = "Plusieurs balles de couleurs différentes se déplacent au hasard sur le canevas\n\
 à vitesse faible, rebondissent les unes sur les autres et sur les paroies. Le joueur doit\n\
 cliquer sur la balle actuellement Bleue. S'il y arrive, il gagne un point, mais la balle se\n\
 déplace désormais un peu plus vite, elle devient plus petite et change de couleur. Si le\n\
 joueur se trompe de balle il perds 1 points. Le jeux s'arrête après 15 clics et affiche le\n\
 score atteint."
    message = Toplevel(fenetre)
    message.geometry("475x110")
    message.title("Règle du jeu")
    Label(message, text= texteRegle, ).place(x=5,y=5)
 
# === déplacements des 3 balles ===
def boucleDeplacements():
    global x1Balle1, y1Balle1, dxBalle1, dyBalle1, x1Balle2, y1Balle2, dxBalle2, dyBalle2, x1Balle3,\
          y1Balle3, dxBalle3, dyBalle3, vBalles, tBalles, nbrClics, flagClic,countCoul1, countCoul2, countCoul3
 
    boutonRegles['state'] = DISABLED  # statut des boutons
    boutonLancer['state'] = DISABLED
 
    # déplacement de la balle 1
    x1Balle1, y1Balle1 = x1Balle1 + dxBalle1, y1Balle1 + dyBalle1
 
    if len(canevas.find_overlapping(x1Balle1, y1Balle1, x1Balle1 + tBalles, y1Balle1 + tBalles)) > 1 : # rebond sur une autre balle
        x1Balle1, dxBalle1, dyBalle1 = 270, randint(10, 15), randint(10, 15)          
    if x1Balle1 >270:                                                          # rebond sur le bord droit
        x1Balle1, dxBalle1, dyBalle1 = 270, -randint(10, 15), randint(10, 15)
    if y1Balle1 >270:                                                          # rebond sur le bord bas
        y1Balle1, dxBalle1, dyBalle1 = 270, -randint(10, 15), -randint(10, 15) 
    if x1Balle1 <2:                                                            # rebond sur le bord gauche
        x1Balle1, dxBalle1, dyBalle1 = 2, randint(10, 15), -randint(10, 15)   
    if y1Balle1 <2:                                                            # rebond sur le bord haut
        y1Balle1, dxBalle1, dyBalle1 = 2, randint(10, 15), randint(10, 15)
 
    canevas.coords(balle1, x1Balle1, y1Balle1, x1Balle1 + tBalles, y1Balle1 + tBalles)
 
    # déplacement de la balle 2
    x1Balle2, y1Balle2 = x1Balle2 +dxBalle2, y1Balle2 +dyBalle2
 
    if len(canevas.find_overlapping(x1Balle2, y1Balle2, x1Balle2 + tBalles, y1Balle2 + tBalles)) > 1 : # rebond sur une autre balle
        x1Balle2, dxBalle2, dyBalle2 = 270, randint(10, 15), randint(10, 15)  
    if x1Balle2 >270:                                                          # rebond sur le bord droit
        x1Balle2, dxBalle2, dyBalle2 = 270, -randint(10, 15), randint(10, 15)   
    if y1Balle2 >270:                                                          # rebond sur le bord bas 
        y1Balle2, dxBalle2, dyBalle2 = 270, -randint(10, 15), -randint(10, 15)  
    if x1Balle2 <2:                                                            # rebond sur le bord gauche    
        x1Balle2, dxBalle2, dyBalle2 = 2, randint(10, 15), -randint(10, 15)       
    if y1Balle2 <2:                                                            # rebond sur le bord haut   
        y1Balle2, dxBalle2, dyBalle2 = 2, randint(10, 15), randint(10, 15)
    canevas.coords(balle2, x1Balle2, y1Balle2, x1Balle2 + tBalles, y1Balle2 + tBalles)
 
    # déplacement de la balle 3
    x1Balle3, y1Balle3 = x1Balle3 +dxBalle3, y1Balle3 +dyBalle3
 
    if len(canevas.find_overlapping(x1Balle3, y1Balle3, x1Balle3 + tBalles, y1Balle3 + tBalles)) > 1 : # rebond sur une autre balle
        x1Balle3, dxBalle3, dyBalle3 = 270, randint(10, 15), randint(10, 15)  
    if x1Balle3 >270:                                                         # rebond sur le bord droit
        x1Balle3, dxBalle3, dyBalle3 = 270, -randint(10, 15), randint(10, 15)  
    if y1Balle3 >270:                                                         # rebond sur le bord bas 
        y1Balle3, dxBalle3, dyBalle3 = 270, -randint(10, 15), -randint(10, 15) 
    if x1Balle3 <2:                                                           # rebond sur le bord gauche  
        x1Balle3, dxBalle3, dyBalle3 = 2, randint(10, 15), -randint(10, 15)    
    if y1Balle3 <2:                                                           # rebond sur le bord haut
        y1Balle3, dxBalle3, dyBalle3 = 2, randint(10, 15), randint(10, 15)        
    canevas.coords(balle3, x1Balle3, y1Balle3, x1Balle3 + tBalles, y1Balle3 + tBalles)
 
    if nbrClics < 15 :                                  # tests pour terminer le déplacement des 3 balles
        fenetre.after(vBalles,boucleDeplacements)       # multiples exécutions ralenties de la boucle de déplacement
    else :
        tBalles = 30                                    # taille initiale des 3 balles
 
        countCoul1, countCoul2, countCoul3 = 0, 1, 2    # compteurs des couleurs des 3 balles
 
        canevas.itemconfigure(balle1, fill = tablCoul[countCoul1])
        canevas.itemconfigure(balle2, fill = tablCoul[countCoul2])
        canevas.itemconfigure(balle3, fill = tablCoul[countCoul3])
 
        x1Balle1, y1Balle1 = 150, 120   # coordonnées initiales de la balle 1 (initialement bleue)
        x1Balle2, y1Balle2 = 170, 150   # coordonnées initiales de la balle 2 (initialement jaune)
        x1Balle3, y1Balle3 = 130, 150   # coordonnées initiales de la balle 3 (initialement verte)
 
        canevas.coords(balle1, x1Balle1, y1Balle1, x1Balle1 + tBalles, y1Balle1 + tBalles)   # repositionne les 3 balles
        canevas.coords(balle2, x1Balle2, y1Balle2, x1Balle2 + tBalles, y1Balle2 + tBalles)
        canevas.coords(balle3, x1Balle3, y1Balle3, x1Balle3 + tBalles, y1Balle3 + tBalles)
 
        flagClic = 0                    # bloque le clic de sousis avant la relance des balles
 
        boutonRegles['state'] = NORMAL  # statut des boutons
        boutonLancer['state'] = NORMAL
 
# === fait tourner les couleurs des 3 balles ===
def changeCouleur() :
        global countCoul1, countCoul2, countCoul3
 
        if countCoul1 < 2 : countCoul1 = countCoul1 + 1
        else : countCoul1 = 0
        if countCoul2 < 2 : countCoul2 = countCoul2 + 1
        else : countCoul2 = 0
        if countCoul3 < 2 : countCoul3 = countCoul3 + 1
        else : countCoul3 = 0
 
        canevas.itemconfigure(balle1, fill = tablCoul[countCoul1])
        canevas.itemconfigure(balle2, fill = tablCoul[countCoul2])
        canevas.itemconfigure(balle3, fill = tablCoul[countCoul3])
 
# =========================================== définition des gestionnaires d'événements ===========================================
 
# === lance les balles ===
def lanceBalles():
    global flagClic, tBalles, vBalles, nbrClics, nbrClicsMax, bonClics
 
    nbrClics, nbrClicsMax, bonClics = 0, 15, 0  # initialise les clics
    flagClic = 1                                # pour permettre le clic dans le canvas
    vBalles = 300                               # vitesse initiale de délacement des 3 balles
    labelScore.configure(text = 'Score ' + str(bonClics) + '/' + str(nbrClics))   # affiche le score
 
    boucleDeplacements()  # lance la boucle infinie de déplacements des 3 balles
 
# === clic bouton gauche de la souris sur les balles ===
def clicSouris(event) :
    global tBalles, vBalles, x1Balle1, y1Balle1, flagClic, nbrClics, bonClics, affScore 
 
    if flagClic == 1 :                                             # clic autorisé si les 3 balles sont lancées 
        nbrClics = nbrClics + 1                                    # compte le nombre de clics global                                                   
 
        if x1Balle1 < event.x and event.x < x1Balle1 + tBalles :   # clic sur la surface de la balle 1 (initialement bleue)
            if y1Balle1 < event.y and event.y < y1Balle1 + tBalles :
                tBalles = tBalles - 1
                vBalles = vBalles - 30
                fenetre.bell()                                     # emet un son à chaques bons clics
                bonClics = bonClics + 1
                changeCouleur()
        if x1Balle2 < event.x and event.x < x1Balle2 + tBalles :   # clic sur la surface de la balle 2
            if y1Balle2 < event.y and event.y < y1Balle2 + tBalles :
                bonClics = bonClics - 1
        if x1Balle3 < event.x and event.x < x1Balle3 + tBalles :   # clic sur la surface de la balle 3
            if y1Balle3 < event.y and event.y < y1Balle3 + tBalles :
                bonClics = bonClics - 1
 
        labelScore.configure(text = 'Score ' + str(bonClics) + '/' + str(nbrClics))   # affiche le score
 
# ======================================================= Programme principal ===================================================== 
 
tablCoul = ['blue', 'yellow','green']          # tableau des couleurs pour les 3 balles
countCoul1, countCoul2, countCoul3 = 1, 2, 0   # compteurs des couleurs des 3 balles
 
flagClic = 0                                   # commutateur pour ignorer le clic de souris dans le canevas
nbrClics, nbrClicsMax, bonClics = 0, 15, 0     # initialise les clics de souris
affScore = ''                                  # initialise l'affichage du score
 
dxBalle1, dyBalle1 = 5, -10     # direction de déplacement initial de la balle 1 
dxBalle2, dyBalle2 = -5, 5      # direction de déplacement initial de la balle 2
dxBalle3, dyBalle3 = 10, -5     # direction de déplacement initial de la balle 3
 
tBalles = 30                    # taille initiale des balles
vBalles = 300                   # vitesse initiale de délacement des balles
 
x1Balle1, y1Balle1 = 150, 120   # coordonnées initiales de la balle 1 (initialement bleue)
x1Balle2, y1Balle2 = 170, 150   # coordonnées initiales de la balle 2 (initialement jaune)
x1Balle3, y1Balle3 = 130, 150   # coordonnées initiales de la balle 3 (initialement verte)
 
# === création du widget racine ===
fenetre = Tk()
fenetre.title("Jeu de balles - Cliquez sur la balle bleue")
 
# === création des widgets enfants ===
canevas = Canvas(fenetre,bg='dark grey',height=300, width=300)
canevas.pack(side=LEFT)
canevas.bind('<Button-1>', clicSouris)  # détection du clic bouton gauche de la souris dans le canevas
 
balle1 = canevas.create_oval(x1Balle1, y1Balle1, x1Balle1+tBalles, y1Balle1+tBalles, width=1, fill=tablCoul[0])
balle2 = canevas.create_oval(x1Balle2, y1Balle2, x1Balle2+tBalles, y1Balle2+tBalles, width=1, fill=tablCoul[1])
balle3 = canevas.create_oval(x1Balle3, y1Balle3, x1Balle3+tBalles, y1Balle3+tBalles, width=1, fill=tablCoul[2])
 
boutonQuitter = Button(fenetre,text='Quitter', width = 13, command=fenetre.quit)
boutonQuitter.pack(side=BOTTOM)
boutonRegles = Button(fenetre, text='Règle du jeu', width = 13, command=regleJeu)
boutonRegles.pack()
boutonLancer = Button(fenetre, text='Lancez les balles', width = 13, command=lanceBalles)
boutonLancer.pack()
 
labelScore = Label(fenetre, textvariable=affScore)
labelScore.pack()
 
# =========================================== démarrage du réceptionnaire d'événements ============================================
fenetre.mainloop()

[papajoker]

bonjour

votre avis sur la façon dont j'aborde la programmation.

Je peux te répondre facilement sans voir ton code
J'ai été débutant et, les 2 premières années (plus ou moins) ... le code que j'ai pondu un an avant lorsque je le relis est bon pour la poubelle !

C'est en fait une très bonne chose, cela indique que l'on progresse bien.

En ne suivant qu'un seul cours (ton livre), si on n'a pas d'expérience de la programmation avant, il ne devrait avoir, à la sortie du livre, qu'un code très approximatif (pour être très gentil).
A la sortie de son premier livre, on ne maitrise rien, on a juste survolé plein de chose :

----------
j'ai en fait une mauvaise vision de ce type de livre :
Grand débutant, on doit approfondir les bases du langage. C'est déjà énorme à bien se l'approprier. C'est déjà du travail pour quelques mois.

Et uniquement après, on va appendre des technologies (bases de données, Tk, web, dessin, ?). On peut lire/survoler les chapitres pour sa culture "générale", mais c'est une surcharge d'apprentissage énorme si on n'a pas bien acquis les bases. Faire l'impasse au début sur ces "technologies" si on n'en a pas un besoin immédiat me semble beaucoup plus simple.
Par exemple, après des mois de codage python, découvrir sqlite devient un jeu d'enfant, sinon c'est la galère assurée.

Note: Il faudrait que tu nous dises ce que tu comptes faire en python.

probables grosses erreurs d'algorithme

Cela n'est pas lié à python. Il faut avoir un esprit cartésien, analytique, ... (et j'en passe) et être critique sur sa solution. Et l'expérience aide aussi beaucoup, ce n'est donc pas simple pour le débutant. (Vu ta signature, je suppose que tu as des facilités dans ce domaine)

[scalpel]

... Il faudrait que tu nous dises ce que tu comptes faire en python ...

Avant de partir à la retraite, plutôt que d'apprendre à jouer au Bridge, j'ai décidé de me mettre à un langage de programmation.
J'ai choisi le langage "Python", il faut avant tout que l'expérience soit pour moi enrichissante, ludique et satisfaisante.

Grâce au "Swinnen" et aux échanges sur ce forum, l'objectif est parfaitement atteint. Pour le moment, mon seul projet est de parvenir à terminer le cours, sans avoir rien loupé. Plus tard si je me sens suffisamment à mon aise, je me chercherai un véritable projet à développer.

Voila le contexte de ma modeste démarche "Python" et c'est pour ça que j'hésite à trop vous solliciter.

[Sve@r]

Avant de partir à la retraite, plutôt que d'apprendre à jouer au Bridge, j'ai décidé de me mettre à un langage de programmation.

Est-ce ton premier langage de programmation ?

Pour ton exercice soyons franc, il est bourré de défauts mais c'est normal. Par exemple

Code python :

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

1
2
3
4
5
6
if countCoul1 < 2 : countCoul1 = countCoul1 + 1
else : countCoul1 = 0
if countCoul2 < 2 : countCoul2 = countCoul2 + 1
else : countCoul2 = 0
if countCoul3 < 2 : countCoul3 = countCoul3 + 1
else : countCoul3 = 0

3 codes identiques pour 3 éléments similaires, là en général on a un réflexe immédiat: les tableaux

Code :

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

1
2
countCoul=[...]
for i in range(len(countCol)): countCol[i]=(countCol[i] + 1) % 3

Et tout le reste à l'avenant (les balles etc). Ainsi si demain on veut passer à 5 balles on ne change qu'une seule valeur dans le code: le nombre de balles.

C'est humain: on a un truc on veut vite le coder. Mais souvent si on se pose 2mn et qu'on tente de réfléchir en essayant de penser non pas au truc de maintenant mais à comment il pourrait évoluer on gagne en réalité pas mal de temps. Je pense qu'une bonne approche pour écrire un code, s'est de se rappeler qu'il devra aussi être lu.

Une autre astuce: tu écris souvent des trucs ressemblant à ceci

Code python :

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

1
2
3
4
5
def fonctionX(...):
	if flag:
		actionX
		actionY
		actionZ

Ou ceci

Code python :

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

1
2
3
4
5
6
7
for ...
	if truc:
		actionA
	else:
		actionB
		actionC
		actionD

Ca marche. Mais une autre approche pourrait être

Code python :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
def fonctionX(...):
	if not flag: return
	actionX
	actionY
	actionZ
 
for ...
	if truc:
		actionA
		continue
	actionB
	actionC
	actionD

Et ainsi tu gagnes une indentation sur les blocs de traitement complexes (souvent on est gêné par la taille de la ligne donc si on peut gagner à gauche...)

[fred1599]

Hello,

Qu'est-ce qu'une fonction ? On là défini en programmation comme une action, elle est donc nommée par un verbe à l'infinitif.

Je ne crois pas avoir vu de boucle, est-ce lié à la difficulté de les utiliser ?

Je vois aussi beaucoup de fonctions sans paramètre, là aussi on pourrait penser que l'ajout de paramètres dans une fonction te met en difficulté.

La partie algorithmique n'est pas claire, le code est difficilement lisible et on comprend difficilement le pourquoi certaines lignes ont été écrites, en gros dans ta tête tu te comprends... c'est déjà pas mal, mais d'ici 6 mois, quand tu vas relire ton code, pas sûr que cette compréhension reste intacte.

Plus technique, l'utilisation de global une ou deux fois comme rustine, sur un code long ça peut aller, mais plus tu utilises global, plus il est difficile de rendre ton code modifiable pour de futures évolutions ou même trouver une solution à un bug éventuel.

[scalpel]

... Est-ce ton premier langage de programmation ? ...

J’avais déjà tenté l'expérience il y a quelques années d'où mon inscription qui date de 2008. Lors d’une immobilisation physique, durant une petite semaine, j’avais effectué une approche du langage HTML et quelques temps plus tard, deux à trois soirées de PHP. J’avais pour projet de mettre en ligne un site WEB pour un membre de ma famille, mais devant mon incapacité à produire quelque chose d'esthétiquement regardable, j’ai très rapidement abandonné.

... C'est humain: on a un truc on veut vite le coder. Mais souvent si on se pose 2mn et qu'on tente de réfléchir en essayant de penser non pas au truc de maintenant mais à comment il pourrait évoluer on gagne en réalité pas mal de temps...

Je cherche effectivement trop vite à produire ce que j’ai l’impression de venir de comprendre, j’ai le sentiment de ne pas avancer assez vite dans le cours. J’ai pris conscience que mon code était mauvais quand j’ai commencé à m’y perdre et que je me suis retrouvé obligé de modifier ce qui fonctionnait déjà pour pouvoir continuer. J'avais besoins de vos retour pour confirmer ce constat.

... Je ne crois pas avoir vu de boucle, est-ce lié à la difficulté de les utiliser ? Je vois aussi beaucoup de fonctions sans paramètre, là aussi on pourrait penser que l'ajout de paramètres dans une fonction te met en difficulté ...

Avant de vous livrer mon exercice, j’ai tenté de l’optimiser (passer des variables aux fonctions, utiliser des tableaux et des boucles pour éviter les répétitions de lignes de code, …), mais trop tard. Je trouve tellement satisfaisant d'avoir réussit un petit programme qui fonctionne, qu'il est pour moi très difficile d’accepter de le mettre en panne pour optimiser son code.

... l'utilisation de global une ou deux fois comme rustine, sur un code long ça peut aller, mais plus tu utilises global ...

J'aime bien le therme de rustine, car c'est très exactement dans un contexte de dépannage que j'ai utilisé global à profusion.

Merci vraiment pour vos conseils et astuces qui vont m'être très utiles et surtout que je vais être obligé d’appliquer si je veux pouvoir continuer à vous solliciter. .

PS. Encore deux exercices avant de passer à la manipulation des fichiers, je suis très impatient d'en arriver à ce sujet qui sera pour moi plus proche de mon quotidien professionnel.

[MPython Alaplancha]

Je trouve tellement satisfaisant d'avoir réussit un petit programme qui fonctionne, qu'il est pour moi très difficile d’accepter de le mettre en panne pour optimiser son code.

Il y a un super outil qui te permet de travailler en toute quiétude différentes versions d'un code , c'est 'Git'.
N'hésite pas à détruire pour refaire, c'est comme ça qu'on progresse.
Tu pourrais aussi l'améliorer sur certains points. Par exemple, je vois que tes règles du jeu ne s'affichent pas intégralement dans la fenêtre qui lui est dédiée; tu pourrais créer une fonction qui gère les retours à la ligne d'une string, ça peut être un bon exercice...

note: utilise des import explicites...

[scalpel]

... je me contenterai de vous suggérer de refaire cet exercice lorsque vous aurez un peu abordé les notions de "class". ...

Cette notion est abordée dans le paragraphe suivant, je ne devrais donc pas tarder à m'améliorer sur ce point.

... Il y a un super outil qui te permet de travailler en toute quiétude différentes versions d'un code , c'est 'Git'. ...

"Visual Studio Code" me suggérait une extension GIT depuis un petit moment et je n'avais pas compris à quoi elle pouvait bien me servir, je vais me pencher sur le sujet.
Jusqu'à présent j'ai tout simplement utilisé "Google drive" pour sauvegarder mes exercices et les avoir à disposition à tous moments.

[Sve@r]

"Visual Studio Code" me suggérait une extension GIT depuis un petit moment et je n'avais pas compris à quoi elle pouvait bien me servir, je vais me pencher sur le sujet.

Personnellement je ne me lancerais pas là dedans. Déjà ce n'est pas un langage mais un outil donc il ne t'enseignera rien coté algo.
Et ensuite c'est un outil de versionning professionnel. Dans un (relativement) gros projet on peut avoir envie de tester des évolutions donc on va créer des branches X et Y qui vont évoluer pendant plusieurs jours (semaines). Et on peut passer facilement d'une branche à l'autre pour tester (l'outil mémorise les changements et les rejoue à chaque fois). Puis une version convient et on supprime l'autre. Ou rien ne convient et on revient au début.
Donc c'est un outil qui a déjà une certaine complexité je pense peu utile pour un débutant.

Si tu veux t'amuser => https://apprendre-en-ligne.net/turing/...

Jusqu'à présent j'ai tout simplement utilisé "Google drive" pour sauvegarder mes exercices et les avoir à disposition à tous moments.

Mouais. Un simple dossier "exosPython" eût suffit...

[papajoker]

et n'étant pas particulièrement doué, soyez indulgents avec moi.

Oui, code de débutant, mais peut-être "doué" si on le compare à d'autres vrai débutants.

Je cherche effectivement trop vite à produire ce que j’ai l’impression de venir de comprendre, j’ai le sentiment de ne pas avancer assez vite dans le cours.

un livre peut se lire en quelques heures mais, bien comprendre python c'est des mois de pratique. Donc non, tu avances vite et certainement bien trop vite : voir remarques sur ton code qui sont des remarques de bases (tous premiers chapitres).

j’ai tenté de l’optimiser (passer des variables aux fonctions, utiliser des tableaux et des boucles pour éviter les répétitions de lignes de code, …)
...
J'aime bien le therme de rustine, car c'est très exactement dans un contexte de dépannage que j'ai ...

Il ne faut surtout pas parler ici d'optimisation ! Tu cherches juste à faire un bon code Et tu le dis toi-même, appliquer des "rustines" ne va certainement pas arranger les choses.

J’ai pris conscience que mon code était mauvais quand j’ai commencé à m’y perdre et que je me suis retrouvé obligé de modifier ce qui fonctionnait déjà pour pouvoir continuer.

Avant de coder la moindre ligne, on doit faire avant une analyse et déjà avoir un plan (en tête ou par écrit). Un écrivain entame un roman sans la moindre idée de départ ? Sans un plan ?
Les débutants veulent absolument arriver au bout. Une bonne analyse et une stratégie de mise en œuvre est obligatoire, sinon le code a toutes les chances d'être bon pour la poubelle.

il est pour moi très difficile d’accepter de le mettre en panne pour optimiser son code.

Mais il faut penser le contraire !
Tu es dans une démarche pour apprendre et n'as aucune pression. Avec ta démarche actuelle, c'est comme vouloir continuer la construction d'une tour alors que les fondations sont en allumettes... Alors que vouloir repartir de zéro avec une nouvelle stratégie va être justement la meilleure façon de progresser (la seule même).

Il y a un super outil qui te permet de travailler en toute quiétude différentes versions d'un code, c'est 'Git'.

100% d'accord que git (en local) est un outil indispensable. Mais créer une nouvelle branche si c'est pour garder 5..10% du code original, cela n'a pas d'intérêt.

[scalpel]

... Oui, code de débutant, mais peut-être "doué" si on le compare à d'autres vrai débutants ...

Je suis un vieil "informaticien" mais je t'assure que je suis un vrai débutant en développement et je constate que j'en ai pratiquement tous les défauts.
Avant de démarrer l'apprentissage de Python, je n'avais passé que quelques jours sur le sujet dans toute ma carrière.

... Par exemple, après des mois de codage python, découvrir sqlite devient un jeu d'enfant, sinon c'est la galère assurée...

Je suis gêné de te poser cette question : mais que peut-on coder pendant des mois si on ne s'intéresse pas aux sujets abordés dans le "Swinnen" ?

Tu es dans une démarche pour apprendre et n'as aucune pression. Avec ta démarche actuelle, c'est comme vouloir continuer la construction d'une tour alors que les fondations sont en allumettes... Alors que vouloir repartir de zéro avec une nouvelle stratégie va être justement la meilleure façon de progresser (la seule même).

Je lis toutes tes remarques avec beaucoup d'intérêts, mais ce n'est pas évident (même si ce forum est très efficace) de trouver la motivation pour progresser seul dans un apprentissage. Je trouve le "Swinnen" bien fait, il est progressif dans la difficulté et me permet d'avoir une ligne à suivre pour avancer. Mon soucis est lié au fait que dans la mesure ou je parviens à finaliser les exercices, j'ai du mal à ne pas passer immédiatement aux suivants. Je n'ai pas de prof à disposition en permanence pour m'indiquer que je n'ai pas employé la bonne stratégie et je ne peu pas me permettre de vous solliciter tous les soir.

Je peu vous garantir que je vais m'appliquer à suivre scrupuleusement toutes les recommandations qui m'on été faites dans ce post.

[Sve@r]

Je suis gêné de te poser cette question : mais que peut-on coder pendant des mois si on ne s'intéresse pas aux sujets abordés dans le "Swinnen" ?

Oh là là tu n'as pas idée !!!
Regarde ton exercice à 3 ballesavec 3 balles (désolé la blague était trop facile ) qu'il faut attraper et le temps que tu y as passé. Imagine-toi maintenant vouloir coder un agenda, une gestion de comptes bancaires (au pluriel avec possibilité de transfert) ou (pourquoi pas) un outil de téléchargement style Filezilla...
Cet exemple fait 340 lignes et ne fait rien qu'afficher un fichier à l'écran et déjà j'ai mis un paquet de minutes à le coder.

Programmer c'est long !!! Déjà va faire un tour là bas et tente les quelques 10 premiers exercices...

[wiztricks]

Salut,

Vu ce qui a déjà été dit, je me contenterai de vous suggérer de refaire cet exercice lorsque vous aurez un peu abordé les notions de "class". C'est la solution "standard" pour arriver à contrôler l'explosion du nombre de variables (et de listes).

De plus, dans le cas tkinter, beaucoup de fonction sont des "fonctions de rappel"/"callbacks" avec lesquels passage de paramètres et récupération des retours étant quasi impossible, on se retrouve à utiliser des "global" partout. Quand on utilise des méthodes en tant que callback on récupère l'objet et ses attributs sans avoir à passer quoi que ce soit explicitement.

- W