Formation programmation informatique

Leçon 1 • Entrée, sortie et formatage de base

Apprend à lire les entrées utilisateur et à afficher des sorties formatées. Relie les concepts de données abstraits à un comportement visible et interactif du programme.

Leçon 2 • Configuration d'un environnement de développement

Installe et configure un éditeur de code, un environnement d'exécution et un terminal. Garantit que chaque étudiant peut écrire, exécuter et déboguer du code dès le premier jour.

Leçon 3 • Opérateurs et expressions

Couvre les opérateurs arithmétiques, relationnels, logiques et d'affectation. Les étudiants peuvent construire et évaluer correctement des expressions composées.

Leçon 4 • Variables, types de données et littéraux

Introduit le stockage nommé, les types primitifs et la syntaxe des littéraux. Établit le vocabulaire utilisé dans tous les chapitres suivants.

Leçon 1 • Comparaison et conditions logiques

Approfondit la compréhension des expressions booléennes composées et de l'évaluation en court-circuit. Évite les erreurs logiques courantes dans le code de branchement.

Leçon 2 • Contrôle de boucle et modèles d'itération

Enseigne break, continue et les idiomes de boucle courants tels que les modèles d'accumulateur et de sentinelle. Affine la conception des boucles pour plus de clarté et de correction.

Leçon 3 • Boucles contrôlées par condition

Couvre les boucles while et do-while pour la répétition pilotée par une condition. Les étudiants gèrent la validation des entrées et la répétition pilotée par les événements.

Leçon 4 • Boucles contrôlées par compteur

Introduit les boucles for et l'itération basée sur une plage pour un nombre connu de répétitions. Jette les bases de tous les algorithmes itératifs.

Leçon 1 • Définition et appel de fonctions

Couvre la déclaration de fonction, les listes de paramètres et les valeurs de retour. Établit l'unité de base de la réutilisation du code utilisée dans tous les chapitres suivants.

Leçon 2 • Arguments par défaut, nommés et variables

Introduit des signatures de paramètres flexibles, y compris les valeurs par défaut et les arguments variadiques. Permet aux fonctions de s'adapter à différents contextes d'appel.

Leçon 3 • Portée et durée de vie des variables

Explique les règles de portée locale, englobante et globale, ainsi que l'ombrage des variables. Évite les bugs subtils causés par le partage involontaire de variables.

Leçon 4 • Fonctions d'ordre supérieur et lambdas

Couvre le passage de fonctions en arguments, le retour de fonctions et la syntaxe des lambdas anonymes. Prépare les étudiants aux motifs de programmation fonctionnelle.

Leçon 1 • Ensembles et tuples

Couvre les collections non ordonnées uniques et les séquences immuables. Les étudiants appliquent des opérations ensemblistes et utilisent des tuples pour les données à structure fixe.

Leçon 2 • Chaînes comme séquences

Traite les chaînes comme des séquences de caractères indexées et couvre les opérations courantes sur les chaînes. Fait le pont entre les types primitifs et le comportement des collections.

Leçon 3 • Tableaux et listes

Couvre le stockage séquentiel indexé, l'accès aux éléments et la mutation. Fournit le type de collection le plus fondamental pour les données ordonnées.

Leçon 4 • Choix et combinaison de structures de données

Analyse les compromis temporels et spatiaux entre les types de collections. Les étudiants conçoivent des structures composites pour des tâches réalistes de modélisation des données.

Leçon 1 • Héritage et redéfinition de méthodes

Enseigne la création de sous-classes, la réutilisation du code de la classe parente et la redéfinition de méthodes. Permet la modélisation hiérarchique et la réutilisation du code entre types apparentés.

Leçon 2 • Composition et principes de conception

Introduit la composition plutôt que l'héritage, le principe de responsabilité unique et le principe ouvert/fermé. Les étudiants remanient les conceptions de classes pour plus de flexibilité.

Leçon 3 • Méthodes et encapsulation

Couvre les méthodes d'instance, les modificateurs d'accès et le masquage des données. Les étudiants protègent l'état interne et exposent des interfaces publiques propres.

Leçon 4 • Polymorphisme et interfaces

Couvre le typage canard, les classes abstraites et les contrats d'interface. Les étudiants écrivent du code qui opère sur plusieurs types via une interface commune.

Leçon 1 • Lecture et écriture de fichiers texte

Couvre l'ouverture, la lecture, l'écriture et la fermeture de fichiers avec des gestionnaires de contexte. Relie les données en mémoire au stockage persistant sur disque.

Leçon 2 • Types d'exceptions et hiérarchie d'erreurs

Cartographie les catégories d'exceptions courantes et leur hiérarchie d'héritage. Les étudiants identifient le type d'exception approprié pour chaque scénario de défaillance.

Leçon 3 • Blocs Try, Except et Finally

Couvre la gestion structurée des exceptions, les clauses except multiples et le code de nettoyage. Les étudiants évitent les plantages et libèrent les ressources de manière fiable.

Leçon 4 • Exceptions personnalisées et programmation défensive

Enseigne la définition de classes d'exceptions personnalisées et la validation proactive des entrées. Les étudiants conçoivent des API qui communiquent clairement les erreurs.

Leçon 1 • Analyse d'algorithmes et notation Grand-O

Introduit la complexité temporelle et spatiale et la classification Grand-O. Donne aux étudiants un cadre pour comparer objectivement l'efficacité des algorithmes.

Leçon 2 • Recherche linéaire et binaire

Implémente et compare les algorithmes de recherche séquentielle et binaire. Les étudiants comprennent les préconditions et les performances de chaque approche.

Leçon 3 • Résolution de problèmes basée sur la récursivité

Applique la pensée récursive à des problèmes classiques comme les arbres binaires de recherche et les permutations. Renforce la récursivité du chapitre trois dans des contextes algorithmiques.

Leçon 4 • Algorithmes de tri efficaces

Implémente le tri fusion et le tri rapide en utilisant la méthode diviser pour régner. Les étudiants analysent les performances O(n log n) et les stratégies de partitionnement.

Leçon 1 • Qualité du code et refactorisation

Couvre les conventions de nommage, les odeurs de code et les techniques de refactorisation systématique. Les étudiants améliorent le code existant sans modifier son comportement externe.

Leçon 2 • Gestion de versions avec Git

Couvre l'initialisation de dépôt, les commits, le branchement et la fusion. Permet le développement collaboratif et solo avec un historique complet des modifications.

Leçon 3 • Test unitaire et développement piloté par les tests

Enseigne l'écriture de tests unitaires, d'assertions et le cycle rouge-vert-refactorisation. Les étudiants vérifient l'exactitude et préviennent automatiquement les régressions.

Leçon 4 • Documentation et lisibilité du code

Enseigne les commentaires en ligne, les docstrings et la rédaction de README. Les étudiants produisent un code que les coéquipiers peuvent comprendre et maintenir.