Fiche de Synthèse SNT : Programmation Python et Correspondances Scratch

Les variables et la gestion des données

  • Définition d'une variable :

    • Une variable est un emplacement mémoire informatique qui permet de stocker des objets ou des valeurs de différents types au cours de l'exécution d'un programme.

  • Règles syntaxiques de nommage

    • Le nom d'une variable ne peut contenir que des caractères alphanumériques (lettres majuscules de A à Z, lettres minuscules de a à z, chiffres de 00 à 99) ainsi que le caractère de soulignement ou tiret du bas (_).

    • Un nom de variable ne doit jamais commencer par un chiffre.

    • Les espaces sont strictement interdits dans les identifiants de variables.

    • L'usage de mots réservés par le langage Python est interdit (par exemple : in, and, if, for, else, while).

  • Déclaration et opérateur d'affectation :

    • En Python, la déclaration d'une variable s'effectue directement en lui affectant une valeur sous la syntaxe Nom = "valeur" ou nom_variable = valeur.

    • Le symbole = ne représente pas une égalité mathématique, mais l'opérateur d'affectation qui ordonne de stocker la valeur située à droite dans la variable située à gauche.

    • En Scratch, l'affectation correspond au bloc orange affecter à [variable] la valeur [valeur].

  • Types fondamentaux de variables :

    • str (string) : chaîne de caractères représentant du texte, entourée de guillemets simples ou doubles.

    • int (integer) : nombre entier (positif, négatif ou nul), sans partie décimale.

    • float : nombre décimal (nombre à virgule flottante), représenté avec un point comme séparateur décimal.

    • list : liste ordonnée regroupant un ensemble d'éléments.

  • Outils d'inspection et de conversion de types :

    • type()\text{type}() : fonction renvoyant le type effectif de la variable passée en argument.

    • str()\text{str}() : fonction convertissant une donnée numérique ou un objet en chaîne de caractères.

    • int()\text{int}() : fonction convertissant une chaîne de caractères ou un flottant en nombre entier.

    • float()\text{float}() : fonction convertissant une donnée en nombre à virgule flottante.

  • Comparaison Scratch / Python pour la création et le stockage :

    • Stocker la valeur numérique 55 dans la variable aa :

    • En Scratch : bloc affecter à a la valeur 5.

    • En Python : instruction a = 5.

    • Stocker la chaîne de texte Bonjour ! dans la variable aa :

    • En Scratch : bloc affecter à a la valeur "Bonjour !".

    • En Python : instruction a = 'Bonjour !'.

Les entrées, les sorties et les calculs arithmétiques

  • Affichage des données (Sorties) :

    • En Scratch, l'affichage est commandé par le bloc d'aspect afficher [texte ou variable].

    • En Python, l'affichage standard à l'écran utilise la fonction print()\text{print}().

    • Afficher un texte brut : nécessite impérativement des guillemets (simples ou doubles), par exemple print('Bonjour !').

    • Afficher le contenu d'une variable : s'écrit sans guillemets en passant directement l'identifiant, par exemple print(a).

  • Saisie utilisateur (Entrées) :

    • La fonction Python input()\text{input}() permet d'interagir avec l'utilisateur en affichant une invite de commande et en suspendant le programme jusqu'à la saisie.

    • Règle fondamentale du typage à la saisie : la fonction input()\text{input}() renvoie systématiquement une chaîne de caractères (str).

    • Saisie de texte simple :

    • En Scratch : bloc affecter à boite la valeur demander un texte à l'utilisateur "Quel est ton prénom ?".

    • En Python : boite = input('Quel est ton prénom?').

    • Saisie d'un nombre entier :

    • En Scratch : bloc affecter à boite la valeur convertir demander un texte à l'utilisateur "Quel est ton âge ?" en entier (int).

    • En Python : conversion obligatoire via la fonction int()\text{int}(), soit boite = int(input('Quel est ton âge?')).

    • Saisie d'un nombre décimal :

    • En Scratch : conversion explicite du résultat de la demande utilisateur.

    • En Python : conversion obligatoire via la fonction float()\text{float}(), soit boite = float(input('Quelle est ta taille en mètres ?')).

  • Calculs arithmétiques :

    • L'opérateur de multiplication est l'astérisque *.

    • Les parenthèses sont utilisées pour définir les priorités de calcul arithmétique.

    • Exemple de calcul constant : l'opération Scratch affecter à solution la valeur 2 * (3 + 4) devient en Python solution = 2 * (3 + 4), ce qui évalue mathématiquement solution=2×(3+4)=14\text{solution} = 2 \times (3 + 4) = 14.

    • Exemple de calcul avec variable : l'opération Scratch affecter à solution la valeur 5 * (a - 6) devient en Python solution = 5 * (a - 6), traduisant la formule solution=5×(a−6)\text{solution} = 5 \times (a - 6).

Les structures conditionnelles et les tests logiques

  • Notions de prédicat et de structure de contrôle :

    • Une condition (ou prédicat) est une expression logique évaluée par le programme qui renvoie exclusivement une valeur booléenne : vrai (True) ou faux (False).

    • Les structures conditionnelles aiguillent le déroulement séquentiel du programme en exécutant des blocs d'instructions spécifiques selon le résultat du test.

  • Opérateurs de comparaison et logiques :

    • == : test d'égalité stricte (nécessite obligatoirement deux signes = successifs pour ne pas être confondu avec l'affectation).

    • != : test d'inégalité ou différence (≠\neq).

    • < : strictement inférieur.

    • > : strictement supérieur.

    • <= : inférieur ou égal (≤\le).

    • >= : supérieur ou égal (≥\ge).

    • Opérateurs logiques : and (conjonction ET), or (disjonction OU), not (négation logique NON).

  • Syntaxe des branchements conditionnels en Python :

    • if : introduit l'alternative principale (« si »).

    • elif : introduit une alternative intermédiaire (« sinon si »).

    • else : introduit le cas par défaut lorsque toutes les conditions précédentes ont été évaluées à False (« sinon »).

    • Obligation syntaxique du double-point : le caractère : est strictement obligatoire à la fin de la ligne contenant le if, le elif ou le else.

    • Obligation de l'indentation : toutes les lignes d'instructions appartenant au corps du bloc conditionnel doivent être décalées vers la droite par des espaces réguliers (indentation) pour délimiter le bloc par rapport au reste du code.

  • Équivalence d'un test simple Scratch / Python :

    • Tester la variable aa et soustraire 1010 si elle est positive, sinon ajouter 1010 :

    • En Scratch : bloc si a est positif alors affecter à a la valeur a - 10 sinon affecter à a la valeur a + 10.

    • En Python : python if a > 0: a = a - 10 else: a = a + 10 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

Tableau comparatif du test conditionnel en Scratch et Python

Les structures itératives : boucles bornées et non bornées

  • Rôle des boucles :

    • Les boucles permettent d'exécuter de façon répétée une série d'instructions.

    • Elles sont également exploitées pour parcourir séquentiellement des structures de données telles que les listes ou les chaînes de caractères.

  • Boucles bornées (for) :

    • Une boucle est dite bornée lorsque le nombre total d'itérations (répétitions) est connu à l'avance avant d'entrer dans la boucle.

    • Syntaxe générale en Python :

    for i in sequence:
        bloc d'instructions
    &nbsp;&nbsp;&nbsp;&nbsp;```
    * La variable d'itération ii prend successivement chacune des valeurs comprises dans la séquence.
    * Fonction `range(n)\text{range}(n)` : produit une suite de nn éléments entiers débutant à 00 et se terminant à n−1n - 1.
    * Exemple : répéter 1010 fois l'incrémentation de la variable aa d'une unité :
    * En Scratch : bloc de contrôle vert `répéter 10 fois affecter à a la valeur a + 1`.
    * En Python :
    

    python for i in range(10): a = a + 1       ```

    • La variable ii parcourt l'ensemble des valeurs entières (0,1,2,…,9)(0, 1, 2, \dots, 9), entraînant exactement 1010 exécutions du corps de la boucle.

  • Boucles non bornées (while) :

    • Une boucle est dite non bornée lorsque le nombre d'itérations n'est pas prévisible à l'avance, car il dépend de l'évolution dynamique d'une condition d'arrêt (« tant que »).

    • Nécessité d'une condition de sortie : pour éviter une exécution infinie (boucle infinie qui bloque le programme), la condition doit impérativement pouvoir devenir fausse au cours des répétitions.

    • Syntaxe générale en Python : python i = 0 while condition: bloc d'instructions i += 1 &nbsp;&nbsp;&nbsp;&nbsp;

    • Rôle des instructions de contrôle :

    • i = 0 : initialisation de la variable de contrôle avant d'entamer la boucle.

    • i += 1 : notation équivalente à i=i+1i = i + 1, permettant d'incrémenter la valeur de la variable d'une unité à chaque passage.

    • Exemple : répéter l'ajout de 11 à aa tant que la valeur reste inférieure à 1010 :

    • En Scratch : bloc répéter tant que a < 10 affecter à a la valeur a + 1.

    • En Python : python while a < 10: a = a + 1 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

Tableau comparatif des boucles for et while entre Scratch et Python

Les fonctions et les modules

  • Notions fondamentales :

    • Une fonction est un sous-programme autonome accomplissant une tâche précise et réutilisable.

    • Définir une fonction consiste à décrire formellement à la machine la suite d'instructions qu'elle doit exécuter.

    • Procédure : terme désignant spécifiquement une fonction qui ne renvoie aucun résultat au programme appelant.

    • Appel de fonction : opération exécutant le code interne contenu dans le corps de la fonction.

  • Syntaxe de définition et de renvoi :

    • Mot-clé def : initialise la déclaration de la fonction.

    • Fonction sans paramètre : déclarée sous la forme def nom_de_la_fonction():.

    • Fonction avec paramètres : déclarée sous la forme def nom_de_la_fonction(a, b):, où aa et bb représentent les arguments passés à la fonction.

    • Caractère : obligatoire : clôture systématiquement la ligne d'en-tête def.

    • Indentation obligatoire : les instructions internes à la fonction doivent être décalées vers la droite.

    • Mot-clé return : commande obligatoire permettant de renvoyer le résultat calculé au programme principal.

  • Appel et stockage du résultat :

    • Appel sans argument : afficher_bonjour() ou de_6_faces().

    • Appel avec arguments : de_n_faces(16).

    • Récupération dans une variable : resultat = fonction() stocke la valeur issue de l'instruction return dans la variable resultat.

  • Modules et bibliothèques standard :

    • Une bibliothèque (ou module) est un ensemble prêt à l'emploi de fonctions, classes et constantes externes pouvant être incorporées dans un script.

    • Exemples de bibliothèques courantes : math, random, tkinter, micro:bit.

    • Importation globale : import random permet d'accéder aux fonctionnalités en utilisant le préfixe du module, par exemple random.randint() ou random.randrange().

    • Importation ciblée : from random import randint charge directement la fonction sans nécessiter le préfixe.

  • Exemples comparatifs de fonctions en Scratch et Python :

    • Fonction de simulation d'un dé à 66 faces sans paramètre :

    • En Scratch : bloc personnalisé vert définir de_6_faces contenant affecter à aleat la valeur entier aléatoire entre 1 et 6 puis retour aleat.

    • En Python : python def de_6_faces(): aleat = randint(1, 6) return aleat &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

    • Appel correspondant : de_6_faces() en Python.

    • Fonction de simulation d'un dé à nn faces avec paramètre :

    • En Scratch : bloc définir de_n_faces avec var: n contenant affecter à aleat la valeur entier aléatoire entre 1 et n puis retour aleat.

    • En Python : python def de_n_faces(n): aleat = randint(1, n) return aleat &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

    • Appel avec une valeur de 1616 faces : de_n_faces(16).

Tableau comparatif de l'écriture et de l'appel de fonctions en Scratch et Python

Projet d'application : Algorithme du nombre mystère

  • Cahier des charges du projet :

    • Choisir aléatoirement un nombre entier secret compris entre 11 et 100100.

    • Guider l'utilisateur jusqu'à la découverte de la cible en lui indiquant à chaque proposition si son estimation est trop grande ou trop petite.

    • Répéter les saisies tant que la valeur soumise diffère du nombre mystère.

    • Conclure par un message de victoire dès que le nombre exact est identifié.

  • Implémentation pas à pas en Scratch :

    • Sélection du nombre secret : affecter à nombre_inconnu la valeur entier aléatoire entre 1 et 101 (Scratch générant une valeur inclusive entre 11 et 100100).

    • Affichage de la consigne : afficher "Ta mission : découvrir un nombre mystère compris...".

    • Première entrée : affecter à proposition la valeur convertir demander un texte à l'utilisateur "saisis ta proposition :" en entier (int).

    • Boucle conditionnelle : répéter tant que proposition != nombre_inconnu :

    • Test supérieur : si proposition > nombre_inconnu alors afficher "Ta proposition est trop grande".

    • Alternative inférieure : sinon afficher "Ta proposition est trop petite".

    • Nouvelle saisie dans la boucle : affecter à proposition la valeur convertir demander un texte à l'utilisateur "Retente une nouvelle proposition :" en entier (int).

    • Sortie de boucle : afficher "YOU WIN, BRAVO !".

Algorithme Scratch du jeu du nombre mystère
  • Implémentation équivalente en script Python :

    • Chargement du module : import random.

    • Génération aléatoire : nombre_inconnu = random.randrange(1, 101) (génère un entier compris entre 11 inclus et 101101 exclu, soit jusqu'à 100100).

    • Affichage initial : print("Ta mission : découvrir un nombre mystère compris entre 1 et 100 en un minimum d'essais").

    • Demande initiale typée en entier : proposition = int(input('saisis ta proposition : ')).

    • Boucle while avec condition de poursuite proposition != nombre_inconnu: :

    • Bloc if proposition > nombre_inconnu: affichant print('Ta proposition est trop grande').

    • Bloc else: affichant print('Ta proposition est trop petite').

    • Réitération de l'entrée : proposition = int(input('Retente une nouvelle proposition : ')).

    • Clôture du programme hors indentation de la boucle : print('YOU WIN, BRAVO !').

Script Python du jeu du nombre mystère