1.5Formation complète en fil rouge
L'essentiel en 30 secondes
- Consolider = assembler : variables + conditions + boucles + fonctions dans un seul programme — de la syntaxe au savoir-construire.
- Verbes → fonctions, menu → main : un verbe = une fonction, le main ne contient que la boucle du menu qui appelle.
- 80 lignes seul = socle acquis : pseudo-code d'abord, if __name__ == "__main__" systématique, pont vers fichiers (N2) et tests (N3).
Mini-cas filé — Nabil livre son carnet d'adresses à Alger
Nabil doit livrer un carnet d'adresses pour son équipe : ajouter, chercher, lister, supprimer, quitter. Il écrit d'abord 80 lignes en vrac avec le menu copié-collé cinq fois — et un bug de suppression se répète partout. Il découpe : un verbe = une fonction (ajouter, chercher, lister, supprimer), un main() avec la boucle du menu, des contacts en dictionnaires, et if __name__ == "__main__" pour protéger l'import. Le carnet tourne seul, sera sauvegardé en JSON au niveau 2 et testé au niveau 3 : le fil rouge du guide est lancé.
Capstone du niveau — Nabil réinvestit 1.1 (variables), 1.2 (menu en conditions), 1.3 (boucles) et 1.4 (fonctions).
1. Assembler le socle : le mini-projet carnet d'adresses
Ce chapitre est une respiration consolidante : variables (contacts en dictionnaires), conditions (menu), boucles (affichage et boucle du menu), fonctions (ajouter, chercher, lister, supprimer) — ce projet assemble tout le niveau 1 en ~80 lignes. C'est le test : si vous le codez seul, sans copier, en expliquant chaque ligne, le socle est acquis.
Nabil choisit le carnet d'adresses plutôt que le jeu du nombre mystère : il servira à son équipe, et chaque fonction sera réinvestie aux niveaux suivants.
2. Découper avant de coder, pont vers la suite
Listez les verbes (ajouter, chercher, lister, supprimer, quitter) : un verbe = une fonction. Le main() ne contient que la boucle du menu qui appelle. Écrivez le pseudo-code en français avant de coder, protégez l'import avec if __name__ == "__main__". Ce carnet reviendra au niveau 2 (fichiers : sauvegarder en JSON), au niveau 3 (tests : prouver les fonctions) : chaque niveau réinvestit au lieu de repartir de zéro.
Nabil écrit son pseudo-code en cinq lignes, code une fonction par verbe, et note déjà « JSON au N2, pytest au N3 » : le fil rouge traverse le guide.
🔎 Exemple concret — 🔎 Exemple concret — Squelette du carnet
La structure qui prouve le socle, comme Nabil pour son équipe.
contacts = []
def ajouter(nom, tel):
contacts.append({"nom": nom, "tel": tel})
def chercher(nom):
return [c for c in contacts if c["nom"] == nom]
def lister():
for c in contacts:
print(f"{c['nom']} : {c['tel']}")
def main():
while True:
choix = input("1-ajouter 2-chercher 3-lister 0-quitter ? ")
if choix == "0":
break
elif choix == "3":
lister()
if __name__ == "__main__":
main()Lecture : le if __name__ protège l'import futur ; la compréhension filtre en une ligne.
Leçon : coder d'abord, relire ensuite — messages clairs, essais et cas affichés.
Vocabulaire de la section
- Consolidation
- Ré-employer plusieurs notions ensemble dans un même programme, jusqu'à ce qu'elles deviennent des réflexes.
Exemple simple : Le carnet de Nabil qui mobilise les quatre chapitres.
Ce que ce n'est pas : dix exercices isolés jamais recombinés.
Réflexe : un projet complet vaut dix exercices.
- Fil rouge
- Projet suivi qui traverse l'apprentissage et donne du sens à chaque notion en la mettant en application.
Exemple simple : Le carnet de Nabil, repris en JSON (N2) puis en tests (N3).
Ce que ce n'est pas : un projet jetable abandonné à chaque niveau.
Réflexe : réinvestir plutôt que repartir de zéro.
- Décomposition
- Découper un problème en petites étapes/fonctions simples : la compétence clé du programmeur. Un verbe = une fonction.
Exemple simple : Les ajouter/chercher/lister/supprimer de Nabil.
Ce que ce n'est pas : écrire 80 lignes d'un coup devant la page blanche.
Réflexe : lister les verbes avant de coder.
- Pseudo-code
- Décrire les étapes d'un programme en langage courant avant de le coder : clarifie la logique sans la syntaxe.
Exemple simple : Les cinq lignes françaises de Nabil avant son carnet.
Ce que ce n'est pas : coder tête baissée puis déboguer pendant des heures.
Réflexe : français d'abord, Python ensuite.
- Débogage (debugging)
- Traquer et corriger les erreurs. print() et la lecture des messages d'erreur (lus de bas en haut) sont les premiers outils.
Exemple simple : Nabil qui isole son bug de suppression avec des prints.
Ce que ce n'est pas : modifier au hasard jusqu'à ce que ça passe.
Réflexe : lire le traceback, reproduire, corriger, revérifier.
En pratique — En pratique — Assembler les bases : un mini-programme complet
- Choisissez un mini-projet : carnet d'adresses (ajouter/chercher/lister/supprimer), jeu du nombre mystère, ou calculatrice en boucle.
- Écrivez d'abord le pseudo-code : les grandes étapes en français (tirer un nombre, boucler, comparer, indiquer plus/moins, compter les essais).
- Codez pas à pas en réutilisant : une fonction par étape, une boucle while pour rejouer, des conditions pour comparer, le module random pour tirer un nombre.
- Testez, provoquez des erreurs, corrigez avec print() : soignez l'expérience (messages clairs, nombre d'essais affiché).
Script prêt à dire — défendre le découpage (30 s)
« Je propose qu'on découpe en une fonction par verbe, avec un main qui ne fait que la boucle du menu : chaque fonction se teste isolément, le bug se localise en une lecture, et on réutilisera ces fonctions pour la sauvegarde JSON puis les tests. »
À dire en revue de code ; montrer le fichier en vrac face au découpé.
Modèle copier-coller — carnet d'adresses complet (capstone N1)
contacts = []
def ajouter(nom, tel):
contacts.append({"nom": nom, "tel": tel})
return f"{nom} ajoute."
def chercher(nom):
trouves = [c for c in contacts if c["nom"] == nom]
return trouves
def lister():
if not contacts:
return "Carnet vide."
return "\n".join(f"{c['nom']} : {c['tel']}" for c in contacts)
def main():
while True:
choix = input("1-ajouter 2-chercher 3-lister 0-quitter ? ")
if choix == "0":
print("Au revoir !")
break
elif choix == "1":
print(ajouter(input("Nom ? "), input("Tel ? ")))
elif choix == "3":
print(lister())
else:
print("Choix inconnu.")
if __name__ == "__main__":
main()
Carnet à Alger
Comme Nabil : dicts + verbes + main menu — l'équipe ajoute et cherche sans formation, le socle est prouvé.
Nombre mystère
random + while pour rejouer + conditions plus/moins : le même socle (variables, boucles, fonctions) dans un jeu.
Calculatrice en boucle
Un menu d'opérations avec fonctions additionner/diviser : la division par zéro testée en condition, le tout rejouable.
Pont N2/N3
Le carnet persisté en JSON (N2 : with open, json.dump/load) puis prouvé en tests (N3) : réinvestir, pas recommencer.
✓ Bonnes pratiques
- Écrire le pseudo-code en français avant de coder.
- Un verbe = une fonction, menu = main, import protégé.
- Finir un projet compris et refait seul avant le niveau 2.
✗ Pièges fréquents
- Tout écrire en vrac sans fonctions (illisible à 80 lignes).
- Copier-coller le menu cinq fois au lieu d'une boucle.
- Passer au N2 sans finir le carnet (socle fragile).
Points clés à retenir
- Consolider = réemployer ensemble variables, conditions, boucles et fonctions dans un programme complet.
- Décomposer un problème en petites étapes est LA compétence à développer — pseudo-code d'abord.
- Verbes → fonctions, menu → main, if __name__ == "__main__" systématique.
- Un mini-projet complet ancre les bases mieux que dix exercices isolés — et prépare N2 (fichiers) et N3 (tests).
Défi 48h — appliquez demain
Codez le carnet du modèle ci-dessus seul, sans copier : pseudo-code, une fonction par verbe, boucle du menu, import protégé. Ajoutez supprimer(), testez chaque choix, puis expliquez chaque ligne à voix haute. 45 minutes suffisent.
- J'ai codé seul un programme de ~80 lignes qui tourne.
- Mon code est découpé (verbes → fonctions, menu → main).
- Je peux expliquer chaque ligne et viser N2 (JSON) puis N3 (tests).
Questions fréquentes
Je connais la syntaxe mais je bloque devant une page blanche, normal ?
Très normal, et c'est justement l'objet de ce chapitre. La solution est la décomposition : n'essayez pas d'écrire le programme entier d'un coup, découpez-le en toutes petites étapes que vous savez déjà coder (pseudo-code), puis assemblez-les une par une.
Combien de projets faut-il faire avant le niveau 2 ?
Un projet complet et bien compris vaut mieux que cinq bâclés. Si vous êtes capable de le refaire seul, sans copier, en expliquant chaque ligne, vous êtes prêt pour le niveau 2. Sinon, refaites-en une variante (nombre mystère, calculatrice).
Que prouve un mini-projet de ~80 lignes codé seul ?