Algorithmes, variables et instructions Python

Variables, fonctions et listes Python en première STI2D : traces d’affectation, mesures, sélections et contrôles des unités.

Environ 35 minutes

  • Tracer des affectations
  • Identifier les entrées et sorties d’une fonction
  • Sélectionner une liste et distinguer effectif et somme
Sommaire
  1. 1. Exécuter des instructions dans l’ordre
  2. 2. Définir les entrées et la sortie d’une fonction
  3. 3. Conserver et sélectionner des mesures
  4. 4. Compter n’est pas additionner
  5. 5. Lire, vérifier et expliquer un programme

Une variable se met-elle à jour toute seule ?

Un calcul informatique dépend de l’ordre des instructions. En suivant quelques valeurs sur papier, tu peux comprendre ce que fait le programme avant de l’exécuter, puis vérifier que sa sortie répond à la question technique posée.

1. Exécuter des instructions dans l’ordre

Un algorithme décrit une suite d’instructions pour obtenir un résultat à partir de données. Python permet de traduire cette démarche en instructions exécutables. Pour comprendre un programme, commence par identifier ses entrées, les transformations effectuées et la sortie attendue. Le calcul d’une énergie, par exemple, utilise une puissance et une durée ; il doit annoncer leurs unités et les conditions dans lesquelles la relation utilisée est valable.

Une variable est un nom associé à une valeur pendant l’exécution. L’instruction tension = 12 associe le nombre 12 au nom tension. Dans tension = tension + 1, Python calcule d’abord le membre de droite avec l’ancienne valeur, puis associe le résultat à la variable. La nouvelle valeur est 13. Ce n’est pas une équation mathématique, qui demanderait ici de résoudre une égalité impossible.

L’ordre des instructions compte. Après a = 3, puis b = a + 2, b vaut 5. Si l’on exécute ensuite a = 10, b reste égal à 5 : son calcul n’est pas automatiquement refait. Une variable numérique conserve la valeur affectée jusqu’à une nouvelle affectation. Pour analyser un programme, un tableau avec une ligne par instruction permet donc de suivre les changements au lieu de deviner la valeur finale.

Le signe = réalise une affectation ; == compare deux valeurs et produit True ou False. Python distingue un entier comme 12, un nombre flottant comme 12.0 et une chaîne de caractères comme '12'. Dans le code, le séparateur décimal est le point. Les unités ne sont pas attachées automatiquement aux nombres : le nom puissance_w et une convention écrite rendent un calcul plus facile à interpréter.

Exemple résolu

On exécute successivement a = 3, b = a + 2, puis a = 10. Quelles sont les valeurs finales ? Quelle instruction supplémentaire recalculerait b avec la nouvelle valeur de a ?

  1. Étape 1 : Après la première instruction, a vaut 3. Après la deuxième, b vaut 3 + 2, donc 5.
  2. Étape 2 : La troisième instruction remplace seulement la valeur de a par 10. Aucun nouveau calcul de b n’est demandé.
  3. Étape 3 : Pour recalculer b, on doit exécuter à nouveau b = a + 2. Avec a égal à 10, on obtiendrait alors 12.

Résultat : À la fin des trois instructions données, a = 10 et b = 5.

Piège à éviter : Lire b = a + 2 comme une relation mise à jour en permanence confond affectation informatique et formule de tableur.

À toi d'essayer

On exécute x = 4, puis y = 3 * x, puis x = x + 2. Donne x et y à la fin et explique pourquoi y ne change pas.

Voir la réponse

x vaut 6 et y vaut 12. Le calcul de y a été effectué lorsque x valait 4 ; l’affectation ultérieure de x ne relance pas ce calcul.

2. Définir les entrées et la sortie d’une fonction

Une fonction rassemble un calcul réutilisable. Ses paramètres désignent les données reçues ; les arguments sont les valeurs effectivement transmises lors d’un appel. Le mot return renvoie une valeur au programme qui a appelé la fonction. Il ne signifie pas « afficher ». Une valeur retournée peut être conservée dans une variable, utilisée dans une autre expression ou affichée avec print.

Voici une fonction écrite sur une seule ligne, avec une instruction simple après les deux-points. p_w représente une puissance constante en watts et d_h une durée en heures. La fonction suppose ces données numériques et positives ou nulles. Elle convertit les wattheures en kilowattheures.

def energie(p_w, d_h): return p_w * d_h / 1000

Pour une fonction plus longue, on place les instructions suivantes sur des lignes indentées de manière cohérente. Les espaces au début des lignes indiquent alors quelles instructions appartiennent à la fonction. Le nom energie ne lance pas un calcul tout seul : energie(800, 1.5) appelle la fonction avec deux arguments. L’expression obtenue peut être affectée par e = energie(800, 1.5).

Exemple résolu

La fonction energie reçoit 800 W et une durée de 1,5 h. Détermine la valeur renvoyée et propose deux contrôles simples.

  1. Étape 1 : Les paramètres reçoivent p_w = 800 et d_h = 1.5. Le produit puissance × durée vaut 1 200 Wh.
  2. Étape 2 : La division par 1 000 donne 1,2 kWh. La fonction renvoie le nombre flottant représenté en Python par 1.2.
  3. Étape 3 : Un premier contrôle est energie(0, 3), qui doit donner 0. Un second est energie(1000, 2), qui doit donner 2.

Résultat : L’appel energie(800, 1.5) renvoie 1.2, correspondant à 1,2 kWh.

Piège à éviter : Remplacer return par print afficherait un résultat mais ne renverrait pas cette valeur numérique pour le calcul suivant.

Un test doit porter sur le calcul et sur son interprétation. Une énergie nulle pour une durée nulle est cohérente. Doubler la durée doit doubler l’énergie dans ce modèle à puissance constante. Ces vérifications ne rendent pas le modèle universel : si la puissance varie, les données et la méthode de calcul doivent être adaptées. La justesse du code et la pertinence du modèle sont deux questions distinctes.

3. Conserver et sélectionner des mesures

Une liste est une suite ordonnée de valeurs. mesures = [9.8, 10.2, 10.2, 10.5] contient quatre observations. Le premier indice est 0 : mesures[0] donne 9.8, mesures[2] donne 10.2 et mesures[3] donne 10.5. La longueur len(mesures) vaut 4, mais l’indice 4 n’existe pas. Les indices non négatifs vont donc de 0 à la longueur moins un.

Deux mesures de même valeur restent deux observations situées à deux indices différents.

L’instruction mesures.append(10.0) ajoute une cinquième observation à la fin. Pour supprimer une observation à un indice connu, mesures.pop(0) retire la première et décale les indices suivants. On vérifie donc les indices après une modification. Les répétitions sont conservées : deux relevés identiques ne sont pas une seule observation. Une liste vide s’écrit [] et sa longueur est nulle.

La compréhension [v for v in mesures if v >= 10.2] construit une nouvelle liste des valeurs au moins égales à 10,2. Le mot for parcourt les éléments et if impose le critère. La comparaison >= inclut les valeurs égales au seuil. La sélection respecte leur ordre et leurs répétitions. Une compréhension sans filtre, comme [2 * v for v in mesures], transforme chaque valeur au lieu de sélectionner une partie des observations.

À toi d'essayer

Pour valeurs = [3, 7, 12, 18], donne valeurs[2]. On ajoute ensuite 7 avec append. Quelle est la nouvelle longueur et combien de fois la valeur 7 est-elle présente ?

Correction détaillée pas à pasDans ce chapitre : 2 corrections détaillées.

4. Compter n’est pas additionner

Un compteur donne le nombre d’objets retenus. Un accumulateur conserve une somme ou un produit obtenu progressivement. Pour [2, 3, 3], l’effectif vaut 3 et la somme vaut 8. Une somme commence à 0, qui ne change pas le premier terme ajouté. Un produit commence à 1, qui ne change pas le premier facteur multiplié. Commencer un produit à 0 annulerait le résultat.

Exemple résolu

Les mesures de puissance sont [40, 60, 80, 60] W. On conserve celles qui sont au moins égales à 60 W. Détermine la liste retenue, l’effectif et la somme, puis une expression Python pour chacun des deux résultats.

  1. Étape 1 : Le test v >= 60 refuse 40 et conserve 60, 80 et 60. La liste retenues = [v for v in mesures if v >= 60] vaut donc [60, 80, 60].
  2. Étape 2 : Il y a trois observations. L’expression len(retenues) vaut 3, sans unité physique.
  3. Étape 3 : La somme est 60 + 80 + 60 = 200. L’expression sum(retenues) donne 200, avec l’unité watt dans le contexte.

Résultat : L’effectif est 3 et la somme est 200 W. Une somme de puissances n’est pas une énergie.

Piège à éviter : Éliminer la seconde valeur 60 comme un doublon modifierait à tort l’effectif et la somme des observations.

Le compteur ajoute 1 à chaque mesure retenue. La somme ajoute successivement 60, 80 puis 60.

La moyenne d’une liste de mesures comparables est sa somme divisée par son effectif, seulement si cet effectif est non nul. La moyenne conserve l’unité des valeurs. Pour une liste vide, len vaut 0 et sum vaut 0, mais leur quotient est impossible : on signale l’absence de mesures. Il ne faut pas remplacer silencieusement cette absence par une moyenne nulle, qui serait un autre résultat.

À toi d'essayer

Un programme doit calculer la puissance moyenne des appareils d’une liste. Une première liste contient [0, 0] ; une seconde est vide. Pourquoi le même résultat 0 serait-il trompeur pour les deux listes ?

Correction détaillée pas à pasDans ce chapitre : 2 corrections détaillées.

5. Lire, vérifier et expliquer un programme

Avant une exécution, prédis le résultat sur des données courtes. Après l’exécution, compare la valeur obtenue à la trace manuscrite. Si elles diffèrent, vérifie les unités, les indices et l’ordre des affectations. Un message d’erreur renseigne sur l’instruction où l’exécution échoue ; une exécution sans erreur ne garantit pas que le programme résout la bonne question.

Au bac : expliquer une démarche algorithmique

  1. Présente les entrées avec leurs unités et la sortie recherchée. Distingue un nombre de mesures d’une grandeur physique.
  2. Suis chaque affectation avec la valeur disponible à cet instant. Pour une liste, écris les indices sous les éléments.
  3. Identifie le rôle du filtre et vérifie ce qu’il fait sur une valeur égale au seuil. Conserve les observations répétées.
  4. Justifie le résultat avec une trace courte et un contrôle indépendant. Pour une liste vide, explique pourquoi une moyenne ne peut pas être calculée.
Attention :

Un indice commence à zéro ; une longueur compte tous les éléments. return fournit un résultat à l’appelant ; print sert à l’affichage. Ni le nom d’une variable ni une exécution sans erreur ne garantissent l’unité d’une grandeur.

Bilan

SituationRepère
AffectationCalculer la droite puis actualiser le nom
ListeOrdre et répétitions conservés
EffectifNombre d’observations
MoyenneSomme / effectif strictement positif

S’entraîner : retrouve les exercices sur /exercices.

À retenir

  • Une affectation évalue une expression puis associe son résultat à un nom.
  • Une liste conserve l’ordre et les répétitions ; son premier indice est 0.
  • Une fonction peut renvoyer une valeur avec return, sans l’afficher.
  • L’effectif et la somme sont deux résultats distincts.
  • Une moyenne nécessite au moins une observation.

Fiche de révision

Pour une liste de longueur 5, les indices non négatifs sont 0, 1, 2, 3 et 4.

Après x = 2 puis y = x + 1, changer x ne recalcule pas y.

Pour vérifier une fonction de calcul, choisis un cas nul et un cas dont le résultat est immédiat.

Avant une division par len(valeurs), vérifie que des données sont présentes.

Et maintenant ?

Tu as lu le cours. L’étape suivante tient en une action.

S’entraîner sur ce chapitreUn exercice dans l’espace Exercices

Prolonge l’expérience !

Continue à explorer ce chapitre à travers de nouvelles activités, des défis et des expériences interactives. Avec Premium, l’apprentissage continue !

Ici, tu débloques aussi 2 corrections détaillées.

Parent ? Suivez les progrès de votre enfant.

S’entraîner sur cette notion

Tous les cours de Première STI2D — Mathématiques technologiques
Scientia