Cours pour apprendre à programmer

Leçon 1 • Mise en place d'un environnement de développement

Guide l'installation d'un éditeur de code, d'un environnement d'exécution et d'outils de terminal. Un environnement de travail fonctionnel est la condition préalable à chaque exercice pratique à venir.

Leçon 2 • Choisir son premier langage de programmation

Compare les langages conviviaux pour débutants selon la clarté de la syntaxe, le soutien de la communauté et la pertinence sur le marché du travail. Les étudiants et étudiantes choisissent un langage et justifient leur choix.

Leçon 3 • Lecture et écriture de la syntaxe de base

Présente les instructions, les expressions, les commentaires et les règles d'espacement blanc. Les étudiants et étudiantes écrivent et exécutent des programmes simples pour intérioriser les conventions syntaxiques.

Leçon 1 • Types de données primitifs

Examine les entiers, les nombres à virgule flottante (floats), les booléens et les chaînes de caractères comme éléments constitutifs de toutes les données. Les étudiants et étudiantes pratiquent des opérations spécifiques aux types et identifient les incompatibilités de types.

Leçon 2 • Opérateurs de comparaison et opérateurs logiques

Présente les opérateurs relationnels et logiques qui produisent des résultats booléens. Ces opérateurs alimentent toutes les structures conditionnelles et de boucle dans les chapitres suivants.

Leçon 3 • Conversion et transtypage de types

Explique la coercition implicite et le transtypage explicite entre les types de données. Les étudiants et étudiantes déboguent les erreurs de type et écrivent des routines de conversion sécurisées.

Leçon 4 • Opérateurs arithmétiques et d'affectation

Enseigne l'ensemble complet des opérateurs arithmétiques et des raccourcis d'affectation composée. Les étudiants et étudiantes calculent des résultats et mettent à jour les valeurs des variables dans de courts programmes.

Leçon 1 • Constructions switch et match

Présente la sélection à plusieurs branches comme alternative plus propre aux longues chaînes if-else. Les étudiants et étudiantes refactorisent le code conditionnel en blocs switch ou match.

Leçon 2 • Instructions if, else if et else

Construit des arbres de décision à l'aide de blocs conditionnels et de conditions imbriquées. Les étudiants et étudiantes tracent les chemins d'exécution et évitent les erreurs logiques courantes.

Leçon 3 • Boucles while et do-while

Introduit la répétition contrôlée par condition pour des nombres d'itérations inconnus. Les étudiants et étudiantes écrivent des boucles qui lisent une entrée jusqu'à ce qu'une valeur valide soit saisie.

Leçon 4 • Break, continue et contrôle de boucle

Enseigne les mécanismes de sortie anticipée et de saut qui ajustent le comportement des boucles. Les étudiants et étudiantes refactorisent les boucles pour éliminer les itérations inutiles.

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

Définit la portée locale, englobante et globale et explique l'ombrage des variables. Les étudiants et étudiantes tracent les valeurs des variables à travers des appels de fonctions imbriquées.

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

Couvre la syntaxe de déclaration des fonctions, le nommage et l'invocation. Les étudiants et étudiantes convertissent immédiatement des blocs de code répétés en fonctions nommées.

Leçon 3 • Notions fondamentales de la récursion

Introduit les fonctions auto-appelantes avec des cas de base et des étapes récursives. Les étudiants et étudiantes implémentent des algorithmes récursifs classiques et analysent la profondeur de la pile d'appels.

Leçon 4 • Paramètres, arguments et valeurs par défaut

Explique les paramètres positionnels, les valeurs par défaut et les modes de passage des arguments. Les étudiants et étudiantes écrivent des fonctions flexibles qui gèrent les entrées optionnelles avec élégance.

Leçon 1 • Dictionnaires et magasins clé-valeur

Introduit les structures de table de hachage pour une recherche rapide par clé. Les étudiants et étudiantes modélisent des entités du monde réel sous forme de dictionnaires et effectuent des opérations CRUD.

Leçon 2 • Itération sur les collections

Applique les boucles for-each et les itérateurs pour traiter chaque élément d'une collection. Les étudiants et étudiantes combinent l'itération avec des conditionnelles pour filtrer et transformer les données.

Leçon 3 • Notions fondamentales des listes et des tableaux

Couvre les collections ordonnées et indexées ainsi que leur disposition en mémoire. Les étudiants et étudiantes créent, accèdent et modifient des listes à l'aide de la notation par index.

Leçon 4 • Ensembles (sets) et tuples

Contraste les ensembles uniques non ordonnés avec les tuples immuables et leurs cas d'utilisation. Les étudiants et étudiantes appliquent des opérations sur les ensembles pour résoudre des problèmes d'appartenance et de dédoublonnage.

Leçon 1 • Héritage et réutilisation du code

Étend les classes de base pour créer des sous-classes spécialisées sans dupliquer le code. Les étudiants et étudiantes construisent une hiérarchie de classes à trois niveaux et redéfinissent (override) des méthodes.

Leçon 2 • Composition plutôt qu'héritage

Contraste les hiérarchies d'héritage avec la composition d'objets pour une conception flexible. Les étudiants et étudiantes refactorisent une conception fortement basée sur l'héritage en composants composables.

Leçon 3 • Encapsulation et contrôle d'accès

Enseigne le masquage de l'état interne derrière des interfaces publiques à l'aide de modificateurs d'accès. Les étudiants et étudiantes refactorisent des classes pour n'exposer que les données nécessaires.

Leçon 4 • Classes et objets

Définit les classes comme des plans (blueprints) et les objets comme des instances avec état et comportement. Les étudiants et étudiantes écrivent des classes avec des attributs et des méthodes pour un domaine simple.

Leçon 1 • Notions fondamentales de la gestion des exceptions

Enseigne les blocs try-except-finally pour intercepter et se remettre des erreurs d'exécution. Les étudiants et étudiantes encapsulent les opérations risquées et fournissent des messages d'erreur significatifs.

Leçon 2 • Lecture et écriture de fichiers

Couvre l'ouverture, la lecture, l'écriture et la fermeture de fichiers à l'aide de gestionnaires de contexte. Les étudiants et étudiantes analysent un fichier texte et écrivent les résultats traités dans un nouveau fichier.

Leçon 3 • Exceptions personnalisées et conception d'erreurs

Guide la création de classes d'exceptions spécifiques au domaine pour une communication d'erreur plus claire. Les étudiants et étudiantes conçoivent une hiérarchie d'exceptions pour une petite application.

Leçon 4 • Formats de données structurées

Présente les formats CSV et JSON comme des formats d'échange courants pour les données de programme. Les étudiants et étudiantes sérialisent et désérialisent des données entre des objets en mémoire et des fichiers.

Leçon 1 • Déploiement et exécution en production

Couvre les variables d'environnement, le déploiement de base sur serveur et les notions fondamentales de surveillance. Les étudiants et étudiantes déploient le projet sur une plateforme infonuagique (cloud) et vérifient qu'il s'exécute correctement.

Leçon 2 • Rédaction de tests automatisés

Présente les cadriciels (frameworks) de test unitaire et les principes du développement piloté par les tests. Les étudiants et étudiantes rédigent des tests avant d'implémenter chaque fonction de module.

Leçon 3 • Gestion de versions avec Git

Couvre les commits, les branches, les fusions et les demandes de tirage (pull requests) comme flux de travail professionnel. Les étudiants et étudiantes gèrent le dépôt du projet de l'initialisation à la fusion finale.

Leçon 4 • Empaquetage et gestion des dépendances

Enseigne les environnements virtuels, les gestionnaires de paquets et les fichiers de configuration de projet. Les étudiants et étudiantes isolent les dépendances et produisent une version reproductible.