Exercices Python
Sites pour apprendre en s’amusant
Rechercher parmi les exercices Python
[searchform post_types= »post » cats= »142″]
Sélectionner les exercices par thème
[mctagmap show_posts= »yes » from_category= »142″ tag_count= »yes »]
Exercices ciblés
Les exercices suivants portent sur des éléments bien précis du langage Python.
Exercices divers
Comptage de lettres
- Écrire une fonction compterLettre(texte, lettre) ayant pour arguments une chaîne de caractères et un caractère et qui renvoie un dictionnaire qui contient la fréquence de la lettres dans la chaîne.
- Écrire une fonction compterLettres(texte) ayant pour argument une chaîne de caractères et qui renvoie un dictionnaire qui contient la fréquence de toutes les lettres de la chaîne entrée.
par exemple, compterLettres("L'informatique, c'est fantastique !") doit renvoyer : {'t': 4, 'n': 2, 'i': 3, ',': 1, 'o': 1, ' ': 3, 'f': 2, 'm': 1, "'": 2, 's': 2, 'L': 1, 'u': 2, 'c': 1, 'r': 1, 'e': 3, '!': 1, 'a': 3, 'q': 2}
[reveal_link heading="%image% Correction" id="id1"]
[reveal heading="noheading" id="id1"]
def compterLettre(texte, lettre): # à faire ! return
def compterLettres(texte):
d = {}
for c in texte:
if c in d.keys():
d[c] += 1
else:
d[c] = 1
return d[/reveal]
Rectangles
Soient deux rectangles définis par des listes de la forme [positionX, positionY, largeur, hauteur] .
- Écrire une fonction intersection() qui à partir de deux rectangles ainsi définis renvoie, s'il existe, le rectangle intersection.
[reveal_link heading="%image% Correction" id="id2"]
[reveal heading="noheading" id="id2"]
def intersection(rect1, rect2):
x1, y1, l1, h1 = rect1
x2, y2, l2, h2 = rect2
x3 = max(x1, x2)
y3 = max(y1, y3)
l3 = max(x1+l1-x2, x2+l2-x1)
h3 = max(y1+h1-y2, y2+h2-y1)
if l3 <0 or h3 < 0:
return
return x3, y3, l3, h3[/reveal]
Cinématique
- Écrire une instruction qui permet de calculer puis afficher la distance d parcourue par un point qui s'est déplacé à vitesse constante v pendant un temps t .
- Améliorer l'affichage pour limiter le résultat à 3 chiffres significatifs, quelles que soient les valeurs de d et t .
La vitesse n'est plus constante. Elle est donnée par une fonction v(t) .
- Écrire un algorithme permettant d'estimer la vitesse parcourue par une méthode d'intégration numérique : méthode des rectangles et méthode des trapèzes.
(voir https://fr.wikipedia.org/wiki/Calcul_numérique_d'une_intégrale)
 méthode des trapèzes |
 méthode des rectangles |
remarque : écrire cet algorithme dans une fonction distance() acceptant comme arguments :
la fonction v() , l'intervalle de temps (t0, t1) pendant lequel estimer la distance parcourue, et la durée dt de l'échantillon de calcul.
[reveal_link heading="%image% Correction" id="id3"]
[reveal heading="noheading" id="id3"]
v = 10.2 # m/s
t = 2.3 # s
d = v*t
print(d)
print(round(d, 3))
# mieux :
print("%.2E" %d)
v = lambda t:t**2 # v(t)
dt = 0.1 # s
t0, t1 = 1, 3 # s
def distance_rect(v, t0, t1, dt):
t = t0
d = 0
while t < t1:
d += dt*(v(t))
t += dt
return d
def distance_trap(v, t0, t1, dt):
t = t0
d = 0
while t < t1-dt:
d += dt*(v(t)+v(t+dt))/2
t += dt
return d
[/reveal]
Recherche dans une liste (séquentielle et dichotomique)
Il est fréquemment nécessaire de rechercher un élément particulier dans une liste (de nombres, de mots, de couleurs, ....).
Soit une liste de nombres réels, classés par ordre croissants :
from random import random l = sorted([random() for i in range(1000)])
L'objectif de l'exercice est d'obtenir l'indice i et la valeur v de l'élément de la liste le plus proche d'un nombre n donné (mais inférieur).
- Écrire un algorithme réalisant ceci par balayage (recherche séquentielle) : par test de tous les éléments de la liste depuis le premier, jusqu'à celui recherché.
[reveal_link heading="%image% Indice" id="id4"]
[reveal heading="noheading" id="id4"]
Indice = 0 Tant que l'élément d'indice Indice < Valeur_recherchée et ...(à compléter)... Incrémenter Indice Élément_recherché = élément d'indice Indice
[/reveal]
- Écrire un algorithme de recherche dichotomique :
On envisage deux types de fonction : une fonction séquentielle et une fonction récursive.
- Comparer les performances de ces 3 solutions à l'aide de méthodes de mesure de performances.
[reveal_link heading="%image% Éléments de Correction" id="id5"]
[reveal heading="noheading" id="id5"]
n = 0.6 # Valeur recherchée
def recherche_seq(n, l):
i = 0
while i < len(l) and ...... :
i += 1
return ... , ...
def recherche_dicho(n, l):
i = 0
j = len(l) - 1
while .... :
m = (i+j) // 2
if n >= l[m]: # la valeur recherchée est "à droite"
......
else:
......
return ... , ...[/reveal]
Rubik’s cube
- Construire un tableau (une liste de listes) représentant la face de ce Rubik's cube :
- Réaliser une fonction tourner_Rubik() opérant une rotation d'un quart de tour (sens trigonométrique) des cases du Rubik'cube.
Suite de Conway
1 11 21 1211 111221 312211 13112221 1113213211 31131211131221 …
"Avez-vous deviné la règle de construction de cette suite ? Le premier terme se compose de un « un », puis le deuxième énonce le premier « un un ». Ce deuxième terme se compose de deux « un », donc le troisième, énonçant le deuxième, est « deux un ». Il est composé de un « deux » et de un « un », et donc est suivi par « un deux un un », et ainsi de suite."
J.H. Conway , The Book of Numbers , Springer-Verlag, 1996
- Écrire une fonction Conway(u_n) acceptant en argument une chaîne de caractères représentant un terme $u_n$ de la suite de Conway et renvoyant le terme $u_{n+1}$.
Correction
Génération de code HTML
- Écrire une fonction qui accepte comme argument un dictionnaire (clefs et valeurs de type chaîne de caractères) et renvoie le code HTML d'un tableau :
<!DOCTYPE html>
<html>
<body>
<table border="1" style="width:100%">
<tr>
<td>Père</td>
<td>Homer</td>
</tr>
<tr>
<td>Mère</td>
<td>Marge</td>
</tr>
<tr>
<td>Fils</td>
<td>Bart</td>
</tr>
</table>
</body>
</html>
|
 |
Correction
7 segments
Écrire une fonction sept_seg() capable de convertir un nombre décimal dans un format pour afficheurs "7 segments".
Par exemple, la chaîne de caractères "23" sera convertie en une chaîne de caractères qui s'affichera comme ceci :
_ _ _| _| |_ _|
Ce qui correspond à la chaîne de caractères : " _ _ \n _| _|\n|_ _|\n"
[reveal_link heading="%image% Correction" id="id6"]
[reveal heading="noheading" id="id6"]
# Solution la plus courte !!! (http://pycontest.net/job)
>>> j=''.join;seven_seg=lambda z:j(j(' _ |_|_ _| |'[-~ord("¤Ž°Ú¬¼hJž"[int(a)])%u:][:3]for a in z)+"\n"for u in(3,14,10))
>>> seven_seg("23")
_ _
_| _|
|_ _|
Mais on doit pouvoir faire plus lisible !! [/reveal]
