Partie 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 ().

def saluer():
    print("Bonjour")

saluer     # ❌ N'exécute rien ! (c'est juste une référence à la fonction)
saluer()   # ✅ Exécute la fonction

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

def saluer(prenom):
    print(f"Bonjour {prenom}")

saluer()              # ❌ TypeError: missing 1 required positional argument
saluer("Alice", 16)   # ❌ TypeError: takes 1 positional argument but 2 were given
saluer("Alice")       # ✅ Correct

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é :

def tester(x):
    if x > 0:
        return "positif"
    print("Cette ligne est exécutée si x <= 0")
    return "négatif ou nul"

print(tester(5))    # "positif" (le print de la ligne 3 n'est PAS exécuté)
print(tester(-2))   # affiche d'abord le message, puis "négatif ou nul"

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

notes = [15, 12, 18]
print(notes[3])    # ❌ IndexError: list index out of range
# Les indices vont de 0 à 2 (longueur - 1)

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)

---