Formation en programmation informatique

Leçon 1 • Choix et installation d'un langage

Compare les paradigmes de langages de programmation et guide l'installation d'un environnement d'exécution de langage adapté aux débutants. Met en place une chaîne d'outils cohérente pour l'ensemble du cours.

Leçon 2 • Comment les ordinateurs exécutent les programmes

Explique le cycle de fetch-décode-exécution, la mémoire et le rôle du système d'exploitation. Ancre tous les concepts de codage ultérieurs dans la réalité matérielle.

Leçon 3 • Gestion de versions avec les bases de Git

Présente Git comme un filet de sécurité pour les modifications de code et la collaboration. Les étudiants effectuent leur premier commit sur un projet, établissant des habitudes utilisées dans chaque chapitre ultérieur.

Leçon 1 • Travailler avec les chaînes de caractères

Explore l'indexation, le découpage, la concaténation et les méthodes intégrées courantes des chaînes. La manipulation des chaînes est essentielle pour les entrées et sorties utilisateur dans les projets ultérieurs.

Leçon 2 • Variables et affectation

Couvre la déclaration des variables, les conventions de nommage et la liaison en mémoire. Comprendre les variables est un prérequis pour chaque concept de codage ultérieur.

Leçon 3 • Opérateurs et expressions

Enseigne les opérateurs arithmétiques, de comparaison, logiques et d'affectation avec les règles de précédence. Les expressions sont les éléments de base de tout flux de contrôle abordé ensuite.

Leçon 4 • Types de données primitifs

Examine les entiers, les flottants, les booléens et les chaînes avec leurs implications mémoire. Une sélection correcte des types évite les bugs courants introduits plus tard dans les chapitres sur la logique.

Leçon 1 • Instructions conditionnelles

Couvre les branches if, else-if et else avec des conditions booléennes. Les conditionnels sont le principal mécanisme de logique décisionnelle dans tous les programmes.

Leçon 2 • Débogage de la logique du flux de contrôle

Utilise des instructions print et un débogueur pour tracer l'exécution conditionnelle et des boucles. Les compétences de débogage systématique réduisent le temps passé à corriger les erreurs logiques dans les projets ultérieurs.

Leçon 3 • Boucles et itération

Introduit les boucles while et for pour répéter des opérations sur des données ou des compteurs. L'itération sous-tend les collections, les algorithmes et le traitement des données abordés plus tard.

Leçon 4 • Instructions de contrôle de boucle

Explique break, continue et return dans les boucles pour modifier le flux d'itération. Un contrôle précis des boucles est essentiel pour écrire des algorithmes efficaces et corrects.

Leçon 1 • Organisation du code en modules

Montre comment diviser le code dans plusieurs fichiers et importer des fonctionnalités entre modules. La conception modulaire est le fondement des projets plus importants dans les chapitres avancés.

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

Couvre la syntaxe des fonctions, les paramètres, les valeurs de retour et les mécanismes d'appel. Les fonctions sont l'unité principale de réutilisation du code tout au long du reste du cours.

Leçon 3 • Fondamentaux de la récursivité

Introduit la pensée récursive avec des cas de base et des cas récursifs. La récursivité est fondamentale pour le parcours d'arbres et les algorithmes diviser-pour-régner introduits plus tard.

Leçon 4 • Paramètres par défaut et arguments nommés

Montre les paramètres optionnels, les valeurs par défaut et le passage d'arguments nommés. Des signatures de fonctions flexibles rendent les API plus faciles à utiliser et à étendre.

Leçon 1 • Choisir la bonne structure de données

Compare la complexité temporelle et spatiale des listes, dictionnaires et ensembles pour les opérations courantes. Une sélection éclairée des structures est essentielle pour le chapitre sur les algorithmes à venir.

Leçon 2 • Ensembles et opérations d'unicité

Introduit les ensembles pour la déduplication, le test d'appartenance et l'algèbre des ensembles. Les opérations sur les ensembles fournissent des solutions efficaces aux problèmes impliquant des éléments uniques.

Leçon 3 • Tuples et séquences immuables

Explique les tuples, leur immutabilité et leurs cas d'utilisation comme les valeurs de retour multiples. Choisir des tuples plutôt que des listes signale l'intention et empêche les mutations accidentelles.

Leçon 4 • Listes et tableaux dynamiques

Couvre la création, l'indexation, le découpage et les méthodes de mutation des listes. Les listes sont le type de collection le plus courant et apparaissent dans chaque projet ultérieur.

Leçon 1 • Classes et instances d'objets

Définit la syntaxe des classes, les constructeurs et la création d'instances. Les classes sont le principal mécanisme d'abstraction pour tous les patrons de conception orientés objet à venir.

Leçon 2 • Principes de conception orientée objet

Introduit les principes SOLID et les patrons de conception courants à un niveau conceptuel. Ces principes guident les décisions d'architecture prises dans le chapitre du projet final.

Leçon 3 • Polymorphisme et typage canard

Explique comment des objets de différentes classes partagent une interface commune via le polymorphisme. La conception polymorphe rend les systèmes flexibles et plus faciles à étendre.

Leçon 4 • Héritage et réutilisation de code

Montre l'héritage simple et multi-niveaux avec la surcharge de méthodes. L'héritage permet une modélisation hiérarchique et réduit la duplication de code entre classes apparentées.

Leçon 1 • Journalisation et observabilité

Introduit la journalisation structurée comme remplacement du débogage basé sur print. Les journaux fournissent une visibilité au moment de l'exécution essentielle pour diagnostiquer les problèmes dans les applications déployées.

Leçon 2 • Comprendre les exceptions et les erreurs

Distingue les erreurs de syntaxe, les exceptions d'exécution et les erreurs logiques par catégorie. Une classification correcte accélère le diagnostic et éclaire la stratégie de gestion appropriée.

Leçon 3 • Validation des entrées et codage défensif

Applique des modèles de validation pour protéger les fonctions contre les mauvaises entrées avant le traitement. Le codage défensif réduit la surface d'attaque pour les défaillances d'exécution en production.

Leçon 4 • Lever et créer des exceptions personnalisées

Montre comment lever des exceptions intentionnellement et définir des classes d'exception spécifiques au domaine. Les exceptions personnalisées rendent les contrats d'erreur des bibliothèques et des API explicites.

Leçon 1 • Planification du projet et exigences

Traduit un énoncé de problème en user stories, critères d'acceptation et un plan de modules. Des exigences claires empêchent la dérive du périmètre et guident toutes les décisions d'implémentation.

Leçon 2 • Documentation et commentaires de code

Enseigne les conventions de docstring, les commentaires en ligne et la génération de documentation de référence d'API. Une bonne documentation rend le code utilisable par les coéquipiers et les mainteneurs futurs.

Leçon 3 • Empaquetage et partage de votre projet

Guide la gestion des dépendances, l'empaquetage du projet et la publication dans un registre de paquets. Les paquets distribuables sont le livrable standard dans les équipes logicielles professionnelles.

Leçon 4 • Tests automatisés avec des tests unitaires

Couvre la conception de cas de test, les assertions et l'exécution d'une suite de tests avec un framework standard. Les tests automatisés détectent les régressions et valident le comportement à mesure que le projet grandit.