Formation en programmation informatique

Leçon 1 • Choisir et installer un langage

Compare les paradigmes des langages de programmation et guide l'installation d'un environnement d'exécution 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 récupération-décodage-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 valident leur premier projet, établissant ainsi des habitudes utilisées dans chaque chapitre suivant.

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

Explore l'indexation des chaînes, le découpage, la concaténation et les méthodes intégrées courantes. 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

Aborde la déclaration de variables, les conventions de nommage et la liaison 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 constitutifs de tout le 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 ainsi que leurs implications mémoire. Un choix correct des types permet d'éviter les bogues courants introduits plus tard dans les chapitres sur la logique.

Leçon 1 • Instructions conditionnelles

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

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

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

Leçon 3 • Boucles et itération

Présente 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 de 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 • Organiser le code en modules

Montre comment diviser le code entre des 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éfinir et appeler des fonctions

Aborde 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écursion

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

Leçon 4 • Arguments 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 fonction flexibles rendent les API plus faciles à utiliser et à étendre.

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

Compare la complexité temporelle et spatiale des listes, dictionnaires et ensembles pour les opérations courantes. Un choix éclairé de la structure est essentiel pour le chapitre sur les algorithmes à venir.

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

Présente les ensembles pour la déduplication, les tests 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 immuabilité et les cas d'utilisation tels que 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

Aborde la création de listes, l'indexation, le découpage et les méthodes de mutation. 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 mécanisme d'abstraction principal 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 polymorphique rend les systèmes flexibles et plus faciles à étendre.

Leçon 4 • Héritage (POO) et réutilisation du code

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

Leçon 1 • Journalisation et observabilité

Introduit la journalisation structurée comme remplacement du débogage par print. Les journaux offrent une visibilité sur 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 informe la stratégie de gestion appropriée.

Leçon 3 • Validation des entrées et programmation défensive

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

Leçon 4 • Lever et créer des exceptions (erreur logicielle) personnalisées

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

Leçon 1 • Planification de projet et exigences

Traduit un énoncé de problème en user stories, critères d'acceptation et 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 API. Une bonne documentation rend le code utilisable par les coéquipiers et les mainteneurs futurs.

Leçon 3 • Empaqueter et partager 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 les tests unitaires

Aborde 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.