Une sélection d'exercices pour apprendre la programmation Python

Nombre d'auteurs : 6 - Nombre d'exercices : 68 - Dernière mise à jour : 22 janvier 2022

Cette page propose des exercices pour apprendre à programmer en Python.

Ces exercices, accessibles même aux débutants, comprennent des énoncés clairs et complets suivis de solutions détaillées.

Formez-vous gratuitement avec les cours Python, trouvez des réponses à vos questions dans la FAQ Python et posez vos questions sur le forum Python.

Commentez

SommaireInterfaces graphiques (Tkinter)

Anneaux olympiques
Créer une fenêtre avec un canevas
Conversions de températures

Fonctions originales

Fichiers

Anneaux olympiques

Mis à jour le 12 octobre 2021 par Laethy, MPython Alaplancha

Objectif : apprendre à utiliser Tkinter, la bibliothèque graphique la plus utilisée jusqu'à présent en Python.

Niveau de difficulté : intermédiaire

Exercice

a) Créez un court programme qui dessinera les 5 anneaux olympiques dans un rectangle de fond blanc (white). Un bouton « Quitter » doit permettre de fermer la fenêtre.
b) Modifiez le programme ci-dessus en y ajoutant 5 boutons. Chacun de ces boutons provoquera le tracé de chacun des 5 anneaux.

Auteur : Gérard Swinnen

Cours : apprendre à programmer avec Python

Voir une solution

La solution proposée par l'auteur dans son livre Apprendre à programmer en Python 3 est la suivante :

Code python :

Sélectionner tout

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
  
from tkinter import * 
  
# Coordonnées X,Y des 5 anneaux : 
coord = [[20,30], [120,30], [220, 30], [70,80], [170,80]] 
# Couleurs des 5 anneaux : 
coul = ["red", "yellow", "blue", "green", "black"] 
  
base = Tk() 
can = Canvas(base, width =335, height =200, bg ="white") 
can.pack() 
bou = Button(base, text ="Quitter", command =base.quit) 
bou.pack(side = RIGHT) 
# Dessin des 5 anneaux : 
i = 0 
while i < 5: 
  x1, y1 = coord[i][0], coord[i][1] 
  can.create_oval(x1, y1, x1+100, y1 +100, width =2, outline =coul[i]) 
  i = i + 1 
base.mainloop()

Variante proposée par l'auteur :

Code python :

Sélectionner tout

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
from tkinter import * 
  
# Dessin des 5 anneaux : 
def dessineCercle(i): 
  x1, y1 = coord[i][0], coord[i][1] 
  can.create_oval(x1, y1, x1+100, y1 +100, width =2, outline =coul[i]) 
  
def a1(): 
  dessineCercle(0) 
  
def a2(): 
  dessineCercle(1) 
  
def a3(): 
  dessineCercle(2) 
  
def a4(): 
  dessineCercle(3) 
  
def a5(): 
  dessineCercle(4) 
  
# Coordonnées X,Y des 5 anneaux : 
coord = [[20,30], [120,30], [220, 30], [70,80], [170,80]] 
# Couleurs des 5 anneaux : 
coul = ["red", "yellow", "blue", "green", "black"] 
  
base = Tk() 
can = Canvas(base, width =335, height =200, bg ="white") 
can.pack() 
bou = Button(base, text ="Quitter", command =base.quit) 
bou.pack(side = RIGHT) 
  
# Installation des 5 boutons :	   
Button(base, text='1', command = a1).pack(side =LEFT)	  
Button(base, text='2', command = a2).pack(side =LEFT)	  
Button(base, text='3', command = a3).pack(side =LEFT)	  
Button(base, text='4', command = a4).pack(side =LEFT)	  
Button(base, text='5', command = a5).pack(side =LEFT)	  
base.mainloop()

Ce code peut être simplifié en transmettant directement, depuis le bouton, l'argument attendu par la fonction dessineCercle() :

Code python :

Sélectionner tout

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
import tkinter as tk  
  
# Dessin des 5 anneaux :  
def dessineCercle(i):  
  x1, y1 = coord[i][0], coord[i][1]  
  can.create_oval(x1, y1, x1+100, y1 +100, width =2, outline =coul[i])  
  
  
# Coordonnées X,Y des 5 anneaux :  
coord = [[20,30], [120,30], [220, 30], [70,80], [170,80]]  
# Couleurs des 5 anneaux :  
coul = ["red", "yellow", "blue", "green", "black"]  
  
base = tk.Tk()  
can = tk.Canvas(base, width =335, height =200, bg ="white")  
can.pack()  
bouton = tk.Button(base, text ="Quitter", command =base.quit)  
bouton.pack(side = tk.RIGHT)  
  
# Installation des 5 boutons : 
# On utilise la fonction lambda afin de pouvoir passer un argument à la fonction 
for i in range(5): 
    tk.Button(base, text=str(i+1), 
              command = lambda n=i: dessineCercle(n)).pack(side =tk.LEFT)   
base.mainloop()

Créer une fenêtre avec un canevas

Mis à jour le 12 octobre 2021 par Laethy, MPython Alaplancha

Objectif : apprendre à utiliser la bibliothèque Tkinter.

Niveau de difficulté : avancé

Exercice

Écrivez un programme qui fait apparaître une fenêtre avec un canevas. Dans ce canevas, on verra deux cercles (de taille et de couleur différentes), qui sont censés représenter deux astres. Des boutons doivent permettre de les déplacer à volonté tous les deux dans toutes les directions. Sous le canevas, le programme doit afficher en permanence :
a) la distance séparant les deux astres ;
b) la force gravitationnelle qu'ils exercent l'un sur l'autre (pensez à afficher en haut de fenêtre les masses choisies pour chacun d'eux, ainsi que l'échelle des distances).
Dans cet exercice, vous utiliserez évidemment la loi de la gravitation universelle de Newton

Auteur : Gérard Swinnen

Cours : apprendre à programmer avec Python

Voir une solution

La solution proposée par l'auteur dans son livre Apprendre à programmer en Python 3 est la suivante :

Code python :

Sélectionner tout

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
  
# Simulation du phénomène de gravitation universelle 
  
from tkinter import * 
from math import sqrt 
  
def distance(x1, y1, x2, y2): 
  "distance séparant les points x1,y1 et x2,y2" 
  d = sqrt((x2-x1)**2 + (y2-y1)**2)	 # théorème de Pythagore 
  return  d 
  
def forceG(m1, m2, di): 
  "force de gravitation s'exerçant entre m1 et m2 pour une distance di" 
  return m1*m2*6.67e-11/di**2	       # loi de Newton 
  
def avance(n, gd, hb): 
  "déplacement de l'astre n, de gauche à droite ou de haut en bas" 
  global x, y, step 
  # nouvelles coordonnées : 
  x[n], y[n] = x[n] +gd, y[n] +hb 
  # déplacement du dessin dans le canevas : 
  can.coords(astre[n], x[n]-10, y[n]-10, x[n]+10, y[n]+10) 
  # calcul de la nouvelle interdistance : 
  di = distance(x[0], y[0], x[1], y[1]) 
  # conversion de la distance "écran" en distance "astronomique" : 
  diA = di*1e9	     # (1 pixel => 1 million de km)  
  # calcul de la force de gravitation correspondante : 
  f = forceG(m1, m2, diA) 
  # affichage des nouvelles valeurs de distance et force : 
  valDis.configure(text="Distance = " +str(diA) +" m") 
  valFor.configure(text="Force = " +str(f) +" N") 
  # adaptation du "pas" de déplacement en fonction de la distance : 
  step = di/10 
  
def gauche1(): 
  avance(0, -step, 0) 
  
def droite1(): 
  avance(0, step, 0) 
  
def haut1(): 
  avance(0, 0, -step) 
  
def bas1(): 
  avance(0, 0, step) 
  
def gauche2(): 
  avance(1, -step, 0) 
  
def droite2(): 
  avance (1, step, 0) 
  
def haut2(): 
  avance(1, 0, -step) 
  
def bas2(): 
  avance(1, 0, step) 
  
# Masses des deux astres : 
m1 = 6e24      # (valeur de la masse de la terre, en kg) 
m2 = 6e24      #  
astre = [0]*2	   # liste servant à mémoriser les références des dessins 
x =[50., 350.]	    # liste des coord. X de chaque astre (à l'écran) 
y =[100., 100.]    # liste des coord. Y de chaque astre 
step =10      # "pas" de déplacement initial 
  
# Construction de la fenêtre : 
fen = Tk() 
fen.title(' Gravitation universelle suivant Newton') 
# Libellés : 
valM1 = Label(fen, text="M1 = " +str(m1) +" kg") 
valM1.grid(row =1, column =0) 
valM2 = Label(fen, text="M2 = " +str(m2) +" kg") 
valM2.grid(row =1, column =1) 
valDis = Label(fen, text="Distance") 
valDis.grid(row =3, column =0) 
valFor = Label(fen, text="Force") 
valFor.grid(row =3, column =1) 
# Canevas avec le dessin des 2 astres: 
can = Canvas(fen, bg ="light yellow", width =400, height =200) 
can.grid(row =2, column =0, columnspan =2) 
astre[0] = can.create_oval(x[0]-10, y[0]-10, x[0]+10, y[0]+10, 
	     fill ="red", width =1) 
astre[1] = can.create_oval(x[1]-10, y[1]-10, x[1]+10, y[1]+10, 
	     fill ="blue", width =1) 
# 2 groupes de 4 boutons, chacun installé dans un cadre (frame) : 
fra1 = Frame(fen) 
fra1.grid(row =4, column =0, sticky =W, padx =10) 
Button(fra1, text="<-", fg ='red',command =gauche1).pack(side =LEFT) 
Button(fra1, text="->", fg ='red', command =droite1).pack(side =LEFT) 
Button(fra1, text="^", fg ='red', command =haut1).pack(side =LEFT) 
Button(fra1, text="v", fg ='red', command =bas1).pack(side =LEFT) 
fra2 = Frame(fen) 
fra2.grid(row =4, column =1, sticky =E, padx =10) 
Button(fra2, text="<-", fg ='blue', command =gauche2).pack(side =LEFT) 
Button(fra2, text="->", fg ='blue', command =droite2).pack(side =LEFT) 
Button(fra2, text="^", fg ='blue', command =haut2).pack(side =LEFT) 
Button(fra2, text="v", fg ='blue', command =bas2).pack(side =LEFT) 
  
fen.mainloop()

Une amélioration possible du code consiste à déclarer les boutons à l'aide d'une boucle, ainsi que de s'affranchir des fonctions utilisées pour l'envoi des arguments à la fonction avance() en les envoyant directement depuis les boutons.
Pour cela, nous pouvons utiliser les fonctions lambda ou bien partial().
Voici un exemple avec partial() :

Code python :

Sélectionner tout

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
  
# Simulation du phénomène de gravitation universelle  
  
import tkinter as tk  
from math import sqrt  
from functools import partial   
  
def distance(x1, y1, x2, y2):  
  "distance séparant les points x1,y1 et x2,y2"  
  d = sqrt((x2-x1)**2 + (y2-y1)**2)	 # théorème de Pythagore  
  return  d  
  
def forceG(m1, m2, di):  
  "force de gravitation s'exerçant entre m1 et m2 pour une distance di"  
  return m1*m2*6.67e-11/di**2	       # loi de Newton  
  
def avance(n, gd, hb):  
  "déplacement de l'astre n, de gauche à droite ou de haut en bas"  
  global x, y, step  
  # nouvelles coordonnées :  
  x[n], y[n] = x[n] +gd, y[n] +hb  
  # déplacement du dessin dans le canevas :  
  can.coords(astre[n], x[n]-10, y[n]-10, x[n]+10, y[n]+10)  
  # calcul de la nouvelle interdistance :  
  di = distance(x[0], y[0], x[1], y[1])  
  # conversion de la distance "écran" en distance "astronomique" :  
  diA = di*1e9	     # (1 pixel => 1 million de km)   
  # calcul de la force de gravitation correspondante :  
  f = forceG(m1, m2, diA)  
  # affichage des nouvelles valeurs de distance et force :  
  valDis.configure(text=f"Distance = {diA}+ m")  
  valFor.configure(text=f"Force = {f}+ N")  
  # adaptation du "pas" de déplacement en fonction de la distance :  
  step = di/10  
  
# Masses des deux astres :  
m1 = 6e24      # (valeur de la masse de la terre, en kg)  
m2 = 6e24      #   
astre = [0]*2	   # liste servant à mémoriser les références des dessins  
x =[50., 350.]	    # liste des coord. X de chaque astre (à l'écran)  
y =[100., 100.]    # liste des coord. Y de chaque astre  
step =10      # "pas" de déplacement initial  
  
# Construction de la fenêtre :  
fen = tk.Tk()  
fen.title(' Gravitation universelle suivant Newton')  
# Libellés :  
valM1 = tk.Label(fen, text=f"M1 = {m1}+ kg")  
valM1.grid(row =1, column =0)  
valM2 = tk.Label(fen, text="M2 = " +str(m2) +" kg")  
valM2.grid(row =1, column =1)  
valDis = tk.Label(fen, text="Distance")  
valDis.grid(row =3, column =0)  
valFor = tk.Label(fen, text="Force")  
valFor.grid(row =3, column =1)  
# Canevas avec le dessin des 2 astres:  
can = tk.Canvas(fen, bg ="light yellow", width =400, height =200)  
can.grid(row =2, column =0, columnspan =2)  
astre[0] = can.create_oval(x[0]-10, y[0]-10, x[0]+10, y[0]+10,  
	     fill ="red", width =1)  
astre[1] = can.create_oval(x[1]-10, y[1]-10, x[1]+10, y[1]+10,  
	     fill ="blue", width =1)  
# 2 groupes de 4 boutons, chacun installé dans un cadre (frame) :  
directions= (("<-", (0, -step, 0)), ("->", (0, step, 0)), 
             ("^", (0, 0, -step)), ("v", (0, 0, step)), 
             ("<-", (1, -step, 0)), ("->",(1, step, 0)), 
             ("^",(1, 0, -step)), ("v",(1,0,step))) 
  
fra1 = tk.Frame(fen)  
fra1.grid(row =4, column =0, sticky="w", padx=10) 
for t in directions[:4]: 
  tk.Button(fra1, text=t[0], fg ='red', 
         command =partial(avance,*t[1])).pack(side=tk.LEFT)  
  
fra2 = tk.Frame(fen)  
fra2.grid(row =4, column =1, sticky ="e", padx =10) 
for t in directions[4:]: 
  tk.Button(fra2, text=t[0], fg ='blue', 
         command =partial(avance,*t[1])).pack(side=tk.LEFT) 
  
fen.mainloop()

Variante avec utilisation d'un dictionnaire :

Code python :

Sélectionner tout

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
  
# Simulation du phénomène de gravitation universelle  
from functools import partial   
import tkinter as tk  
from math import sqrt  
  
def distance(x1, y1, x2, y2):  
  "distance séparant les points x1,y1 et x2,y2"  
  d = sqrt((x2-x1)**2 + (y2-y1)**2)	 # théorème de Pythagore  
  return  d  
  
def forceG(m1, m2, di):  
  "force de gravitation s'exerçant entre m1 et m2 pour une distance di"  
  return m1*m2*6.67e-11/di**2	       # loi de Newton  
  
def avance(n, gd, hb):  
  "déplacement de l'astre n, de gauche à droite ou de haut en bas"  
  global x, y, step  
  # nouvelles coordonnées :  
  x[n], y[n] = x[n] +gd, y[n] +hb  
  # déplacement du dessin dans le canevas :  
  can.coords(astre[n], x[n]-10, y[n]-10, x[n]+10, y[n]+10)  
  # calcul de la nouvelle interdistance :  
  di = distance(x[0], y[0], x[1], y[1])  
  # conversion de la distance "écran" en distance "astronomique" :  
  diA = di*1e9	     # (1 pixel => 1 million de km)   
  # calcul de la force de gravitation correspondante :  
  f = forceG(m1, m2, diA)  
  # affichage des nouvelles valeurs de distance et force :  
  valDis.configure(text=f"Distance = {diA}+ m")  
  valFor.configure(text=f"Force = {f}+ N")  
  # adaptation du "pas" de déplacement en fonction de la distance :  
  step = di/10  
  
# Masses des deux astres :  
m1 = 6e24      # (valeur de la masse de la terre, en kg)  
m2 = 6e24      #   
astre = [0]*2	   # liste servant à mémoriser les références des dessins  
x =[50., 350.]	    # liste des coord. X de chaque astre (à l'écran)  
y =[100., 100.]    # liste des coord. Y de chaque astre  
step =10      # "pas" de déplacement initial  
  
# Construction de la fenêtre :  
fen = tk.Tk()  
fen.title(' Gravitation universelle suivant Newton')  
# Libellés :  
valM1 = tk.Label(fen, text=f"M1 = {m1}+ kg")  
valM1.grid(row =1, column =0)  
valM2 = tk.Label(fen, text="M2 = " +str(m2) +" kg")  
valM2.grid(row =1, column =1)  
valDis = tk.Label(fen, text="Distance")  
valDis.grid(row =3, column =0)  
valFor = tk.Label(fen, text="Force")  
valFor.grid(row =3, column =1)  
# Canevas avec le dessin des 2 astres:  
can = tk.Canvas(fen, bg ="light yellow", width =400, height =200)  
can.grid(row =2, column =0, columnspan =2)  
astre[0] = can.create_oval(x[0]-10, y[0]-10, x[0]+10, y[0]+10,  
	     fill ="red", width =1)  
astre[1] = can.create_oval(x[1]-10, y[1]-10, x[1]+10, y[1]+10,  
	     fill ="blue", width =1)  
# 2 groupes de 4 boutons, chacun installé dans un cadre (frame) :  
directions = {"<-": (0, -step, 0), "->": (0, step, 0), 
              "^": (0, 0, -step), "v": (0, 0, step)} 
  
fra1 = tk.Frame(fen)  
fra1.grid(row =4, column =0, sticky="w", padx=10) 
for name in directions: 
  tk.Button(fra1, text=name, fg ='red', 
             command =partial(avance,*directions[name])).pack(side=tk.LEFT)  
  
directions = {"<-": (1, -step, 0), "->": (1, step, 0), 
              "^": (1, 0, -step), "v": (1,0,step)} 
fra2 = tk.Frame(fen)  
fra2.grid(row =4, column =1, sticky ="e", padx =10) 
for name in directions: 
  tk.Button(fra2, text=name, fg ='blue', 
             command =partial(avance,*directions[name])).pack(side=tk.LEFT)  
  
fen.mainloop()

Conversions de températures

Mis à jour le 12 octobre 2021 par Laethy, MPython Alaplancha

Objectif : manipuler la bibliothèque Tkinter

Niveau de difficulté : intermédiaire

Exercice

Écrivez un petit programme qui fait apparaitre une fenêtre avec deux champs : l'un indique une température en degrés Celsius, et l'autre la même température exprimée en degrés Fahrenheit. Chaque fois que l'on change une quelconque des deux températures, l'autre est corrigée en conséquence. Pour convertir les degrés Fahrenheit en Celsius et vice-versa, on utilise la formule TF=TC * 1,80 + 32 (cf. cours de Physique générale). Revoyez aussi le petit programme concernant la calculatrice simplifiée.

Auteur : Gérard Swinnen

Cours : apprendre à programmer avec Python

Voir une solution

Fonctions originales

Fichiers

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2024 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.