TP - Exercices pour débuter
Rappels utiles
Ces exercices doivent être utilisés pour vous entraîner à programmer. Ils sont généralement accompagnés d'aide et de leur solution pour vous permettre de progresser.
Avant de vous précipiter sur ces solutions dès la première difficulté, n'oubliez pas les conseils suivants :
- Avez-vous bien fait un schéma au brouillon pour visualiser le problème posé ?
- Avez-vous essayé de rédiger un algorithme en français, avec vos propres mots, avant de vous lancer dans la programmation sur machine ?
- Avez-vous utilisé des affichages intermédiaires, des
print(), pour visualiser au fur et à mesure le contenu des variables ? - Avez-vous testé le programme avec les propositions de tests donnés dans l'exercice ?
- Avez-vous testé le programme avec de nouveaux tests, différents de ceux proposés ?
Tests du code et main
Le main est le code principal d'un programme. Il ne sera exécuté que si le fichier courant est directement
exécuté. Par exemple, si un fichier contenant un main est importé, ce code ne sera pas exécuté.
Voici un exemple de ce qu'il faut faire :
# Rédigez ici vos fonctions
if __name__ == "__main__":
# Ces lignes permettent d'exécuter les tests présents dans les docstrings
import doctest
doctest.testmod()
# Rédigez ici votre code principal (tests, affichages ...)
Le doctest permet de tester les fonctions en utilisant les tests rédigés dans le docstring, c'est-à-dire le
commentaire situé dans la définition de la fonction.
Important
Toutes les fonctions seront à rédiger dans un unique fichier listes.py !!!
Exercice n°1 : Tests sur les listes
Avant de s'attaquer aux fonctions, testons nos connaissances avec les listes. Pour cela, essayons de réaliser les opérations demandées dans le programme Python ci-dessous :
- Créer une liste vide.
- Ajouter les valeurs 3, 7 et 4 dans la liste.
- Afficher la liste.
Et ensuite :
- Créer une liste contenant les valeurs 6, 2 et 1.
- Supprimer le dernier élément de la liste.
- Afficher la liste.
Et pour finir, il faut concaténer (avec +) et afficher la liste résultat.
Exercice n°2 : Des tuples aux listes
Cet exercice a pour but de montrer la transition tuples → listes.
Rédiger une fonction tuple_to_list(t) qui prend un tuple en paramètre et renvoie une liste contenant les mêmes
éléments que le tuple en entrée, et dans le même ordre.
def tuple_to_list(t):
"""
t - tuple : Tuple à transformer en liste
Sortie : liste de même taille que t, contenant les éléments de t.
>>> tuple_to_list( (1, 6, 3) )
[1, 6, 3]
"""
Une piste ?
Il y a plusieurs méthodes possibles pour réaliser cette fonction.
Une autre piste ?
Une méthode possible est de parcourir tous les éléments du tuple t puis de les ajouter un par un dans une liste.
Comment parcourir un tuple ? Lisez votre cours !
Comment ajouter un élément dans une liste ? Lisez votre cours !
Exercice n°3 : Listes de tests
Cet exercice est important : il va servir de base aux trois exercices qui suivront. Il va permettre d'avoir des listes aléatoires afin de tester les diverses fonctions que nous allons créer.
- Rédiger une fonction
liste_alea(n, p)qui renvoie une liste de n entiers aléatoires choisis entre 1 et p inclus. - Modifier la signature de la fonction pour que les paramètres par défaut soient n=10 et p=100.
- Entrer
print(liste_alea(7, 20))dans le programme principal.
À quelle situation pourrait correspondre la liste ainsi affichée ? - Entrer
print(liste_alea(14, 6))dans le programme principal.
À quelle situation pourrait correspondre la liste ainsi affichée ?
from random import *
def liste_alea(n, p):
"""
n - int : Nombre d'entiers à ajouter dans la liste
p - int : Valeur maximale des entiers dans la liste
Sortie : Liste de n entiers aléatoires pris entre 1 et p inclus.
"""
La signature de la fonction ?
Il s'agit de la toute première ligne qui suit le mot-clef en Python. La signature d'une fonction comprend donc le nom de la fonction, mais aussi ses paramètres. On demande donc ici de réaliser une modification au niveau des paramètres de la fonction.
Une piste ?
On crée une liste vide puis on ajoute des éléments à la fin de cette liste avec la méthode .append().
Une autre piste ?
On génère un nouvel entier aléatoire, on l'ajoute à la liste ; on génère un nouvel entier aléatoire, on l'ajoute à la liste ; etc...
Exercice n°4 : Somme des éléments
Rédiger une fonction somme(liste) qui renvoie la somme des éléments de la liste liste. On admet que les éléments
de liste sont tous numériques (mais pas forcément des entiers...).
def somme(liste):
"""
liste - list : Liste des nombres à additionner
Sortie : Somme des nombres de la listes.
>>> somme([1, 8, 5, 9])
23
"""
Dans le programme principal, utiliser la fonction liste_alea() pour créer une liste
aléatoire de 10 entiers compris entre 1 et 10. Afficher ensuite la somme des termes de cette liste pour tester la
fonction somme().
Un indice ?
Comme vous vous en doutez (si vous ne vous en doutez pas, travaillez vraiment parce que vous avez du retard), il faut parcourir toutes les valeurs de la liste.
Vous pourrez, pour chaque valeur, l'additionner à une même valeur qui sera renvoyée à la fin du programme.
P.S. : La somme des éléments d'une liste vide est 0.
Truc/Astuce (après avoir terminé !!!)
La fonction pré-programmée en Python qui permet d'effectuer cette somme est sum() :
test = liste_alea(10, 10)
print(test)
print(f'La somme des elements de cette liste est {sum(test)}')
Exercice n°5 : Insérer un élément
Concevoir la fonction inserer(liste, position, element) qui renvoie la liste liste dans laquelle l'élément element
a été inséré à l'indice position.
Attention ! Il faut bien vérifier que l'élément peut être inséré. En effet, l'indice donné par position dépasse
peut-être la taille de la liste. Si tel est le cas, il est demandé de renvoyer la valeur None.
def inserer(liste, position, element):
"""
liste - list
position - int : Indice où l'élément doit être inséré
element : Élément quelconque à insérer
Sortie : Une nouvelle liste où l'indice "position" contient la valeur de "element".
>>> inserer([3, 7, 1, 8], 2, -1)
[3, 7, -1, 1, 8]
>>> inserer([9, 5, 1], 5, 8)
None
>>> inserer([], 0, 3)
[3]
"""
Dans le programme principal, utiliser la fonction liste_alea() pour créer une liste aléatoire de 10 entiers
compris entre 1 et 6. Afficher ensuite cette liste puis la même liste dans laquelle on a inséré la valeur -1 à
l'indice 4.
Une piste ?
Il existe deux façons de réaliser cet exercice.
La première est d'utiliser la méthode .append(). Cela nécessite donc de créer une nouvelle liste et de la
remplir avec les éléments de l'ancienne liste et le nouvel élément. Ce n'est pas la façon la plus simple !.
Dans cet exercice, il faut plutôt utiliser la concaténation + entre deux listes.
Une autre piste ?
Pensez à tester les positions extrêmes pour la fonction inserer() : 0, len(liste)-1, len(liste)...
Truc/Astuce (après avoir terminé !!!)
La méthode pré-programmée en Python qui permet d'effectuer cette insertion est .insert(position, element) :
test = liste_alea(10, 6)
print(test)
test.insert(4, -1)
print(f"L'insertion dans la liste donne {test}")
Attention ! Cette méthode (qui n'est pas une fonction) modifie directement la liste !
Exercice n°6 : Valeur maximale dans une liste
Concevoir la fonction maxi(liste) qui renvoie le plus grand élément de liste. On admet que les éléments de liste
sont tous numériques.
Si la liste ne contient aucune valeur, on renverra la valeur None.
def maxi(liste):
"""
liste - list
Sortie : La valeur maximale de la liste.
>>> maxi([3, 7, 1, 8])
8
>>> maxi([9, 5, 1])
9
>>> maxi([])
None
"""
Dans le programme principal, utiliser la fonction liste_alea() pour créer une liste aléatoire de 15 entiers
compris entre 1 et 100 pour tester la fonction maxi().
Une piste ?
On décide arbitrairement que le 1er élément de la liste est le maximum puis on le compare à chacun des autres éléments, en le remplaçant dès que c'est nécessaire.
Truc/Astuce (après avoir terminé !!!)
La fonction pré-programmée en Python qui permet d'obtenir le maximum d'une liste est max().
test = liste_alea(10, 100)
print(f"La liste est {test}")
maximum = max(test)
print(f"Le maximum de la liste est {maximum}")
Cette fonction renvoie juste un nombre pour l'instant. Améliorer cette fonction afin qu'elle renvoie un tuple contenant le maximum comme premier élément puis la liste des indice(s) au(x)quel(s) se trouve ce maximum dans la liste analysée.
Améliorer le programme principal pour obtenir un affichage comme ci-dessous :
Une piste ?
Lors de la recherche du maximum, on en profite pour stocker au fur et à mesure les indices correspondants à ce maximum dans une liste. Si un nouveau maximum est trouvé, on doit donc recommencer la liste des indices avec une liste vide.
Travail originel CC-BY-NC-SA : Nicolas Buyle-Bodin, Jean-Manuel Meny, Mickaël Bordonaro, Cédric Frayssinet, Maxime Chourré