NSI : les 6 erreurs fréquentes sur les fonctions en Python

Les fonctions en Python sont un pilier de la programmation, et en spécialité NSI, elles sont au cœur de nombreux exercices et projets. Pourtant, beaucoup d'élèves trébuchent sur les mêmes pièges, que ce soit en classe ou le jour du bac. Pas de panique ! Dans cet article, on passe en revue les 6 erreurs les plus fréquentes quand on manipule les fonctions en Python, avec des explications claires, des exemples de code et des astuces pour les éviter. À la fin, tu seras armé pour coder comme un pro et gagner des points précieux à l'épreuve.

1. Oublier le mot-clé return

L'erreur la plus courante chez les débutants : créer une fonction qui fait des calculs mais qui ne renvoie rien. Résultat, quand on appelle la fonction, on obtient None et on ne comprend pas pourquoi.

Regarde cet exemple :

def additionner(a, b):
    resultat = a + b
    # pas de return !

print(additionner(3, 4))  # affiche None

La fonction additionner calcule bien la somme, mais elle ne la renvoie pas. Pour que la fonction soit utile, il faut utiliser return pour renvoyer le résultat à l'appelant.

def additionner(a, b):
    return a + b

print(additionner(3, 4))  # affiche 7

Astuce : si ta fonction doit produire un résultat, pense systématiquement à return. Par contre, si elle a un effet de bord (comme afficher un message), tu peux ne pas l'utiliser, mais ce n'est pas la même logique.

2. Confondre print et return

Autre grand classique : utiliser print au lieu de return dans une fonction. print affiche une valeur à l'écran, mais ne la renvoie pas. Du coup, impossible de réutiliser le résultat dans d'autres calculs.

Exemple :

def carre(x):
    print(x**2)  # affiche le carré, mais ne le renvoie pas

y = carre(5)  # affiche 25
print(y)  # affiche None

Si tu veux que y contienne le carré de 5, il faut utiliser return :

def carre(x):
    return x**2

y = carre(5)
print(y)  # affiche 25

Pour t'entraîner, explore les exercices NSI du site, ils sont parfaits pour comprendre ces subtilités.

3. Ne pas comprendre la portée des variables (variables locales vs globales)

En Python, une variable définie à l'intérieur d'une fonction est locale : elle n'existe que dans cette fonction. À l'extérieur, elle est invisible. Inversement, une variable définie en dehors de toute fonction est globale et accessible partout, mais attention aux modifications.

Erreur typique : essayer de modifier une variable globale sans le déclarer explicitement.

total = 0

def ajouter(valeur):
    total = total + valeur  # erreur : total est lu et modifié, Python pense qu'elle est locale

ajouter(5)
print(total)  # affiche 0, car la fonction a créé une variable locale 'total' sans lien avec la globale

Pour modifier une variable globale, il faut utiliser le mot-clé global :

total = 0

def ajouter(valeur):
    global total
    total = total + valeur

ajouter(5)
print(total)  # affiche 5

Mais attention, l'usage de global est à éviter si possible. Une meilleure approche est de passer la variable en paramètre et de retourner la nouvelle valeur :

def ajouter(total, valeur):
    return total + valeur

total = 0
total = ajouter(total, 5)
print(total)  # affiche 5

4. Les paramètres par défaut modifiables (piège classique)

En Python, les paramètres par défaut sont évalués une seule fois au moment de la définition de la fonction. Si tu utilises un objet modifiable (comme une liste) comme valeur par défaut, tu risques de partager cet objet entre tous les appels.

Exemple d'erreur :

def ajouter_element(element, liste=[]):
    liste.append(element)
    return liste

print(ajouter_element(1))  # [1]
print(ajouter_element(2))  # [1, 2] (au lieu de [2])

La solution est d'utiliser None comme valeur par défaut et de créer une nouvelle liste à chaque appel :

def ajouter_element(element, liste=None):
    if liste is None:
        liste = []
    liste.append(element)
    return liste

print(ajouter_element(1))  # [1]
print(ajouter_element(2))  # [2]

C'est un piège redoutable pour les examens, alors retiens-le bien !

5. Modifier une liste passée en paramètre sans le vouloir

Quand tu passes une liste à une fonction, c'est une référence à la même liste en mémoire que tu transmets. Si tu la modifies à l'intérieur de la fonction, la liste d'origine est modifiée aussi. Parfois c'est voulu, mais souvent c'est une erreur.

Exemple :

def doubler(liste):
    for i in range(len(liste)):
        liste[i] = liste[i] * 2

mes_nombres = [1, 2, 3]
doubler(mes_nombres)
print(mes_nombres)  # [2, 4, 6] (modifié !)

Si tu ne veux pas modifier la liste d'origine, il faut en créer une copie :

def doubler(liste):
    nouvelle_liste = []
    for element in liste:
        nouvelle_liste.append(element * 2)
    return nouvelle_liste

mes_nombres = [1, 2, 3]
nouveaux = doubler(mes_nombres)
print(mes_nombres)  # [1, 2, 3]
print(nouveaux)  # [2, 4, 6]

Pour les listes, tu peux aussi utiliser la copie avec liste[:] ou list(liste).

6. Ne pas tester les cas limites ou les types d'arguments

En NSI, on te demande souvent d'écrire des fonctions robustes. Une erreur fréquente est de ne pas prévoir ce qui se passe si on passe des valeurs négatives, nulles, ou des types différents de ceux attendus.

Exemple :

def division(a, b):
    return a / b

print(division(10, 0))  # erreur : division par zéro

Pour éviter cela, on peut vérifier les paramètres et lever une exception (ou gérer le cas) :

def division(a, b):
    if b == 0:
        return "Division par zéro impossible"
    return a / b

print(division(10, 0))  # affiche le message

Pense aussi à vérifier le type de l'argument si nécessaire, par exemple avec isinstance().

Comment bien réviser les fonctions pour le bac NSI ?

Les fonctions sont un thème incontournable du programme de NSI, en Première comme en Terminale. Pour réussir l'épreuve, il ne suffit pas de connaître la syntaxe : il faut comprendre la logique et savoir appliquer les concepts dans des exercices variés.

Voici quelques conseils :

• Pratique régulière : écris des fonctions tous les jours, même simples. C'est en codant qu'on progresse.
• Lis le code des autres : analyse des fonctions écrites par d'autres pour voir différentes approches.
• Teste tes fonctions : utilise des print ou des assertions pour vérifier que tout fonctionne.
• Révise avec des ressources en ligne : le site nsi-lycee.fr propose des cours et des exercices corrigés qui peuvent t'aider.

Pense aussi à consulter les sujets des annales du bac pour t'entraîner dans les conditions de l'examen. Si tu as besoin de soutien, le site AlloLycée propose des ressources et du soutien scolaire.

Conclusion

Voilà, tu connais maintenant les 6 erreurs les plus fréquentes sur les fonctions en Python en NSI. En les évitant, tu gagneras en efficacité et en confiance. N'oublie pas : coder, c'est comme apprendre un sport, il faut s'entraîner régulièrement. Alors, lance-toi, fais des erreurs, comprends-les et améliore-toi. Tu vas y arriver !