Séance 1 : Types scalaires, fonctions prédéfinies arithmétiques & TDO

Phase {{ currentPhase === 'all' ? 'Toutes' : currentPhase + ' / ' + phases.length }}

Phase active :

{{ currentPhase === 'all' ? 'Vue complète (Toutes les phases affichées)' : phases[currentPhase - 1].title }}

Étape 1

Accroche et réactivation didactique

10 minutes

Situation-problème au tableau

« Calculer la distance euclidienne entre l'origine (0,0) et un point (X, Y) généré aléatoirement entre -10 et 10, puis déterminer si son arrondi entier est un nombre pair. »

Cette situation concrète permet de mobiliser les coordonnées cartésiennes, la génération aléatoire, le calcul de puissances, la racine carrée, l'arrondi et le test de divisibilité par 2.

Décomposition de la résolution :

1
Génération aléatoire : X ∈ [-10, 10] et Y ∈ [-10, 10].
2
Distance euclidienne : Formule mathématique d = √(X² + Y²).
3
Arrondi entier : Rapprochement à l'entier le plus proche (d_arrondi).
4
Test de parité : Vérification si d_arrondi Mod 2 = 0.

Formule Mathématique

d = √(x² + y²)

est_pair ⇔ (Arrondi(d) Mod 2 = 0)

Modèle Pythagoricien dans le plan cartésien (ℝ²)

Questions orales d'accroche (cliquez pour afficher la réponse didactique) :

En Algorithmique :

En Python 3 :

Étape 2

Synthèse des correspondances normatives : Algorithmique ↔ Python

15 minutes

Présentation au tableau des équivalences normatives officielles issues des conventions 2024-2025 de l'Inspection Générale :

Notion / Opération	Algorithmique (Norme Officielle)	Python (Conventions 2024-2025)
Entrée / Sortie	`Lire(x)` `Écrire(x)`	`x = int(input())` / `x = float(input())` `print(x)`
Division entière & Reste	`q ← a Div b` `r ← a Mod b`	`q = a // b` `r = a % b`
Racine carrée	`RacineCarré(x)`	`sqrt(x)` via from math import sqrt
Entier aléatoire	`Aléa(vi, vf)`	`randint(vi, vf)` via from random import randint
Arrondi / Partie entière	`Arrondi(x)` `Ent(x)`	`round(x)` `int(x)`
Valeur absolue	`Abs(x)`	`abs(x)`

Rappel clé fondamental (Différence conceptuelle majeure) :

Toute variable manipulée en algorithmique doit impérativement être recensée et typée dans le T.D.O. (Tableau de Déclaration des Objets).
À l'inverse, en Python, les variables ne sont pas déclarées au préalable : c'est l'affectation dynamique qui définit automatiquement leur type en mémoire selon la valeur reçue.

Détails et subtilités d'usage :

Aléa(vi, vf) vs randint

L'intervalle est fermé : les deux bornes vi et vf font partie intégrante des valeurs possibles.

# -10 et 10 peuvent être tirés :
x = randint(-10, 10)

Arrondi(x) vs Ent(x)

Arrondi(x) cherche l'entier le plus proche, alors que Ent(x) tronque la partie décimale.

Arrondi(4.6) = 5 | round(4.6) = 5
Ent(4.6) = 4 | int(4.6) = 4

Div / Mod vs // / %

La division euclidienne dans les entiers relie dividende, diviseur, quotient et reste : a = b * q + r.

14 Div 3 = 4 | 14 // 3 = 4
14 Mod 3 = 2 | 14 % 3 = 2

Étape 3

Élaboration de l'Algorithme et du T.D.O. Standard

20 minutes

Construction collective au tableau : écriture formelle respectant la casse, l'indentation et la nomenclature conventionnelle.

ALGORITHME DistancePoint Algorithme Principal

ALGORITHME DistancePoint
DEBUT
    x ← Aléa(-10, 10)
    y ← Aléa(-10, 10)
    d ← RacineCarré(x * x + y * y)
    d_arrondi ← Arrondi(d)
    est_pair ← (d_arrondi Mod 2 = 0)
    Écrire("Coordonnées : (", x, ", ", y, ")")
    Écrire("Distance réelle : ", d)
    Écrire("Distance arrondie : ", d_arrondi)
    Écrire("Distance paire ? ", est_pair)
FIN

T.D.O. Standard Déclaration formelle

Objet	Type / Nature
x, y, d_arrondi	Entier
d	Réel
est_pair	Booléen

Analyse des types scalaires :

Entier : Coordonnées aléatoires sans virgule et distance arrondie.
Réel : La racine carrée peut donner un nombre décimal flottant.
Booléen : Résultat d'une assertion logique ne prenant que Vrai ou Faux.

Étape 4

Implémentation sur machine, Débogage & Laboratoire

20 minutes

Les élèves saisissent et exécutent le code Python dans leur IDE (Thonny, VS Code ou IDLE).

distance_point.py

from math import sqrt
from random import randint

# Tirage aléatoire des coordonnées entre -10 et 10
x = randint(-10, 10)
y = randint(-10, 10)

# Traitement arithmétique
d = sqrt(x * x + y * y)
d_arrondi = round(d)
est_pair = (d_arrondi % 2 == 0)

# Affichage des résultats
print("Coordonnées : (", x, ",", y, ")")
print("Distance réelle :", d)
print("Distance arrondie :", d_arrondi)
print("Distance paire ? :", est_pair)

Pièges fréquents & Intervention de l'enseignant

Oubli des importations :
NameError: name 'sqrt' is not defined
→ Correction : Ajouter impérativement from math import sqrt et from random import randint en haut de fichier.

Erreurs de casse (Sensibilité à la casse) :
NameError: name 'Round' is not defined
→ Correction : Python distingue strictement minuscules et majuscules. Écrire round, sqrt, abs en minuscules.

Confusion d'opérateurs (= vs == et / vs //) :
→ Le test d'égalité s'écrit == et non =. Le reste s'exprime avec % et non mod.

Simulateur Interactif : Repère Cartésien & Calculs en temps réel

Repère orthonormé [-10, 10] × [-10, 10].

Coordonnée X :

Coordonnée Y :

Somme des carrés (x² + y²) : ({{ simPoint.x }})² + ({{ simPoint.y }})² = {{ simSumSq }}

Distance réelle (d = √(x² + y²)) : {{ simDist.toFixed(4) }}

Arrondi entier (d_arrondi = round(d)) : {{ simDistRounded }}

Parité (d_arrondi % 2 == 0) : {{ simIsEven ? 'PAIR (Vrai / True)' : 'IMPAIR (Faux / False)' }}

Sortie console Python (Terminal)

Coordonnées : ( {{ simPoint.x }} , {{ simPoint.y }} ) Distance réelle : {{ simDist }} Distance arrondie : {{ simDistRounded }} Distance paire ? : {{ simIsEven ? 'True' : 'False' }}

Étape 5

Bilan, Clôture et Auto-évaluation

5 minutes

Contrôle oral rapide (Questions Flash de clôture) :

Expression

Afficher la solution

Algo : {{ f.resAlgo }}

Quiz d'auto-évaluation interactif

Testez vos compétences sur les types scalaires, la division euclidienne et les fonctions arithmétiques.

Score : {{ quizScore }} / {{ quizQuestions.length }}

Q{{ idx + 1 }}. {{ q.question }}

Explication didactique : {{ q.explanation }}