Programmer pour explorer le numérique

Utiliser les variables, conditions, boucles et fonctions Python pour traiter des tailles de données et vérifier les résultats.

Environ 30 minutes

  • Suivre des affectations
  • Écrire et tester une condition
  • Utiliser des boucles
  • Définir et appeler une fonction
Sommaire
  1. Décrire un traitement avant de programmer
  2. Exprimer une condition et vérifier ses frontières
  3. Répéter un traitement avec une boucle
  4. Définir et appeler une fonction
  5. Vocabulaire, erreurs et bilan

Comment vérifier qu’un programme fait ce que tu veux, et pas seulement qu’il s’exécute ?

Tu vas traduire de petits traitements de tailles de données en instructions Python. Le fil conducteur consiste à prévoir les résultats, suivre les valeurs et tester les cas qui peuvent révéler une erreur, avant de réutiliser ces outils dans les thèmes de SNT.

Décrire un traitement avant de programmer

Un algorithme décrit une suite d’opérations permettant de résoudre un problème. Un programme exprime ce traitement dans un langage que la machine peut exécuter. En SNT, programmer aide à explorer les données, les images ou les réseaux. Il faut d’abord préciser les données d’entrée, le résultat attendu et les étapes du traitement. Un programme qui s’exécute sans erreur de syntaxe peut encore produire un résultat incorrect.

Python distingue plusieurs types de valeurs. Un entier représente par exemple un nombre de fichiers ; un nombre à virgule flottante peut représenter une mesure ; une chaîne de caractères contient du texte ; un booléen vaut True ou False. Les guillemets délimitent une chaîne. La chaîne composée des caractères 1 et 2 n’est pas l’entier 12 : les opérations disponibles et leur sens dépendent du type.

Une variable est un nom associé à une valeur. L’affectation utilise le signe = et commence par évaluer l’expression située à droite, puis associe le résultat au nom de gauche. Si compteur vaut 2, l’instruction compteur = compteur + 1 le fait passer à 3. Cette écriture n’est pas une égalité mathématique à résoudre. L’ordre des instructions est donc essentiel pour comprendre l’état du programme.

Chaque affectation remplace la valeur précédente de compteur. La barre nulle correspond à l’état initial.

Exemple résolu

Un script utilise une taille de 4 Kio. Dans cette activité, 1 Kio vaut 1 024 octets. Calcule la taille en octets avec les instructions suivantes.

  1. Étape 1 : Associer la taille initiale au nom taille.taille = 4
  2. Étape 2 : Calculer puis mémoriser la conversion.octets = taille * 1024
  3. Étape 3 : Afficher le résultat mémorisé.print(octets)

Résultat : Le programme affiche 4096. La variable taille reste égale à 4 et octets vaut 4096. Les unités donnent le sens de ces nombres.

Piège à éviter : Le mot octets est un nom de variable choisi par la personne qui programme ; Python ne vérifie pas automatiquement l’unité physique.

À toi d'essayer

Une variable n vaut 3. On exécute n = n + 2 puis n = n * 4. Quelle est sa valeur finale ? Pourquoi ne faut-il pas calculer les deux opérations à partir de 3 ?

Voir la réponse

La première instruction donne 5 ; la seconde utilise cette nouvelle valeur et donne 20. La machine suit la séquence, elle ne conserve pas implicitement 3 comme valeur à employer à chaque ligne.

Exprimer une condition et vérifier ses frontières

Une comparaison produit un booléen. Le double signe == teste l’égalité, tandis que = affecte une valeur. Les opérateurs <, >, <= et >= comparent des valeurs. La condition d’une instruction if choisit si un bloc doit être exécuté. Une partie else permet de traiter le cas contraire. Les deux-points terminent la ligne qui ouvre le bloc ; l’indentation indique quelles instructions en font partie.

Supposons qu’une application autorise une taille inférieure ou égale à 10 unités. Le test taille <= 10 inclut exactement 10. Utiliser taille < 10 le refuserait. Pour vérifier la frontière, on essaie 9, 10 et 11. Ce choix de tests distingue les deux programmes, contrairement à un essai unique avec 4. Il faut aussi décider quelles entrées sont autorisées : une taille négative n’a pas le sens attendu dans cet exemple.

Une condition doit être écrite dans le vocabulaire exact du langage. Les booléens True et False prennent une majuscule. Pour une saisie au clavier, input renvoie une chaîne ; une conversion comme int est nécessaire si l’on veut effectuer certains calculs sur un entier. Une conversion peut échouer si le texte n’est pas compatible : il faut suivre les consignes de saisie de l’activité ou prévoir un traitement de cette situation.

Vers le bac : lire et tester un programme

  1. Nomme les entrées, leur type et le résultat attendu.
  2. Trace les valeurs après chaque affectation dans un tableau de suivi.
  3. Pour une condition, teste un cas vrai, un cas faux et la frontière.
  4. Compare le résultat calculé à la main avec celui obtenu en exécutant le programme.
  5. Explique l’erreur par une instruction précise avant de proposer une correction.

Répéter un traitement avec une boucle

Une boucle for parcourt des valeurs dans l’ordre. Avec range(3), elle utilise successivement 0, 1 et 2 : la borne de fin est exclue. Si le bloc comporte une instruction, celle-ci est exécutée trois fois. Le nom choisi pour parcourir les valeurs change à chaque passage. Une boucle ne répète que les lignes de son bloc, repérées par l’indentation dans une écriture sur plusieurs lignes.

Une boucle while répète son bloc tant qu’une condition est vraie. Il faut examiner ce qui fait évoluer cette condition et permet l’arrêt. Si compteur commence à 0 et augmente de 1 tant qu’il est strictement inférieur à 3, les valeurs après les passages sont 1, 2 et 3. La condition devient alors fausse. Oublier la mise à jour peut provoquer une boucle qui ne se termine pas.

Un accumulateur mémorise un résultat construit progressivement. Pour additionner des tailles de messages, on l’initialise à zéro avant la boucle. À chaque passage, on lui ajoute la taille courante. Le remettre à zéro dans la boucle ferait perdre les sommes précédentes. On peut prévoir le résultat à la main avant d’exécuter le script, ce qui fournit une vérification indépendante du traitement.

L’accumulateur conserve la somme précédente avant d’ajouter la nouvelle taille. Le total final est 17 unités.

Exemple résolu

Additionne les tailles 3, 5 et 9 avec une boucle. Les instructions de boucle sont ici écrites sur une seule ligne, une syntaxe possible pour un bloc simple.

  1. Étape 1 : Initialiser avant la répétition.total = 0
  2. Étape 2 : Ajouter chaque taille au total courant.for taille in [3, 5, 9]: total = total + taille
  3. Étape 3 : Afficher après la boucle.print(total)

Résultat : Le programme affiche 17. Après chaque passage, total vaut respectivement 3, 8 et 17, comme sur le graphique.

Piège à éviter : Placer total = 0 dans le bloc répété supprimerait l’accumulation.

À toi d'essayer

Une boucle doit afficher les nombres 1, 2, 3 et 4. Quel appel de range convient, et pourquoi range(4) ne produit-il pas cette suite ?

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

Définir et appeler une fonction

Une fonction regroupe un traitement réutilisable. On la définit avec def, un nom, des parenthèses contenant les paramètres, puis des deux-points. Un paramètre reçoit une valeur lors d’un appel. L’instruction return termine l’exécution de la fonction et renvoie son résultat. Définir la fonction ne suffit pas à effectuer tous les calculs possibles : il faut ensuite l’appeler avec les arguments souhaités.

Afficher et renvoyer sont deux opérations différentes. print rend une valeur visible à l’écran. return permet au programme appelant de réutiliser un résultat dans un autre calcul. Une fonction qui affiche seulement une valeur ne la renvoie pas automatiquement comme résultat numérique. Cette distinction devient utile lorsque plusieurs traitements se suivent, par exemple convertir une taille puis comparer le résultat à une limite.

Exemple résolu

Écris une fonction de conversion de Kio en octets, appelle-la pour 5 Kio puis réutilise son résultat.

  1. Étape 1 : Définir une fonction avec un paramètre et un retour, ici sur une seule ligne.def convertir(kio): return kio * 1024
  2. Étape 2 : Appeler la fonction et affecter le résultat.volume = convertir(5)
  3. Étape 3 : Afficher une comparaison avec une limite de 6000 octets.print(volume <= 6000)

Résultat : La fonction renvoie 5120 pour l’argument 5. volume vaut donc 5120 et la comparaison affichée vaut True.

Piège à éviter : Remplacer return par print ferait afficher 5120 mais ne fournirait plus ce nombre comme valeur de retour à comparer.

Les noms utilisés comme paramètres sont locaux à l’appel de la fonction. Il est préférable qu’une petite fonction calcule à partir de ses paramètres et renvoie un résultat explicite. Cela facilite les essais. Pour une conversion, on peut vérifier 0, 1 et 5 puis comparer les résultats attendus. Ces tests n’épuisent pas toutes les entrées possibles, mais ils mettent à l’épreuve les cas choisis.

À toi d'essayer

Une fonction doit compter les messages dont la taille dépasse strictement 8 unités. Pour les tailles 8, 9, 2 et 12, quel résultat attends-tu ? Quel test faut-il utiliser et où initialiser le compteur ?

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

Vocabulaire, erreurs et bilan

Vocabulaire

Affectation :
Association d’un nom au résultat d’une expression.
Booléen :
Valeur logique True ou False.
Boucle :
Structure répétant un bloc d’instructions.
Paramètre :
Nom recevant une valeur lors d’un appel de fonction.
Retour :
Résultat transmis par une fonction au programme appelant.
Attention :

Confondre = et == change le rôle d’une instruction. La borne finale de range est exclue. Un accumulateur se prépare avant la répétition. L’indentation délimite les blocs. Afficher une valeur ne remplace pas son retour par une fonction.

Bilan

BesoinOutil
Mémoriser un résultatVariable et affectation
Choisir un traitementCondition
RépéterBoucle bornée ou conditionnelle
Réutiliser un traitementFonction avec paramètres et retour

À retenir

  • Une affectation évalue d’abord l’expression puis associe sa valeur au nom choisi.
  • Une condition produit un choix à partir d’une valeur logique.
  • Une boucle répète les instructions de son bloc ; range exclut sa borne de fin.
  • Une fonction peut recevoir des paramètres et renvoyer un résultat avec return.

Fiche de révision

Dessiner la succession des états permet de comprendre une mise à jour.

Pour une limite inclusive, essayer la valeur limite et ses voisines.

Commencer une somme à zéro puis ajouter chaque donnée conserve les résultats intermédiaires.

Séparer calcul, retour et affichage facilite la réutilisation et les tests.

Et maintenant ?

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

Relis le coursLes exercices de ce chapitre arrivent bientôt.

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.

Tous les cours de SNT
Ketty