Chapitre 3 : Fonctions et listes¶
Programme officiel (B.O.)¶
B.O. spécial n° 1 du 22 janvier 2019 - SNT Seconde
| Contenus | Capacités attendues |
|---|---|
| Affectations, variables | Écrire et développer des programmes avec des variables. |
| Séquences d'instructions | Comprendre et écrire une suite ordonnée d'instructions. |
Instructions conditionnelles (if, elif, else) |
Programmer des choix dans un algorithme. |
Boucles bornées (for) et non bornées (while) |
Programmer des répétitions. |
| Définitions et appels de fonctions | Décomposer un programme en fonctions réutilisables. |
7. Les fonctions¶
7.1. Qu'est-ce qu'une fonction ?¶
Une fonction est un bloc de code réutilisable auquel on donne un nom. Elle permet de :
- Décomposer un programme en sous-tâches claires
- Éviter la répétition de code (principe DRY : Don't Repeat Yourself)
- Rendre le programme lisible et facile à maintenir
Vous avez déjà utilisé des fonctions prédéfinies : print(), input(), len(), range(), type(), int(), float(), str()…
7.2. Définir et appeler une fonction¶
# DÉFINIR la fonction (la créer)
def dire_bonjour():
print("Bonjour !")
print("Bienvenue en cours de SNT.")
# APPELER la fonction (l'exécuter)
dire_bonjour()
# Bonjour !
# Bienvenue en cours de SNT.
# On peut l'appeler autant de fois qu'on veut
dire_bonjour()
dire_bonjour()
Définir ≠ Appeler
La définition (def) crée la fonction mais ne l'exécute pas. Il faut l'appeler en écrivant son nom suivi de parenthèses ().
Erreur fréquente : appeler avant de définir
dire_bonjour() # ❌ NameError: name 'dire_bonjour' is not defined
def dire_bonjour():
print("Bonjour")
Python lit le code de haut en bas : la fonction doit être définie avant d'être appelée.
7.3. Fonctions avec paramètres¶
Les paramètres sont des valeurs que l'on passe à la fonction lors de l'appel :
def saluer(prenom):
print(f"Bonjour {prenom} !")
saluer("Alice") # Bonjour Alice !
saluer("Bob") # Bonjour Bob !
Plusieurs paramètres :
def aire_rectangle(longueur, largeur):
return longueur * largeur
print(aire_rectangle(5, 3)) # 15
print(aire_rectangle(10, 7)) # 70
Erreur : mauvais nombre d'arguments
Paramètres par défaut¶
On peut donner une valeur par défaut à un paramètre. Si l'argument n'est pas fourni lors de l'appel, la valeur par défaut est utilisée :
def saluer(prenom, formule="Bonjour"):
print(f"{formule} {prenom} !")
saluer("Alice") # Bonjour Alice !
saluer("Alice", "Salut") # Salut Alice !
saluer("Alice", "Bonsoir") # Bonsoir Alice !
Arguments nommés¶
On peut préciser le nom des paramètres lors de l'appel, ce qui permet de changer l'ordre :
def presentation(prenom, age, classe):
print(f"{prenom}, {age} ans, en {classe}")
# Appel classique (par position)
presentation("Alice", 16, "2nde B")
# Appel avec arguments nommés (par nom)
presentation(classe="2nde B", prenom="Alice", age=16)
# On peut mélanger (les positionnels d'abord)
presentation("Alice", classe="2nde B", age=16)
7.4. return : renvoyer un résultat¶
Le mot-clé return permet à la fonction de renvoyer une valeur au programme qui l'a appelée :
def calculer_aire(longueur, largeur):
return longueur * largeur
# On récupère le résultat dans une variable
a = calculer_aire(5, 3)
print(f"Aire : {a}") # Aire : 15
# On peut utiliser directement le résultat
if calculer_aire(10, 7) > 50:
print("Grand rectangle !")
print() vs return - la confusion n° 1 des débutants
# Avec print : AFFICHE mais ne renvoie rien
def aire_v1(longueur, largeur):
print(longueur * largeur)
resultat = aire_v1(5, 3) # Affiche 15
print(resultat) # None ! (la fonction ne renvoie rien)
print(resultat * 2) # ❌ TypeError: unsupported operand type(s) for *: 'NoneType' and 'int'
# Avec return : RENVOIE la valeur (sans l'afficher)
def aire_v2(longueur, largeur):
return longueur * largeur
resultat = aire_v2(5, 3) # Pas d'affichage !
print(resultat) # 15
print(resultat * 2) # 30 ✅
Règle : si la fonction doit être réutilisée dans un calcul, utilisez return. Si elle doit juste afficher quelque chose à l'écran, utilisez print().
Ce qui se passe après un return
Le return arrête immédiatement la fonction. Tout code après un return n'est jamais exécuté :
Renvoyer plusieurs valeurs¶
Python permet de renvoyer plusieurs valeurs avec un seul return :
def min_max(a, b, c):
minimum = min(a, b, c)
maximum = max(a, b, c)
return minimum, maximum
petit, grand = min_max(7, 2, 9)
print(f"Min : {petit}, Max : {grand}") # Min : 2, Max : 9
7.5. Portée des variables (local vs global)¶
Les variables créées à l'intérieur d'une fonction sont locales : elles n'existent que pendant l'exécution de la fonction.
def ma_fonction():
x = 10 # Variable locale
print(x)
ma_fonction() # Affiche 10
print(x) # ❌ NameError: name 'x' is not defined
x = 100 # Variable globale
def ma_fonction():
print(x) # On peut LIRE une variable globale
ma_fonction() # Affiche 100
Piège courant avec la portée
compteur = 0
def incrementer():
compteur = compteur + 1 # ❌ UnboundLocalError !
# Python croit qu'on veut créer une variable locale 'compteur'
# mais on essaie de la lire avant de la créer
incrementer()
En SNT, il est préférable de passer les valeurs en paramètres et d'utiliser return plutôt que de modifier des variables globales.
7.6. Exemples complets de fonctions¶
Fonction qui teste si un nombre est pair :
# Plusieurs façons d'écrire la même fonction :
# Version 1 : avec if/else
def est_pair(n):
if n % 2 == 0:
return True
else:
return False
# Version 2 : simplifiée (le test est déjà un booléen !)
def est_pair(n):
return n % 2 == 0
# Les deux versions donnent le même résultat
print(est_pair(4)) # True
print(est_pair(7)) # False
Fonction avec une boucle :
def table_multiplication(n):
for i in range(1, 11):
print(f"{n} × {i} = {n * i}")
table_multiplication(7)
Fonction avec un conditionnel :
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 "Admis"
else:
return "Non admis"
print(mention(15.5)) # Bien
8. Les listes (introduction)¶
Les listes sont des collections ordonnées de valeurs. Elles sont indispensables en programmation et apparaissent dans de nombreux exercices.
8.1. Créer et manipuler une liste¶
# Créer une liste
notes = [15, 12, 18, 9, 14]
prenoms = ["Alice", "Bob", "Charlie"]
vide = []
# Accéder à un élément (les indices commencent à 0)
print(notes[0]) # 15 (premier élément)
print(notes[2]) # 18 (troisième élément)
print(notes[-1]) # 14 (dernier élément)
# Modifier un élément
notes[1] = 16 # notes vaut maintenant [15, 16, 18, 9, 14]
# Longueur de la liste
print(len(notes)) # 5
Erreur fréquente : indice hors limites
8.2. Ajouter et supprimer des éléments¶
fruits = ["pomme", "banane"]
# Ajouter à la fin
fruits.append("cerise") # ["pomme", "banane", "cerise"]
# Insérer à une position donnée
fruits.insert(1, "orange") # ["pomme", "orange", "banane", "cerise"]
# Supprimer par valeur
fruits.remove("banane") # ["pomme", "orange", "cerise"]
# Supprimer par indice
del fruits[0] # ["orange", "cerise"]
# Supprimer et récupérer le dernier élément
dernier = fruits.pop() # dernier = "cerise", fruits = ["orange"]
8.3. Parcourir une liste¶
notes = [15, 12, 18, 9, 14]
# Calculer la moyenne
total = 0
for note in notes:
total += note
moyenne = total / len(notes)
print(f"Moyenne : {moyenne}")
# Variante avec sum() (fonction intégrée)
moyenne = sum(notes) / len(notes)
8.4. Quelques fonctions et méthodes utiles¶
nombres = [3, 1, 4, 1, 5, 9, 2, 6]
len(nombres) # 8 (nombre d'éléments)
min(nombres) # 1 (plus petit élément)
max(nombres) # 9 (plus grand élément)
sum(nombres) # 31 (somme de tous les éléments)
sorted(nombres) # [1, 1, 2, 3, 4, 5, 6, 9] (nouvelle liste triée)
nombres.sort() # trie la liste en place (modifie nombres)
nombres.count(1) # 2 (nombre d'occurrences de 1)
3 in nombres # True (teste si 3 est dans la liste)