Axe : Textes Sections : Sc. Expérimentales, Mathématiques & Sc. Techniques Durée : 70 min Conventions 2024-2025

Séance 2 : Types caractère & chaîne de caractères

Indiçage base 0, fonctions prédéfinies textuelles, découpage par slicing et traitement de chaînes en Python.

Objectifs didactiques de la séance :
  • Maîtriser l'indiçage base 0 des chaînes de caractères (0 ≤ i < Long(Ch)).
  • Employer les fonctions prédéfinies textuelles (Long, Pos, Sous_chaine, Effacer, Majus, Convch, Estnum, Valeur, Ord, Chr).
  • Traduire ces traitements textuels en Python selon les conventions officielles (len, .find, slicing [d:f], .upper(), .isdecimal(), str(), int(), etc.).
  • Formaliser l'algorithme avec son TDO et exécuter le script sans erreur de syntaxe.
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 situation-problème

10 minutes
Énoncé au tableau
« Une application reçoit un code d'inscription sous la forme d'une chaîne, par exemple "info-2026". On souhaite vérifier si le suffixe après le tiret "-" est bien composé uniquement de chiffres, mettre le préfixe en majuscules ("INFO"), convertir l'année en entier pour calculer l'année suivante, puis afficher le code mis à jour sous la forme "INFO-2027". »
Cette situation permet de mobiliser les traitements textuels fondamentaux : recherche de séparateur, extraction de tranches, validation numérique, conversion de types et assemblage par concaténation.
Décomposition du traitement textuel :
  • 1
    Localisation du séparateur : Recherche de la position du tiret "-" avec Pos / .find().
  • 2
    Découpage préfixe / suffixe : Extraction sans boucle avec Sous_chaine / slicing [d:f].
  • 3
    Validation & Conversion de l'année : Vérification avec Estnum / isdecimal(), conversion via Valeur / int() et incrémentation (+ 1).
  • 4
    Recomposition du nouveau code : Majuscules avec Majus / .upper(), conversion avec Convch / str() et concaténation +.
Transformation Visuelle
"info-2026" "INFO-2027"
• Préfixe : "info" → "INFO"
• Séparateur : "-" (indice 4)
• Suffixe : "2026" → 2026 + 1 = 2027
Questionnement oral (cliquez pour afficher la réponse didactique) :
{{ q.question }}
En Algorithmique :
{{ q.algoAns }}
En Python 3 :
{{ q.pyAns }}
Étape 2

Tableau de correspondance : Algorithmique ↔ Python

15 minutes

Mise au point sur les équivalences normatives officielles pour les caractères et les chaînes de caractères (Conventions 2024-2025) :

Notion / Opération Algorithmique (Norme) Python (Conventions 2024-2025)
Longueur Long(ch) len(ch)
Recherche de position Pos(ch1, ch2) (retourne -1 si absent) ch2.find(ch1)
Extraction (slicing) Sous_chaine(ch, d, f) position f exclue ch[d:f]
Suppression Effacer(ch, d, f) ch = ch[:d] + ch[f:]
Passage en majuscules Majus(ch) ch.upper()
Test numérique Estnum(ch) ch.isdecimal()
Conversion en nombre Valeur(ch) int(ch) ou float(ch)
Conversion en chaîne Convch(x) str(x)
Code ASCII / Caractère Ord(c)
Chr(d)		 ord(c)
chr(d)
Rappels didactiques majeurs :
  • Indiçage en base 0 : Le premier caractère d'une chaîne Ch est situé à l'indice 0 (notation Ch[i] avec 0 ≤ i < Long(Ch)).
  • Borne finale exclue : Tant en algorithmique (Sous_chaine(ch, d, f)) qu'en Python (ch[d:f]), le caractère à la position finale f est toujours exclu.
  • Type unique en Python : En Python, il n'existe pas de type caractère distinct : un caractère est simplement représenté comme une chaîne de longueur 1 de type str.
Pos vs .find()

Si la sous-chaîne n'est pas trouvée, Pos et .find() retournent impérativement -1 (et non 0).

Pos("x", "bac") = -1
"bac".find("x") == -1
Sous_chaine vs [d:f]

L'extraction de d à f comporte f - d caractères.

Sous_chaine("info", 1, 3) = "nf"
"info"[1:3] == "nf"
Effacer vs Immuabilité

En Python, les chaînes étant immuables, on découpe et concatène sans la tranche supprimée.

# Supprime de 0 à 4 exclu :
ch = ch[:0] + ch[4:]
Étape 3

Conception algorithmique & T.D.O. Standard

20 minutes

Élaboration collective de la solution au tableau : respect strict de la syntaxe officielle et des types de données.

ALGORITHME MajCode Algorithme Principal 
ALGORITHME MajCode
DEBUT
    Écrire("Donner le code (ex: info-2026) : ")
    Lire(code)
    
    p ← Pos("-", code)
    prefixe ← Sous_chaine(code, 0, p)
    suffixe ← Sous_chaine(code, p + 1, Long(code))
    
    valide ← Estnum(suffixe)
    annee ← Valeur(suffixe)
    nouvelle_annee ← annee + 1
    
    nouveau_code ← Majus(prefixe) + "-" + Convch(nouvelle_annee)
    
    Écrire("Suffixe numérique valide : ", valide)
    Écrire("Nouveau code : ", nouveau_code)
FIN
T.D.O. Standard Objets Globaux
Objet Type / Nature
code, prefixe, suffixe, nouveau_code Chaîne de caractères
p, annee, nouvelle_annee Entier
valide Booléen
Commentaires méthodologiques :
  • p : Position du tiret (Entier ≥ 0).
  • valide : Booléen résultant de Estnum(suffixe).
  • annee : Converti en Entier pour autoriser l'addition arithmétique + 1.
Étape 4

Traduction, Exécution sur machine & Laboratoire

20 minutes

Saisie individuelle du script Python par les élèves dans leur environnement de travail (Thonny, VS Code ou IDLE) :

maj_code.py 
# Saisie du code initial
code = input("Donner le code (ex: info-2026) : ")

# Recherche du séparateur et extraction
p = code.find("-")
prefixe = code[0:p]
suffixe = code[p + 1:len(code)]

# Vérification et conversions
valide = suffixe.isdecimal()
annee = int(suffixe)
nouvelle_annee = annee + 1

# Formatage final
nouveau_code = prefixe.upper() + "-" + str(nouvelle_annee)

# Affichage
print("Suffixe numérique valide :", valide)
print("Nouveau code :", nouveau_code)
Points d'attention & Vigilance enseignant
Gestion des indices du slicing :
Vérifier l'expression code[p + 1:len(code)] ou la forme équivalente code[p + 1:]. La position p (le tiret) doit être sautée (+ 1).
Interdiction des fonctions hors convention :
Veiller à ce que les élèves n'emploient aucune fonction non agréée : utiliser exclusivement isdecimal() (et non pas isdigit()), et proscrire formellement la méthode .replace().
Sécurisation avant conversion :
Rappeler l'intérêt majeur de isdecimal() avant int() pour éviter une erreur fatale ValueError lors de la saisie d'un suffixe contenant des lettres.
Simulateur Interactif : Décomposition indicée & Traitement en direct
Exemples :
code =
Décomposition indicée des caractères (Base 0) :
{{ item.char === ' ' ? '␣' : item.char }} {{ item.index }}
Préfixe [0:p] Séparateur (p) Suffixe [p+1:len]
Résultats des étapes :
Longueur totale (len(code)) : {{ cleanInput.length }} caractères
Position du tiret (code.find("-")) : {{ hasSep ? sepIndex : '-1 (absent)' }}
Préfixe extrait (code[0:p]) : "{{ prefixeExtrait }}" → "{{ prefixeExtrait.toUpperCase() }}"
Suffixe extrait (code[p+1:]) : "{{ suffixeExtrait }}"
Validité numérique (isdecimal()) : {{ isSuffixNumeric ? 'Vrai / True (chiffres uniquement)' : 'Faux / False' }}
Incrémentation d'année : {{ isSuffixNumeric ? parsedYear + ' + 1 = ' + nextYear : 'Impossible (non numérique)' }}
Sortie console Python (Terminal)
Donner le code (ex: info-2026) : {{ cleanInput }} Suffixe numérique valide : {{ isSuffixNumeric ? 'True' : 'False' }} Nouveau code : {{ nouveauCode }}
Étape 5

Bilan, Synthèse d'ancrage et Auto-évaluation

5 minutes
Contrôle oral rapide (Questions Flash de clôture) :
Question didactique
{{ f.expr }}
Afficher la réponse
Algo : {{ f.resAlgo }}
{{ f.resPy }}
{{ f.type }}

Quiz d'auto-évaluation interactif

Testez vos acquis sur l'indiçage base 0, les primitives textuelles et les équivalents Python.
Score : {{ quizScore }} / {{ quizQuestions.length }}
Q{{ idx + 1 }}. {{ q.question }}
{{ opt }}
Explication didactique : {{ q.explanation }}
Étape {{ currentPhase }} sur {{ phases.length }} {{ phases[currentPhase - 1].shortTitle }}