🎯 Objectifs de la lecon
- •Comprendre le rôle de Git dans la gestion de versions
- •Savoir écrire des tests unitaires et documenter son code
- •Découper un programme en modules pour le rendre réutilisable
Quand tu travailles seul sur un petit programme, tu peux tout garder dans ta tête. Mais en équipe, sur un projet long, il faut des outils pour organiser le code, suivre les modifications, vérifier qu'il fonctionne et le rendre facile à comprendre et à réutiliser.
Gestion de versions avec Git
Git est un logiciel de gestion de versions. Il enregistre l'historique des modifications de ton projet. Chaque enregistrement s'appelle un commit. Un commit contient un message qui décrit le changement.
Un dépôt (repository) est le dossier qui contient tout le projet et son historique. Tu peux créer un dépôt local avec la commande git init. Pour enregistrer un commit, tu utilises d'abord git add pour ajouter les fichiers modifiés, puis git commit -m "message".
« Exemple : après avoir modifié le fichier main.py, tu tapes git add main.py puis git commit -m "Ajout de la fonction de calcul de moyenne". »
Point fort : Le message de commit est clair et explique le changement.
⚠️ Attention
Ne fais jamais de commit sans message. Un commit sans message est inutile pour comprendre l'historique.
✔️ A retenir
Git permet de revenir à une version antérieure, de travailler en parallèle sur des branches, et de fusionner le travail de plusieurs développeurs.
Tests unitaires
Un test unitaire vérifie qu'une petite partie du code (une fonction, une méthode) produit le résultat attendu. On écrit un test pour chaque cas important : cas normal, cas limite, cas d'erreur.
En Python, on utilise le module unittest. On crée une classe qui hérite de unittest.TestCase, et on écrit des méthodes dont le nom commence par test_. Chaque méthode contient une assertion, par exemple self.assertEqual(f(2), 4).
« Exemple : pour tester la fonction carre(x), on écrit un test avec self.assertEqual(carre(3), 9) et self.assertEqual(carre(-2), 4). »
Point fort : On teste à la fois un cas positif et un cas négatif.
⚠️ Attention
Un test qui ne passe pas signale un bug. Mais un test qui passe ne garantit pas que le code est parfait : il peut manquer des cas.
Documentation du code
Documenter, c'est expliquer ce que fait ton code. En Python, on utilise des docstrings : une chaîne de caractères placée juste après la définition d'une fonction ou d'une classe. Elle décrit le rôle, les paramètres et la valeur de retour.
« Exemple : def moyenne(liste): """Calcule la moyenne d'une liste de nombres. Paramètre liste : list de float. Retourne : float.""" »
Point fort : La docstring est immédiatement lisible par un autre développeur ou par un outil comme help().
Ajoute aussi des commentaires dans le code pour expliquer des passages complexes. Mais préfère un code clair à un long commentaire.
✔️ A retenir
Documente toujours le rôle de chaque fonction, ses paramètres et ce qu'elle renvoie. Cela rend le code réutilisable.
Découpage en modules
Un module est un fichier .py qui contient des fonctions, des classes ou des variables. Il permet de regrouper du code par thème. Par exemple, un module calculs.py peut contenir toutes les fonctions mathématiques d'un projet.
Pour utiliser un module dans un autre fichier, on écrit import nom_du_module. On accède alors à ses fonctions avec nom_du_module.fonction(). On peut aussi faire from nom_du_module import fonction pour utiliser directement fonction().
« Exemple : dans le fichier principal main.py, tu écris import calculs puis resultat = calculs.moyenne([1,2,3]). »
Point fort : Le code est organisé, chaque module a une responsabilité unique.
⚠️ Attention
Évite les imports circulaires : le module A importe B, et B importe A. Cela provoque une erreur.
Réutilisabilité
Un code réutilisable peut être employé dans un autre projet sans modification. Pour cela, il doit être générique : éviter les valeurs en dur, utiliser des paramètres, et ne pas dépendre de variables globales.
Le découpage en modules favorise la réutilisabilité. Un module bien conçu peut être copié dans un autre projet et importé directement. La documentation et les tests unitaires aident aussi à réutiliser le code en toute confiance.
« Exemple : une fonction trier(liste, ordre) est réutilisable car elle accepte n'importe quelle liste et un paramètre d'ordre. Une fonction trier_trois_nombres() ne l'est pas. »
Point fort : La fonction générique s'adapte à plus de situations.
✔️ A retenir
Un code réutilisable est modulaire, documenté, testé et paramétrable. Cela te fait gagner du temps sur tes futurs projets.
Erreurs fréquentes
- Oublier de faire git add avant git commit : les modifications ne sont pas enregistrées.
- Écrire des tests après avoir codé toutes les fonctions : il vaut mieux écrire les tests en même temps ou avant.
- Ne pas documenter les fonctions : le code devient incompréhensible pour les autres et pour toi-même plus tard.
- Mettre tout le code dans un seul fichier : difficile à lire, à tester et à réutiliser.
- Utiliser des noms de variables vagues comme a, b, tmp : le code perd en clarté.
