Mathématiques · Seconde

Comment construire une fonction Python fiable et réutilisable ?

Cours interactif de seconde sur fonctions Python, arguments, return, variables locales, aléatoire, répétitions et sorties statistiques.

  1. Comprendre
  2. Mettre en pratique
  3. Vérifier
  4. Mémoriser
  • 6activités interactives
  • 8questions de quiz
  • 6cartes de révision
  • 3sources citées

Ce que tu vas savoir faire

  • Définir et appeler une fonction à un ou plusieurs arguments.
  • Distinguer argument, paramètre et variable locale.
  • Distinguer une valeur renvoyée par return d’un affichage avec print.
  • Lire le contrat d’une fonction et contrôler ses entrées.
  • Écrire une fonction renvoyant le résultat d’une expérience aléatoire et de répétitions indépendantes.
  • Exploiter une fonction fournie renvoyant moyenne et écart type.

Avant de commencer

  • Suivre une affectation et une séquence Python.
  • Lire une condition et une boucle for.
  • Connaître effectif, fréquence et modèle probabiliste.
Le chapitre en bref

Une fonction Python reçoit zéro, un ou plusieurs arguments, exécute un bloc local et renvoie éventuellement une valeur avec return. Son contrat précise les entrées admissibles, la sortie et les restrictions. print affiche, tandis que return rend une valeur réutilisable. Une fonction aléatoire doit correspondre au modèle annoncé ; sa répétition peut être programmée avec une boucle et un compteur, sans imposer les listes.

1. Que promet exactement une fonction ?

Une définition commence par def, un nom, des paramètres entre parenthèses et deux-points. Lors de l’appel, les arguments sont associés aux paramètres, généralement dans l’ordre. Le bloc indenté décrit le calcul.

Le contrat de la fonction annonce la nature des entrées, les restrictions et la sortie. Ainsi inverse(x) exige x non nul ; aire_rectangle(L,l) suppose des longueurs admissibles. Un code syntaxiquement correct peut rester mathématiquement incohérent si son contrat est oublié.

Que reçoit la fonction et que renvoie-t-elle ?

def aire_rectangle(L, l): return L*lArguments : L=5 ; l=3Valeur renvoyée : 15

Le contrat annonce les entrées admissibles et la valeur produite.

2. Pourquoi print ne remplace-t-il pas return ?

return interrompt l’appel courant et transmet une valeur au programme appelant. Cette valeur peut être stockée, comparée ou utilisée dans un nouveau calcul. print se contente d’afficher un texte ou une valeur à l’écran.

Une fonction sans return explicite renvoie None. Voir 8 s’afficher ne signifie donc pas que l’expression double(4)+1 est possible : cela dépend de la valeur réellement renvoyée.

Afficher ou renvoyer : quelle différence ?

def double(x): return 2*x y = double(4)+1double(4) vaut 8y = 9

return produit une valeur réutilisable et interrompt l’appel courant.

3. Où vivent les paramètres et les variables locales ?

À chaque appel, les paramètres reçoivent les arguments et les variables créées dans le corps forment un état local. Deux appels successifs de carre ne partagent pas leur x ni leur variable resultat.

Une fonction dépendant silencieusement d’une variable globale est plus difficile à comprendre et à tester. Lorsque c’est possible, passe la donnée utile en argument et renvoie le résultat : les dépendances deviennent visibles.

Quelle variable appartient à quel appel ?

def carre(x): resultat = x*x return resultat y = carre(3)x et resultat sont localesy reçoit 9

Chaque appel crée son propre état local à partir des arguments.

4. Une fonction aléatoire simule-t-elle automatiquement la réalité ?

randint(1,6) renvoie un entier entre 1 et 6, bornes incluses, selon le générateur employé. Utilisé pour un dé, ce code suppose six issues équiprobables. La fonction simule ce modèle ; elle ne vérifie pas l’équilibre d’un dé réel.

La fonction random() fournit une valeur uniforme dans [0;1[. Tester random()<p produit un succès de probabilité p dans le modèle, à condition de contrôler 0≤p≤1.

Quelle loi la fonction aléatoire simule-t-elle ?

from random import randint def de(): return randint(1,6)Issues 1 à 6 équiprobablesUn entier aléatoire inclusif

Le code simule le modèle annoncé ; il ne prouve pas que le phénomène réel suit cette loi.

5. Comment répéter une expérience sans stocker tous les résultats ?

Pour compter les six obtenus en n lancers, initialise c à zéro, appelle la fonction de() dans une boucle for et incrémente c lorsque le résultat vaut 6. À la fin, c est l’effectif recherché et c/n la fréquence si n est strictement positif.

Le programme 2026 n’exige aucune connaissance des listes. Un compteur est souvent plus lisible et moins coûteux lorsqu’on n’a besoin que d’un effectif, d’une somme ou d’une fréquence. L’indépendance des appels reste une hypothèse du modèle à annoncer.

Comment répéter sans exiger les listes ?

def nb_six(n): c = 0 for i in range(n): if de() == 6: c = c+1 return cn appels ; compteur cRenvoie l’effectif de six

Un compteur suffit pour de nombreuses répétitions : aucune liste n’est nécessaire.

6. Comment exploiter une fonction statistique que l’on n’a pas écrite ?

Une fonction fournie peut renvoyer deux valeurs, par exemple une moyenne m et un écart type s. L’affectation m,s=statistiques() associe chaque sortie au nom correspondant. Il faut ensuite interpréter leur unité et leur rôle.

Lire une fonction comme une boîte noire ne signifie pas lui faire confiance aveuglément : le contrat doit préciser la population, les données traitées et les sorties. En seconde, savoir exploiter une fonction renvoyant moyenne et écart type n’oblige pas à programmer soi-même une structure de listes.

Comment lire une fonction statistique fournie ?

m, s = statistiques()m : moyenne ; s : écart typeDeux valeurs numériques renvoyées

Le programme demande de savoir exploiter ces sorties, pas de reconstruire une gestion de listes.

Erreurs fréquentes

L'essentiel à mémoriser

  • Contrats explicites.
  • Arguments ordonnés.
  • Retour réutilisable.
  • État local.
  • Hasard modélisé.
  • Sorties interprétées.

Vérifier sa compréhension

Réponds aux 8 questions. Ton score et les réponses justes ou fausses apparaissent immédiatement.

1. Dans def somme(a,b), que sont a et b ?
2. Que permet return que print ne garantit pas ?
3. Que renvoie une fonction Python sans return explicite ?
4. Une variable locale créée dans carre(3) est-elle partagée avec carre(5) ?
5. Quelles valeurs randint(1,6) peut-il renvoyer ?
6. Que faut-il annoncer avant d’utiliser de() pour représenter un dé réel ?
7. Pour seulement compter les succès de n essais, une liste est-elle nécessaire ?
8. Après m,s=statistiques(), que représente normalement s selon le contrat étudié ?

Réviser au bon moment

Révèle chaque réponse, puis indique la difficulté de ton rappel pour programmer la prochaine révision dans ce navigateur.

Contrat d’une fonction ?

Prochaine révision : à programmer

Paramètre ou argument ?

Prochaine révision : à programmer

return ou print ?

Prochaine révision : à programmer

Variable locale ?

Prochaine révision : à programmer

randint(a,b) ?

Prochaine révision : à programmer

Compter n succès sans liste ?

Prochaine révision : à programmer

Poursuivre le parcours

  1. Avant Comment prévoir exactement ce qu’un programme Python va faire ?
  2. Tu es ici Comment construire une fonction Python fiable et réutilisable ?
  3. Ensuite Comment les problèmes ont-ils transformé les mathématiques ? Disponible avec l'accès complet

Sources et traçabilité

Dernière vérification : 2026-08-09

  1. Programme d’enseignement de mathématiques de la classe de seconde générale et technologique, Ministère de l’Éducation nationale — consulté le 2026-08-09.
  2. Annexe — Programme de mathématiques de seconde 2026, Ministère de l’Éducation nationale — consulté le 2026-08-09.
  3. Programmes et ressources en mathématiques — voie générale et technologique, Éduscol — consulté le 2026-08-09.

Tu sais construire et auditer une fonction Python

Replace maintenant ces outils dans l’histoire des idées mathématiques.

Le dernier chapitre montre comment nombres, preuves, coordonnées, probabilités et algorithmes se sont construits pour résoudre des problèmes précis.

  • Arguments et sorties contractualisés
  • Hasard distingué du réel
  • Répétitions programmées sans prérequis de listes