Programmer en Python
Leçon 1 - Python : fonctions et listes
Créer vos propres outils et organiser vos données - la suite de votre apprentissage
Python : fonctions et listes
Créer vos propres outils et organiser vos données - la suite de votre apprentissage
Ce cours fait suite au cours "Débuter en Python" et en réutilise toutes les notions. Objectif : apprendre à programmer pour de vrai.
print(), input(), les variables et les types (int, str, bool), les conditions (if / elif / else), les boucles for et while, et l'indentation.
Objectifs du cours
- Comprendre à quoi sert une fonction et pourquoi on en crée.
- Créer vos propres fonctions avec
def, des paramètres etreturn. - Créer des listes et accéder à leurs éléments par leur position.
- Modifier, parcourir et utiliser des listes dans vos programmes.
- Combiner fonctions et listes pour écrire des programmes plus puissants.
Dans le cours 1, vous avez utilisé des fonctions déjà existantes : print() pour afficher, input() pour saisir, int() pour convertir. Ces fonctions ont été écrites par d'autres programmeurs. Mais l'un des pouvoirs les plus importants de la programmation est de pouvoir créer ses propres fonctions.
Pourquoi créer une fonction ?
Imaginons que vous deviez, à plusieurs endroits de votre programme, afficher un message de bienvenue personnalisé. Sans fonction, vous seriez obligé de recopier les mêmes lignes de code à chaque fois. Cela pose trois problèmes : le code devient long, il est difficile à modifier (il faut corriger à chaque endroit), et il est plus difficile à lire. Une fonction résout ces trois problèmes d'un coup.
Créer une fonction avec def
On crée une fonction avec le mot-clé def (abréviation de define, "définir" en anglais), suivi du nom de la fonction, de parenthèses et de deux-points. Le bloc indenté qui suit contient les instructions de la fonction.
def dire_bonjour(): print("Bonjour !") print("Bienvenue dans le programme.")
Ces trois lignes ne produisent aucun affichage. Elles définissent la fonction, c'est-à-dire qu'elles la créent et la rangent en mémoire. Pour que la fonction s'exécute, il faut l'appeler.
def dire_bonjour(): print("Bonjour !") print("Bienvenue dans le programme.") dire_bonjour() dire_bonjour()
Bienvenue dans le programme.
Bonjour !
Bienvenue dans le programme.
La fonction a été définie une seule fois, mais appelée deux fois. Chaque appel exécute le bloc complet. Si l'on souhaite modifier le message, il suffit de changer la fonction : toutes les utilisations sont mises à jour automatiquement.
Le concept de fonction en informatique est directement inspiré des fonctions en mathématiques. En 1936, le mathématicien Alonzo Church a inventé le lambda calcul, un système formel dans lequel tout calcul se réduit à des applications de fonctions. Ce travail théorique, réalisé avant même l'existence des ordinateurs, est l'un des fondements de tous les langages de programmation modernes.
Les paramètres : donner des informations à une fonction
Une fonction qui fait toujours exactement la même chose a un usage limité. Pour la rendre adaptable, on lui donne des paramètres : des valeurs qu'elle reçoit entre ses parenthèses et qu'elle utilise dans son bloc.
def, qui reçoit une valeur à chaque appel de la fonction. La valeur fournie lors de l'appel s'appelle un argument.
def saluer(prenom): print(f"Bonjour, {prenom} ! Bienvenue.") saluer("Marie") saluer("Lucas") saluer("Élise")
Bonjour, Lucas ! Bienvenue.
Bonjour, Élise ! Bienvenue.
La fonction saluer possède un paramètre nommé prenom. Lors du premier appel, prenom reçoit la valeur "Marie". Lors du deuxième, il reçoit "Lucas". Le code de la fonction est le même, mais le résultat change à chaque appel.
Plusieurs paramètres
Une fonction peut recevoir autant de paramètres que nécessaire. Ils sont séparés par des virgules.
def presenter(prenom, age, ville): print(f"{prenom} a {age} ans et habite à {ville}.") presenter("Marie", 12, "Lyon") presenter("Lucas", 11, "Paris")
Lucas a 11 ans et habite à Paris.
L'ordre des arguments est important. Lors de l'appel presenter("Marie", 12, "Lyon"), le premier argument ("Marie") est affecté au premier paramètre (prenom), le deuxième (12) au deuxième (age), et ainsi de suite.
Le nom d'une fonction doit décrire ce qu'elle fait. saluer, calculer_perimetre, afficher_resultat sont des noms clairs. f1, truc, machin ne le sont pas. Comme pour les variables, on utilise des minuscules et des tirets bas pour séparer les mots.
- On crée une fonction avec
def nom():suivi d'un bloc indenté. - Définir une fonction ne l'exécute pas. Il faut l'appeler :
nom(). - Les paramètres, entre parenthèses, rendent la fonction adaptable.
- Les valeurs fournies lors de l'appel s'appellent des arguments.
- L'ordre des arguments correspond à l'ordre des paramètres.
return
Les fonctions du chapitre 1 affichaient des messages avec print(). Elles agissaient, mais elles ne donnaient rien en retour au programme. Pourtant, la plupart des fonctions utiles sont celles qui calculent un résultat et le renvoient, pour qu'on puisse l'utiliser ensuite.
Prenons un exemple concret. La fonction int() que vous connaissez n'affiche jamais rien à l'écran : elle convertit une valeur et renvoie le résultat, ce qui permet de le stocker dans une variable. Nous allons apprendre à faire la même chose avec nos propres fonctions.
return : une instruction qui termine l'exécution de la fonction et renvoie une valeur au programme qui l'a appelée. Cette valeur peut ensuite être stockée dans une variable, affichée, ou utilisée dans un calcul.
Un premier exemple avec return
def double(nombre): resultat = nombre * 2 return resultat x = double(7) print(x)
Suivons l'exécution pas à pas. L'appel double(7) lance la fonction avec nombre = 7. La variable resultat reçoit 7 * 2 = 14. L'instruction return resultat renvoie la valeur 14 au programme principal. Cette valeur est stockée dans x, puis affichée.
La différence entre print et return
Cette distinction est l'une des plus importantes de ce cours. Les deux semblent similaires mais ne font pas du tout la même chose.
| Instruction | Ce qu'elle fait | Le résultat est-il réutilisable ? |
|---|---|---|
print() |
Affiche une valeur à l'écran | Non. L'affichage est "perdu" pour le programme. |
return |
Renvoie une valeur au code qui a appelé la fonction | Oui. On peut la stocker, la recalculer, la comparer. |
def avec_print(n): print(n * 2) def avec_return(n): return n * 2 a = avec_print(5) # affiche 10, mais a vaut None b = avec_return(5) # n'affiche rien, mais b vaut 10 print(a) # affiche None print(b) # affiche 10 print(b + 3) # affiche 13 — on peut calculer avec b
None
10
13
La fonction avec_print affiche le résultat à l'écran, mais ne le renvoie pas : la variable a ne contient rien d'utile (sa valeur est None, un mot spécial de Python qui signifie "rien"). La fonction avec_return, elle, ne produit aucun affichage, mais renvoie le résultat : la variable b contient bien la valeur 10 et on peut l'utiliser.
Le mot None est une valeur spéciale de Python qui signifie "absence de valeur". C'est le résultat renvoyé par toute fonction qui ne contient pas d'instruction return. En Python, None a son propre type, nommé NoneType. Il ne faut pas le confondre avec une liste vide [] ou une chaîne vide "" : celles-ci sont de vraies valeurs, simplement vides, alors que None représente l'absence de toute valeur.
Utiliser return dans un calcul
La puissance de return apparaît lorsqu'on utilise une fonction dans un calcul plus large.
def perimetre_rectangle(longueur, largeur): return 2 * (longueur + largeur) def aire_rectangle(longueur, largeur): return longueur * largeur longueur = 8 largeur = 5 print(f"Périmètre : {perimetre_rectangle(longueur, largeur)} cm") print(f"Aire : {aire_rectangle(longueur, largeur)} cm²")
Aire : 40 cm²
Ici, les fonctions renvoient des valeurs numériques que l'on insère directement dans des f-strings. On aurait aussi pu stocker les résultats dans des variables, ou les réutiliser dans d'autres calculs. C'est cette souplesse qui rend return indispensable.
L'instruction return met fin à l'exécution de la fonction immédiatement. Tout code écrit après un return dans le même bloc ne sera jamais exécuté. Un appel de fonction s'arrête donc au premier return rencontré. Ce return renvoie une seule valeur au sens de Python - mais cette valeur peut être une structure contenant plusieurs éléments, par exemple une liste, comme vous le verrez au chapitre suivant.
Exemple complet : une fonction avec condition et return
def mention(note): if note >= 16: return "Très Bien" elif note >= 14: return "Bien" elif note >= 12: return "Assez Bien" elif note >= 10: return "Reçu" else: return "Non reçu" resultat = mention(15) print(f"Mention obtenue : {resultat}")
L'appel mention(15) entre dans la fonction. La première condition (15 >= 16) est fausse. La deuxième (15 >= 14) est vraie : Python exécute return "Bien" et quitte immédiatement la fonction. Les conditions suivantes ne sont même pas testées.
returnrenvoie une valeur au programme qui a appelé la fonction.print()affiche mais ne renvoie rien d'utile.returnrenvoie mais n'affiche rien.- Une fonction sans
returnrenvoieNone. returntermine immédiatement la fonction.- La valeur renvoyée peut être stockée, affichée ou utilisée dans un calcul.
Jusqu'ici, chaque variable contenait une seule valeur : un nombre, un texte, un booléen. Mais que faire si l'on veut stocker les notes de toute une classe, les prénoms de vos amis, ou les scores d'un jeu ? Créer une variable par valeur serait absurde. C'est exactement à ce problème que répondent les listes.
list) : une structure de données ordonnée qui peut contenir plusieurs valeurs. On la crée avec des crochets [], et les éléments sont séparés par des virgules. Chaque élément a une position (appelée index) qui commence à 0.
Créer une liste
notes = [14, 17, 9, 12, 18] prenoms = ["Marie", "Lucas", "Élise"] liste_vide = [] print(notes) print(prenoms)
['Marie', 'Lucas', 'Élise']
Une liste peut contenir des nombres entiers, des textes, des booléens, ou même un mélange de plusieurs types. Une liste vide, notée [], est une liste qui ne contient encore aucun élément.
Accéder à un élément par son index
Chaque élément d'une liste est identifié par sa position, appelée index. Le premier élément est à l'index 0, le deuxième à l'index 1, et ainsi de suite.
fruits = ["pomme", "banane", "cerise", "mangue"] print(fruits[0]) # premier élément print(fruits[2]) # troisième élément
cerise
La syntaxe est le nom de la liste suivi de l'index entre crochets : fruits[0] donne le premier élément, fruits[2] donne le troisième. Attention : comme le comptage commence à 0, le troisième élément est à l'index 2, pas 3.
| Élément | "pomme" |
"banane" |
"cerise" |
"mangue" |
|---|---|---|---|---|
| Index | 0 | 1 | 2 | 3 |
Le comptage à partir de 0 est une convention popularisée par les langages proches de la machine, notamment le langage C, développé au début des années 1970 par Dennis Ritchie. Elle vient de la façon dont les ordinateurs gèrent la mémoire : l'index représente le décalage par rapport au début de la liste. Le premier élément est à un décalage de 0, d'où l'index 0. Presque tous les langages de programmation modernes ont adopté cette convention.
Les index négatifs
Python offre une particularité pratique : on peut accéder aux éléments en partant de la fin avec des index négatifs. L'index -1 désigne le dernier élément, -2 l'avant-dernier, et ainsi de suite.
fruits = ["pomme", "banane", "cerise", "mangue"] print(fruits[-1]) # dernier élément print(fruits[-2]) # avant-dernier élément
cerise
Connaître la taille d'une liste avec len()
La fonction len() (abréviation de length, "longueur" en anglais) renvoie le nombre d'éléments contenus dans une liste.
notes = [14, 17, 9, 12, 18] print(len(notes))
La liste contient 5 éléments, donc len(notes) renvoie 5. Attention au piège classique : le dernier index valide est len(notes) - 1, soit 4, puisque le comptage commence à 0.
Si l'on tente d'accéder à un index qui n'existe pas, Python provoque une erreur nommée IndexError. Par exemple, si une liste contient 5 éléments et que l'on écrit notes[5], Python affiche IndexError: list index out of range — l'index 5 est "hors limites" car les index valides sont 0, 1, 2, 3 et 4. C'est l'une des erreurs les plus fréquentes en programmation.
- Une liste est une collection ordonnée de valeurs, créée avec
[]. - On accède à un élément par son index :
liste[0]est le premier. - Le comptage des index commence à 0.
- Les index négatifs comptent depuis la fin :
liste[-1]est le dernier. len(liste)renvoie le nombre d'éléments de la liste.
Une liste n'est pas figée. On peut y ajouter des éléments, en supprimer, en modifier. C'est ce qui la rend si utile : elle évolue au fil du programme.
Modifier un élément existant
Pour changer un élément, on accède à sa position et on lui affecte une nouvelle valeur.
fruits = ["pomme", "banane", "cerise"] print(fruits) fruits[1] = "fraise" # on remplace "banane" par "fraise" print(fruits)
['pomme', 'fraise', 'cerise']
Ajouter un élément avec append()
append() : une méthode qui ajoute un élément à la fin d'une liste. On l'appelle avec un point après le nom de la liste : liste.append(valeur).
notes = [14, 17, 9] print(notes) notes.append(15) notes.append(12) print(notes)
[14, 17, 9, 15, 12]
La méthode append() s'écrit différemment des fonctions vues jusqu'ici : on utilise un point entre le nom de la liste et append(). Cette notation avec un point s'appelle la notation pointée. Elle signifie : "applique l'opération append à la liste notes".
Le mot append vient de l'anglais et signifie "ajouter à la fin". En informatique, les listes sont l'une des structures de données les plus anciennes. Le langage LISP, créé en 1958 par John McCarthy, était entièrement fondé sur les listes — son nom signifie d'ailleurs LISt Processing ("traitement de listes"). LISP est encore utilisé aujourd'hui dans certains domaines de l'intelligence artificielle.
Supprimer un élément avec remove()
La méthode remove() supprime la première occurrence d'une valeur donnée dans la liste.
fruits = ["pomme", "banane", "cerise", "banane"] fruits.remove("banane") print(fruits)
Seule la première occurrence de "banane" a été supprimée. La seconde est toujours présente. Si la valeur n'existe pas dans la liste, Python provoque une erreur ValueError.
Vérifier si un élément est dans une liste : in
Le mot-clé in permet de tester si une valeur est présente dans une liste. Le résultat est un booléen : True ou False.
fruits = ["pomme", "banane", "cerise"] print("banane" in fruits) # True print("mangue" in fruits) # False
False
On peut utiliser in dans une condition if :
fruits = ["pomme", "banane", "cerise"] if "mangue" in fruits: print("La mangue est dans la liste.") else: print("La mangue n'est pas dans la liste.")
Parcourir une liste avec for
Le cours 1 avait brièvement montré qu'une boucle for pouvait parcourir une liste. Détaillons cette technique, qui est l'une des plus utilisées en programmation.
notes = [14, 17, 9, 12, 18] total = 0 for note in notes: total = total + note moyenne = total / len(notes) print(f"Moyenne : {moyenne}")
À chaque tour de boucle, la variable note prend la valeur de l'élément suivant dans la liste. Au premier tour, note vaut 14. Au deuxième, 17. Et ainsi de suite jusqu'au dernier élément (18). La variable total accumule la somme, et la moyenne est calculée après la boucle. Remarquez le résultat 14.0 et non 14 : en Python, la division / renvoie toujours un nombre décimal (float), même quand le résultat tombe juste.
Construire une liste élément par élément
Un schéma très courant consiste à partir d'une liste vide et à la remplir progressivement avec append().
carres = [] for i in range(1, 11): carres.append(i * i) print(carres)
On commence avec une liste vide carres = []. La boucle parcourt les nombres de 1 à 10. À chaque tour, elle calcule le carré du nombre (i * i) et l'ajoute à la fin de la liste. Après la boucle, la liste contient les dix premiers carrés parfaits.
| Opération | Syntaxe | Effet |
|---|---|---|
| Créer | [1, 2, 3] |
Crée une liste avec ces éléments |
| Accéder | liste[i] |
Renvoie l'élément à l'index i |
| Modifier | liste[i] = x |
Remplace l'élément à l'index i par x |
| Ajouter | liste.append(x) |
Ajoute x à la fin |
| Supprimer | liste.remove(x) |
Supprime la première occurrence de x |
| Tester | x in liste |
Renvoie True si x est dans la liste |
| Taille | len(liste) |
Renvoie le nombre d'éléments |
Les listes Python sont remarquablement polyvalentes : elles peuvent contenir des éléments de types différents dans la même liste, par exemple [42, "texte", True]. Dans beaucoup de langages typés, comme C ou Java, les tableaux contiennent en général des éléments d'un même type. Cette souplesse est l'une des raisons pour lesquelles Python est considéré comme particulièrement accessible.
- On modifie un élément avec
liste[i] = nouvelle_valeur. append(x)ajoute un élément à la fin de la liste.remove(x)supprime la première occurrence dex.x in listeteste la présence d'un élément (résultat booléen).for element in liste:parcourt tous les éléments un par un.- On peut construire une liste à partir de
[]en ajoutant des éléments dans une boucle.
Exercices
Écrivez une fonction salutation qui prend un prénom et une heure (nombre entier entre 0 et 23) en paramètres. Si l'heure est inférieure à 18, la fonction affiche "Bonjour, [prénom] !". Sinon, elle affiche "Bonsoir, [prénom] !".
Testez-la avec les appels salutation("Marie", 10) et salutation("Lucas", 20).
def salutation(prenom, heure): if heure < 18: print(f"Bonjour, {prenom} !") else: print(f"Bonsoir, {prenom} !") salutation("Marie", 10) salutation("Lucas", 20)
Écrivez une fonction aire_triangle qui prend la base et la hauteur en paramètres et renvoie l'aire du triangle (formule : base × hauteur / 2). Utilisez ensuite cette fonction pour calculer et afficher l'aire d'un triangle de base 10 et de hauteur 6.
def aire_triangle(base, hauteur): return base * hauteur / 2 resultat = aire_triangle(10, 6) print(f"L'aire du triangle est : {resultat} cm²")
Le programme affiche 30.0 et non 30 : la division / renvoie toujours un nombre décimal (float).
Écrivez un programme qui crée la liste [7, 3, 12, 5, 19, 8], puis parcourt cette liste avec une boucle for pour trouver et afficher le plus grand nombre. N'utilisez pas la fonction max() de Python : le but est de le faire vous-même.
Indication : créez une variable plus_grand initialisée au premier élément, puis comparez chaque élément à cette variable.
nombres = [7, 3, 12, 5, 19, 8] plus_grand = nombres[0] for n in nombres: if n > plus_grand: plus_grand = n print(f"Le plus grand nombre est : {plus_grand}")
Écrivez une fonction notes_au_dessus qui prend une liste de notes et un seuil en paramètres, et renvoie une nouvelle liste contenant uniquement les notes supérieures ou égales au seuil.
Testez avec : notes_au_dessus([14, 7, 18, 9, 11, 16], 12).
def notes_au_dessus(notes, seuil): resultat = [] for note in notes: if note >= seuil: resultat.append(note) return resultat bonnes_notes = notes_au_dessus([14, 7, 18, 9, 11, 16], 12) print(bonnes_notes)
Écrivez une fonction calculer_moyenne qui prend une liste de notes en paramètre et renvoie la moyenne. Utilisez cette fonction pour afficher la moyenne de [15, 12, 18, 9, 14].
def calculer_moyenne(notes): total = 0 for note in notes: total = total + note return total / len(notes) moy = calculer_moyenne([15, 12, 18, 9, 14]) print(f"Moyenne : {moy}")
Exercices de réflexion
Lisez ce programme et prédisez son affichage sans l'exécuter.
def mystere(a, b): if a > b: return a else: return b x = mystere(8, 5) y = mystere(3, 10) print(x) print(y) print(mystere(x, y))
Ce programme ne fonctionne pas comme prévu. Expliquez le problème et corrigez-le.
def carre(n): print(n * n) resultat = carre(4) + carre(3) print(f"Somme des carrés : {resultat}")
Lisez ce programme et donnez le contenu de la liste resultat après son exécution. Expliquez chaque étape.
resultat = [10, 20, 30] resultat.append(40) resultat[1] = 25 resultat.remove(30) resultat.append(resultat[0] + resultat[1])
Écrivez une fonction compter qui prend une liste et une valeur en paramètres, et renvoie le nombre de fois que cette valeur apparaît dans la liste. Testez avec compter([1, 3, 5, 3, 7, 3], 3).
Corrigés des exercices de réflexion
La fonction mystere compare deux nombres et renvoie le plus grand.
mystere(8, 5):8 > 5est vrai, doncreturn 8. La variablexreçoit 8.mystere(3, 10):3 > 10est faux, doncreturn 10. La variableyreçoit 10.mystere(x, y)revient àmystere(8, 10):8 > 10est faux, doncreturn 10.
Affichage : 8, puis 10, puis 10.
En réalité, mystere est l'équivalent de la fonction max de Python, appliquée à deux nombres.
Le problème est dans la fonction carre : elle utilise print au lieu de return.
carre(4)affiche16à l'écran mais renvoieNone.carre(3)affiche9à l'écran mais renvoieNone.- La ligne
carre(4) + carre(3)tente de calculerNone + None, ce qui provoque une erreurTypeError.
Correction : remplacer print(n * n) par return n * n. La fonction renverra alors un nombre que l'on pourra additionner.
Suivons chaque instruction :
- Départ :
[10, 20, 30] - Après
append(40):[10, 20, 30, 40] - Après
resultat[1] = 25:[10, 25, 30, 40](le 20 à l'index 1 est remplacé par 25) - Après
remove(30):[10, 25, 40] - Dernière ligne :
resultat[0] + resultat[1]=10 + 25=35. On ajoute 35 à la fin.
Contenu final : [10, 25, 40, 35].
def compter(liste, valeur): compteur = 0 for element in liste: if element == valeur: compteur = compteur + 1 return compteur resultat = compter([1, 3, 5, 3, 7, 3], 3) print(f"Le nombre 3 apparaît {resultat} fois.")
La fonction parcourt la liste élément par élément. Chaque fois qu'un élément est égal à la valeur cherchée, le compteur augmente de 1. Le résultat est 3 (le nombre 3 apparaît trois fois dans la liste).
À retenir
- On crée une fonction avec
def nom(parametres):. On l'appelle avecnom(arguments). returnrenvoie une valeur réutilisable.print()affiche mais ne renvoie rien d'utile.- Une liste est une collection ordonnée :
[14, 17, 9]. Les index commencent à 0. append(x)ajoute à la fin.remove(x)supprime la première occurrence.x in listeteste la présence.for element in liste:parcourt chaque élément.len(liste)donne la taille.
Lexique
append()- Méthode qui ajoute un élément à la fin d'une liste.
- Argument
- Valeur fournie à une fonction lors de son appel. Exemple : dans
saluer("Marie"),"Marie"est l'argument. def- Mot-clé Python qui sert à définir (créer) une fonction.
- Fonction
- Bloc de code nommé, réutilisable, que l'on peut appeler avec des parenthèses. On la crée avec
def. in- Mot-clé qui teste si une valeur est présente dans une liste. Renvoie
TrueouFalse. - Index
- Position d'un élément dans une liste. Le premier élément est à l'index 0.
IndexError- Erreur provoquée lorsqu'on tente d'accéder à un index qui n'existe pas dans la liste.
len()- Fonction qui renvoie le nombre d'éléments d'une liste (ou la longueur d'une chaîne de caractères).
- Liste (
list) - Structure de données ordonnée contenant plusieurs valeurs, créée avec des crochets
[]. - Méthode
- Fonction attachée à un objet, appelée avec la notation pointée :
objet.methode(). Exemple :liste.append(5). None- Valeur spéciale de Python signifiant "absence de valeur". Renvoyée par les fonctions sans
return. À ne pas confondre avec une liste vide[]ou une chaîne vide"". - Notation pointée
- Syntaxe avec un point entre un objet et une méthode :
liste.append(),liste.remove(). - Paramètre
- Variable spéciale déclarée entre les parenthèses de
def, qui reçoit une valeur à chaque appel. remove()- Méthode qui supprime la première occurrence d'une valeur dans une liste.
return- Instruction qui termine une fonction et renvoie une valeur au programme appelant.
ValueError- Erreur provoquée lorsqu'on tente de supprimer une valeur absente de la liste avec
remove().