Script et programme

Identification

Infoforall

5 - Créer un programme en Python


Nous avons vu comment stocker des informations dans des variables.

Nous allons voir comment stocker les instructions dans un programme. Cela nous évitera d'avoir à retaper des instructions que nous avons déjà exécuté à chaque fois qu'on veut refaire la même chose.

En fin d'activité, vous parviendrez à créer une interface graphique qui ressemble à cela par exemple :

Logiciel nécessaire pour l'activité : Thonny

Evaluation ✎ : question 08-09-12

Résumé : Version HTML ou fond blanc ou ou PDF (couleur ou gris)

1 - Créer un script

Nous allons maintenant voir comment programmer et enregistrer plutôt que d'exécuter immédiatement le code dans la console. Nous allons commencer par utiliser Thonny. Néanmoins, un simple éditeur de texte suffit.

Nous allons donc aujourd'hui travailler dans la zone du haut : celle qui permet de créer des scripts.

Nous allons créer au début un petit programme qui ne fait que 2 choses :

  1. Créer une variable a et y mémoriser 200
  2. Créer une variable b et y mémoriser le double de a, soit 400

01° Copier/coller le code suivant dans la zone du haut de Thonny, celle permettant de créer le script (celle sans les trois chevrons ):

1 2
a = 200 b = a * 2
Attention

Vous allez enregistrer votre programme en lui donnant un nom. N'utilisez pas le nom d'un des modules Python qui existent déjà : turtle, random... Sinon, vous ne pourriez plus utiliser turtle.

02° Utiliser FILE - SAVE AS pour enregistrer le fichier (que vous nommerez acti_programme.py) dans un dossier que vous parviendrez à retrouver facilement. Le mieux est donc de le mettre dans votre dossier personnel.

03° Exécuter le programme en utilisant la flèche verte RUN ou le menu RUN - RUN CURRENT SCRIPT ou la touche F5.

Si ce n'est pas fait, visualiser les variables à l'aide du menu VIEW-VARIABLES.

Vous devriez constater qu'on a bien créé deux variables a et b contenant 200 et 400.

Vous devriez donc voir ceci s'afficher dans Thonny : la console de Thonny est vide !

>>> %Run acti_programme.py >>>

Actions à réaliser : vous pourriez visualiser le contenu des variables en demandant gentimment via la console :

>>> a 200 >>> b 400

On retrouve donc bien l'histoire de la séquentialité des instructions.

C'est comme si vous aviez tapé ceci dans la console SAUF que si vous voulez refaire pareil, il suffit de réappuyer sur la flèche verte pour relancer le script.

1 2 3
a = 200 b = a * 2 fin du programme

CLIQUEZ ICI POUR VOIR LE DEROULEMENT :

Déroulement séquentiel

Comme on peut le voir, le programme se déroule séquentiellement : une ligne à la fois, en partant de la ligne du haut et en se dirigeant vers le bas. L'ordinateur va donc évaluer et exécuter une ligne à la fois.

2 - Mode pas à pas

Thonny permet d'observer la séquence d'exécution : il suffit de cliquer sur le bouton à droite de run, DEBUG CURRENT SCRIPT ou d'utiliser le menu RUN DEBUG CURRENT SCRIPT ou CTRL+F5. Vous pourrez alors voir le déroulé du script.

Avec la nouvelle version de Thonny, vous pouvez choisir la première des possiblités : DEBUG CURRENT SCRIPT (Nicer).

04° Suivre le déroulé proposé de façon à parvenir à exécuter le programme pas à pas à l'aide de Thonny. Commencez par lancer le mode pas à pas en utilisant la flèche à droite de la flèche du RUN.

La ligne en jaune correspond à la prochaine ligne qui va être exécutée.

.

Rien ne s'est passé. C'est normal, nous sommes sur la première ligne mais elle n'est pas encore exécutée.

Il suffit alors de cliquer sur STEP OVER (la flèche vers le bas, celle située encore une position à droite de la précédente) ou d'appuyer sur F6 pour exécuter cette ligne et passer encore à la suivante :

On peut voir qu'on vient de créer la variable a.

En cliquant encore une fois, on réalise alors cette dernière instruction :

Cette fois, on vient de créer la variable b.

Le programme est terminé : aucune ligne de code n'est en attente d'exécution.

Les lignes ont toutes été interprétées à tour de rôle, du haut vers le bas, comme lorsqu'on lit un texte.

05° Réfléchir sur ce que va faire ce programme, pas à pas. Que va afficher ce programme ? a ? b ? c ? Rien ? Tout ? Lancer ensuite le mode DEBUG pour vérifier votre réponse. Activer le panneau VARIABLES pour les voir se créer au fur et à mesure.

1 2 3 4
a = 5 b = 10 c = a + b c

Et voici la correction avec les explications en mode pas à pas. :

Nous voici d'abord sur la première ligne avant qu'elle ne soit interprétée.

Rien de particulier, il ne s'est rien passé, puisque la ligne n'est pas executée.

Une fois  a = 5  executée, on voit apparaître une variable a en mémoire puisqu'on utilise une affectation. Lors d'une affectation, rien ne s'affiche automatiquement.

Une fois  b = 10  executée, on voit apparaître une variable b en mémoire puisqu'on utilise une affectation. Rien ne s'affiche. Normal, c'est juste une affectation.

Nous venons de voir s'exécuter  c = a + b .

La variable  c  contient donc 15, la somme de ce que contiennent  a  et  b  à ce moment précis.

Reste à voir ce que provoque l'exécution de la dernière ligne ne contenant que  c 

Grosse différence avec le cas console-interactive : le fait d'avoir tapé  c  n'a pas d'effet visible : l'interpréteur Python évalue votre expression et n'en fait rien puisque vous ne lui dites pas d'en faire quelque chose !

Différence entre mode interactif et programme

Cas de la console

Si on demande à la console de simplement évaluer quelque chose, elle va afficher par défaut le résultat :

>>> a = 10 >>> b = a + 2
>>> a = 10 >>> b = a + 2 >>> b 12

Cas du programme

1 2 3
a = 10 b = a + 2 b

Si on place ce code dans un programme, il va

  • Ligne 1 : placer la variable a en mémoire,
  • Ligne 2 : évaluer la somme puis placer le résultat dans une variable b,
  • Ligne 3 : évaluer b et... c'est tout. Il l'évalue. Pas d'affichage, rien, nada.
Visualiser une variable créée par un programme

Si vous voulez voir le contenu des variables, vous avez trois possibilités :

  • Pendant l'exécution du programme : une seule possibilité, utiliser la fonction native print.
  • Après l'exécution du prgramme : vous regardez dans l'onglet VARIABLES de Thonny
  • Après l'exécution du programme : vous passez par la console interactive

06° On remarquera qu'à la fin de l'exécution de votre script, les variables restent en mémoire. Utiliser le code suivant dans un programme. Que vaut  c  à la fin du programme à votre avis ? Vérifier et expliquer le résultat.

1 2 3 4
a = 5 b = 10 c = a + b a = 100

...CORRECTION...

c est affectée à 15 sur la ligne 3 à l'aide de la valeur de a à ce moment là.

On change la valeur de a sur la ligne 4. Ok, a change.

Par contre, la variable c reste à 15 : on ne l'affecte pas avec un nouveau résultat. Ce n'est pas parce que a a servi à définir ligne 3 que son changement ligne 4 modifie quoi que ce soit. SEQUENTIALITE.

Attention : dans un script, il faut utiilser la fonction native print si vous voulez forcer l'affichage d'un résultat à destination d'un lecteur humain. Noter juste c ne suffit pas.

Voici le même programme mais avec un affichage final destiné à un humain.

1 2 3 4
a = 5 b = 10 c = a + b print(c)

07° Quelqu'un réalise ce programme là. Il déclare qu'il est plus court que le précédent et fait la même chose puisqu'il affiche la même chose. Expliquez lui pourquoi ce programme ne fait pas la même chose que celui juste au dessus !

1 2 3
a = 5 b = 10 print(a + b)

...CORRECTION...

Ce nouveau programme ne fait pas la même chose : on ne mémorise pas le résultat de l'addition.

On affiche simplement le résultat pour qu'un humain puisse le visualiser. Mais on ne pourra pas continuer à travailler avec ce résultat puisqu'il n'a pas été mémorisé dans une variable.

Utilisation de print en mode Interactif

Nous avions vu que la fonction native print n'avait aucun intérêt lors de l'utilisation de la console interactive, sauf pour visualiser un string qui contient des caractères d'échappement permettant de réaliser des tablulations ou des passages à la ligne.

Moralité : ça je veux bien :

>>> a = "Nom\tPrenom\tAge" >>> print(a) Nom Prenom Age >>> print("Nom\nPrenom\nAge") Nom Prenom Age >>> print("Voilà un antislash \\") Voilà un antislash \

Par contre, jamais du code similaire à ceci dans vos copies s'il vous plait :

>>> a = 5 >>> print(a) 5

En effet, en mode interactif, il suffit d'écrire ceci :

>>> a = 5 >>> a 5
Utilisation de print en mode Script

Lorsqu'on utilise un script Python, le print devra être limité aux cas suivants :

  1. Volonté délibérée du programme d'afficher quelque chose à l'utilisateur humain (le résultat final ou autre)
  2. Affichage temporaire du contenu d'une variable si le programme ne fait pas ce que vous voulez ! On peut alors visualiser des résultats intermédiaires.

Par contre, il est fondamental de comprendre ceci : un print n'enregistre absolument pas le résultat en mémoire. Il s'agit d'un simple affichage qui ne permet pas d'utilisation ultérieure.

Si votre but est de stocker l'information, vous vous trompez d'outil : il faut affecter le résulat à une variable.

3 - Commentaires et mise en forme

L’un des points fondamentaux de la programmation est la clarté : votre code sera certainement un jour utilisé ou modifié par quelqu’un d’autre.

Lorsqu’un programme est simple, pas besoin d’explications. Mais lorsque le code commence à gonfler, on regrette souvent de ne plus savoir pourquoi on a codé ceci ou cela quelques semaines avant… Les commentaires servent à donner des explications sur ce que fait le code ou sur ce que doit contenir telle ou telle variable. Sans commentaire, pas facile de se souvenir du but de certaines lignes de code.

Commentaires dans un code Python

Point important : les commentaires sont destinés à un lecteur humain. L'interpréteur Python ne tentera pas de les exécuter. Si vous lancez Thonny en mode Debug, vous pourrez voir qu'il ne s'arrête absolument pas sur les commentaires.

Pour rajouter un commentaire, on utilise simplement le caractère dièse (#) de façon adaptée :

1 2 3
# Toute cette ligne est un commentaire. print("Bonjour tout le monde") # Ceci est également un commentaire print("Cette ligne ne contient pas de # commentaire")
  • La ligne 1 comporte un commentaire sur toute la ligne.
  • La ligne 2 comporte un commentaire uniquement sur la fin de ligne : l'instruction devant le commentaire sera exécuté.
  • La ligne 3 ne comporte aucun commentaire.

Voici le résultat de ce programme dans la console : il n'affiche pas les commentaires.

>>> %Run progcommentaires.py Bonjour le monde Cette ligne ne contient pas de # commentaire >>>

Pour l'instant, le code se suffit à lui même : inutile de rajouter un commentaire. Retenez qu'un commentaire ne doit pas juste paraphraser le code mais fournir des indications éclairantes sur son fonctionnement.

A titre d'exemple, voici un script :

1 2 3
budget = 78 unite = 8 nombre = budget // unite + 2

On comprend vaguement qu'il fait le calcul de quelque chose...

Exemple d'utilisation correcte de commentaires :

1 2 3 4 5
# budget : le budget disponible en euros budget = 78 # unite : prix à l'unité et en euro d'un paquet de gateaux unite = 8 nombre = budget // unite + 2 # On rajoute 2 paquets achetés pour avoir de la marge, certains mangent beaucoup !

Ici, les commentaires sont utiles car ils donnent des indications non visibles dans le code : prix en euros et explication du +2.

Exemple d'utilisation incorrecte de commentaires :

1 2 3 4 5
# budget contient le budget pour acheter les gateaux budget = 78 # unite contient le prix à l'unité unite = 8 nombre = budget//unite + 2 # Le nombre de paquets à acheter pour la soirée

Ici, les commentaires sont clairement inutiles : ils n'ont rien rajoutés à la compréhension réelle du code. Par exemple, on ne sait pas pourquoi on rajoute 2...

07° A titre d'exercice final, on vous demande de lire le script ci-dessous, d'en comprendre l'exécution ligne par ligne.

Questions

  • Combien contient-il de lignes d'instruction (à comprendre sous le sens "pas une ligne de commentaires ou une ligne vide") ?
  • Noter la valeur finale de nouveau_nombre.

Vérifier en mode debug que votre compréhension était bonne.

1 2 3 4 5 6 7 8 9 10 11 12
# budget contient le budget pour acheter les gateaux budget = 500 # unite : prix à l'unité d'un paquet de gateaux unite = 10.0 # nombre de paquets à acheter pour la soirée, marge de 2 supplémentaires. nombre = budget//unite + 2 budget = 5000 unite = 1.0 nouveau_nombre = nombre * 2 # c'est fini !

...CORRECTION...

6 lignes d'instructions.

On remarque bien d'abord que Thonny ne stoppe pas sur la première ligne, le commentaire mais sur la seconde.

Ensuite :

  1. Ligne 2 : On crée budget en lui affectant 500
  2. Ligne 5 : On crée unite en lui affectant 10.0
  3. Ligne 7 : On crée nombre en lui affectant le résultat de 500//10.0 + 2, évalué à 52.0, un float.
  4. Ligne 9 : On écrase budget en lui affectant 5000
  5. Ligne 10 : On fait de même avec unite en lui affectant 1.0
  6. Ligne 11 : On crée nouveau_nombre en lui nombre * 2 :
    ATTENTION AU 'PIEGE' de l'intuition humaine : nombre n'a pas été recalculée sous prétexte que les variables qui ont servi à le trouver la première fois ont changé ! On garde donc 52.0. On affecte donc 104.0 à cette variable.

✎ 08° Expliquer ce que contient autorisation ci-dessous. La variable recu contient le mot de passe reçu. La variable mdp contient le vrai mot de passe attendu.

1 2 3
recu = "1234" mdp = "12345" autorisation = recu == mdp

✎ 09° Rajouter des commentaires de façon à rendre ce code plus clair pour un débutant.

4 - Structure d'un programme et Interface graphique

Vous avez vu une première interface homme-machine : la console. C'est une interface textuelle puisqu'on ne peut émettre et recevoir que du texte.

Vous avez également vu une première interface graphique à l'aide du module turtle. En réalité, le module turtle est basé lui-même sur le module d'interface graphique intégré de base à Python, tkinter.

Sans rentrer dans les détails, vous allez maintenant manipuler un programme permettant de créer une interface graphique et voir l'importance des variables dans un tel programme plutôt que de tout définir à la main.

Structure d'un programme

Nous allons apprendre cette année à programmer proprement.

Pour cela, il faut déjà connaître la structure attendue d'un programme Python.

  1. On commence toujours par l'importation des modules nécessaires au programme.
  2. On déclare ensuite les CONSTANTES : en Python, il s'agit de variables pour lesquelles on s'engage à ne jamais changer la valeur après la première initialisation. D'où le nom de constantes. Par convention, le nom des CONSTANTES est constitué uniquement de majuscules.
  3. On déclare ensuite les fonctions : nous verrons cette partie dans une autre activité, mais vous avez dû les rencontrer en seconde.
  4. On finit avec les instructions du programme en lui-même : on nomme cette partie "programme principal" parfois.

Regardons à quoi ressemble le code de cette petite interface graphique.

Importation

1 2
# 1 - Importation de modules import tkinter as tk

On importe le module tkinter sous l'alias tk.

Constantes

4 5 6 7 8
# 2 - Constantes FD1 = "#AA00CC" # couleur d'un fond coloré FD2 = "#CC00AA" # autre couleur de fond ECR = "#FFAAFF" # couleur de l'écriture MAXI = 7 # Numéro de la première case à gauche

On déclare 4 constantes contenant les couleurs de fond des cases, la couleur d'écriture dans les cases et le numéro de la case de gauche.

Le programme en lui-même

Il se décompose en trois sous-parties :

  1. la création de la fenêtre graphique en elle-même
  2. 10 11 12 13 14 15 16
    # 3 - Instructions du programme ("programme principal") # --- 3.1 - Choix des caractéristiques de la fenêtre fenetre = tk.Tk() # création de la fenêtre graphique fenetre.geometry("900x300") # dimensions de la fenêtre fenetre.title("Exemple d'application des variables") fenetre.configure(bg="#CCCCCC") # Fond coloré de la fenêtre

    On retrouve la notation avec le point pour indiquer qu'on va agir sur l'objet devant le point.

  3. la création des widgets (gadgets visuels : window gadget) qui vont remplir la fenêtre
  4. 18 19 20 21 22 23
    # --- 3.2 - Création et affichage des widgets num = MAXI # numéro de la case coord_x = 20 # en pixels coord_y = 20 # en pixels w7 = tk.Label(fenetre, text=2**num, fg=ECR, bg=FD1, width=10, height=1+2*num) w7.place(x=coord_x, y=coord_y) # Placement ET affichage

    On commence ici avec un premier widget de type Label : il s'agit d'un carré ou d'un rectangle pouvant contenir du texte ou une image.

    On fixe la variable num à MAXI, soit 7. On définit les deux variables de coordonnées à 20.

    Ensuite, ligne 5 ici, on crée un widget nommé w7 à l'aide de la fonction-constructeur nommée Label. On lui transmet :

    • Qu'il est rattaché à fenetre.
    • Ce qu'il doit afficher text=2**num
    • Avec quelle couleur le texte doit être écrit fg=ECR, fg pour foreground, premier plan.
    • La couleur du fond bg=FD1, bg pour background, premier plan.
    • Sa largeur (en caractères) width=10.
    • Sa hauteur (en nombre de lignes) height=1+2*num.

    Ligne 6, on l'affiche à l'écran en le plaçant à la position correspondant aux coordonnées x et y fournies.

    On trouve encore en dessous d'autres widgets similaires : seules les valeurs changent.

  5. la surveillance de la fenêtre lors du passage en programmation événementielle : tout est défini, on réagit juste aux actions de l'utilisateur.
  6. 40 41
    # --- 3.3 - Passage en mode surveillance des événements sur la fenêtre fenetre.mainloop()
ATTENTION

Le module que nous allons utiliser se nomme tkinter. Il est donc important de ne pas nommer votre programme tkinter.py. Sinon, l'interpréteur Python ne parviendra pas à retrouver le vrai fichier tkinter.py !

10° Placer le programme en mémoire. Lancer.

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
# 1 - Importation de modules import tkinter as tk # 2 - Constantes FD1 = "#AA00CC" # couleur d'un fond coloré FD2 = "#CC00AA" # autre couleur de fond ECR = "#FFAAFF" # couleur de l'écriture MAXI = 7 # Numéro de la première case à gauche # 3 - Instructions du programme ("programme principal") # --- 3.1 - Choix des caractéristiques de la fenêtre fenetre = tk.Tk() # création de la fenêtre graphique fenetre.geometry("900x300") # dimensions de la fenêtre fenetre.title("Exemple d'application des variables") fenetre.configure(bg="#CCCCCC") # Fond coloré de la fenêtre # --- 3.2 - Création et affichage des widgets num = MAXI # numéro de la case coord_x = 20 # en pixels coord_y = 20 # en pixels w7 = tk.Label(fenetre, text=2**num, fg=ECR, bg=FD1, width=10, height=1+2*num) w7.place(x=coord_x, y=coord_y) # Placement ET affichage num = num - 1 coord_x = coord_x + 100 w6 = tk.Label(fenetre, text=2**num, fg=ECR, bg=FD2, width=10, height=1+2*num) w6.place(x=coord_x, y=coord_y) num = num - 1 coord_x = coord_x + 100 # en pixels w5 = tk.Label(fenetre, text=2**num, fg=ECR, bg=FD1, width=10, height=1+2*num) w5.place(x=coord_x, y=coord_y) num = num - 1 coord_x = coord_x + 100 # en pixels w4 = tk.Label(fenetre, text=2**num, fg=ECR, bg=FD2, width=10, height=1+2*num) w4.place(x=coord_x, y=coord_y) # --- 3.3 - Passage en mode surveillance des événements sur la fenêtre fenetre.mainloop()

Questions

    Premier widget

  1. Quelle est la valeur de num sur la ligne 19 ?
  2. Que vaut la hauteur (height) du widget w7 de la ligne 22 ?
  3. Quelles sont les coordonnées de placement (x et x) du widget w7 de la ligne 23 ?
  4. Deuxième widget

  5. Quelle est la valeur de num sur la ligne 25 ?
  6. Que vaut la hauteur (height) du widget w6 de la ligne 27 ?
  7. Quelles sont les coordonnées de placement (x et x) du widget w6 de la ligne 28 ?

...CORRECTION...

    Premier widget

  1. Quelle est la valeur de num sur la ligne 19 ?
  2. num vaut MAXI et donc 7.

  3. Que vaut la hauteur (height) du widget w7 de la ligne 22 ?
  4. On calcule 1+2*num et on obtient donc une hauteur de 15 lignes.

  5. Quelles sont les coordonnées de placement (x et x) du widget w7 de la ligne 23 ?
  6. Elles valent 20 et 20.

    Deuxième widget

  7. Quelle est la valeur de num sur la ligne 25 ?
  8. On soustrait 1, et on obtient donc 6.

  9. Que vaut la hauteur (height) du widget w6 de la ligne 27 ?
  10. On calcule 1+2*num et on obtient donc une hauteur de 13 lignes.

  11. Quelles sont les coordonnées de placement (x et x) du widget w6 de la ligne 28 ?
  12. On rajoute 100 à x. Elles valent donc 120 et 20.

Pourquoi mettre les variables fenetre ou w* en orange plutôt qu'en bleu ? Il s'agit de variables faisant référence à des objets propres à l'interface graphique Tkinter. Cela vous permettra de voir clairement où se trouvent les parties du code propre à tkinter.

11° Compléter le code de façon à obtenir cet affichage :

Il faudrait donc créer les widgets w3 à w0.

...CORRECTION...

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
# 1 - Importation de modules import tkinter as tk # 2 - Constantes FD1 = "#AA00CC" # couleur d'un fond coloré FD2 = "#CC00AA" # autre couleur de fond ECR = "#FFAAFF" # couleur de l'écriture MAXI = 7 # Numéro de la première case à gauche # 3 - Instructions du programme ("programme principal") # --- 3.1 - Choix des caractéristiques de la fenêtre fenetre = tk.Tk() # création de la fenêtre graphique fenetre.geometry("900x300") # dimensions de la fenêtre fenetre.title("Exemple d'application des variables") fenetre.configure(bg="#CCCCCC") # Fond coloré de la fenêtre # --- 3.2 - Création et affichage des widgets num = MAXI # numéro de la case coord_x = 20 # en pixels coord_y = 20 # en pixels w7 = tk.Label(fenetre, text=2**num, fg=ECR, bg=FD1, width=10, height=1+2*num) w7.place(x=coord_x, y=coord_y) # Placement ET affichage num = num - 1 coord_x = coord_x + 100 w6 = tk.Label(fenetre, text=2**num, fg=ECR, bg=FD2, width=10, height=1+2*num) w6.place(x=coord_x, y=coord_y) num = num - 1 coord_x = coord_x + 100 # en pixels w5 = tk.Label(fenetre, text=2**num, fg=ECR, bg=FD1, width=10, height=1+2*num) w5.place(x=coord_x, y=coord_y) num = num - 1 coord_x = coord_x + 100 # en pixels w4 = tk.Label(fenetre, text=2**num, fg=ECR, bg=FD2, width=10, height=1+2*num) w4.place(x=coord_x, y=coord_y) num = num - 1 coord_x = coord_x + 100 # en pixels w3 = tk.Label(fenetre, text=2**num, fg=ECR, bg=FD1, width=10, height=1+2*num) w3.place(x=coord_x, y=coord_y) num = num - 1 coord_x = coord_x + 100 # en pixels w2 = tk.Label(fenetre, text=2**num, fg=ECR, bg=FD2, width=10, height=1+2*num) w2.place(x=coord_x, y=coord_y) num = num - 1 coord_x = coord_x + 100 # en pixels w1 = tk.Label(fenetre, text=2**num, fg=ECR, bg=FD1, width=10, height=1+2*num) w1.place(x=coord_x, y=coord_y) num = num - 1 coord_x = coord_x + 100 # en pixels w0 = tk.Label(fenetre, text=2**num, fg=ECR, bg=FD2, width=10, height=1+2*num) w0.place(x=coord_x, y=coord_y) # --- 3.3 - Passage en mode surveillance des événements sur la fenêtre fenetre.mainloop()

✎ 12° Quelles sont les deux seules lignes à modifier si on désire modifier les couleurs des widgets ?

Faire quelques essais de modification.

5 - FAQ

Et si on veut faire plus de choses avec Tkinter ?

Il existe beaucoup de documentation sur le Web.

Les informations risquent néanmoins d'être encore difficile à comprendre pour le moment.

Sinon, vous trouverez ci-dessous un petit tuto pour faire quelques petites manipulations :

FICHE Tkinter

Maintenant que nous avons vu comment créer un programme, nous allons voir dans les activité suivantes comment parvenir à stocker des informations rentrées au clavier par l'utilisateur et comment répondre différemment en fonction de sa réponse. Il s'agit des conditions exprimées avec un IF (SI en français).

Activité publiée le 28 08 2019
Dernière modification : 16 06 2021
Auteur : ows. h.