Formation Python - Tests, qualité et bonnes pratiques de développement

Développer une application Python fonctionnelle est une première étape. Pour l'utiliser durablement dans un environnement professionnel, il faut également pouvoir vérifier son comportement, détecter les régressions et faire évoluer son code sans compromettre les fonctionnalités existantes.

Les tests automatisés et les outils de qualité logicielle permettent de répondre à ces besoins :

• Fiabilité : vérifier le comportement des fonctions et identifier les anomalies avant leur mise en production.
• Maintenabilité : améliorer la lisibilité, la structure et l'évolutivité des programmes.
• Qualité du code : détecter les erreurs potentielles grâce à l'analyse statique, au typage et aux outils de formatage.
• Automatisation : exécuter régulièrement les contrôles de qualité et les tests sans intervention manuelle.
• Collaboration : faciliter les modifications, les revues de code et le travail en équipe.

Cette formation propose une approche pratique de la qualité logicielle avec Python 3.14 et des outils modernes tels que uv, Ruff, mypy, pytest et pytest-cov.

En 3 jours, vous apprendrez à :

• Identifier les défauts de qualité dans un projet Python.
• Développer des tests unitaires, paramétrés et d'intégration.
• Isoler les dépendances pour fiabiliser les tests.
• Refactoriser du code tout en préservant son comportement.
• Automatiser les contrôles de qualité dans un processus de développement.

À travers des exercices et un projet de synthèse, vous appliquerez ces pratiques à une application Python existante pour la rendre plus fiable, testable et maintenable.

À l'issue de la formation, le participant sera capable de :

1. Configurer un environnement de développement Python reproductible et gérer les dépendances du projet.
2. Identifier et corriger les défauts de qualité du code avec des outils d'analyse statique.
3. Appliquer les annotations de types et vérifier leur cohérence.
4. Concevoir des tests automatisés couvrant les comportements attendus et les cas limites.
5. Utiliser les fixtures et les mocks pour isoler les composants testés.
6. Analyser la couverture du code et identifier les scénarios insuffisamment vérifiés.
7. Refactoriser un programme Python en limitant les risques de régression.
8. Automatiser l'exécution des tests et des contrôles de qualité.

Professionnels utilisant Python dans un contexte de développement ou de maintenance logicielle :

• Développeurs Python souhaitant renforcer leurs pratiques de tests et de qualité.
• Ingénieurs logiciels intervenant sur des applications Python existantes.
• Développeurs Data et scientifiques souhaitant fiabiliser leurs programmes.
• Professionnels de l'automatisation développant des scripts et des outils internes.
• Consultants et développeurs indépendants souhaitant améliorer la qualité de leurs livrables.

Intermédiaire

• Maîtriser les fondamentaux de Python : variables, collections, conditions, boucles et fonctions.
• Savoir organiser un programme en modules et utiliser les imports.
• Connaître les principes de gestion des exceptions.
• Être capable de lire, comprendre et modifier un programme Python existant.

Une connaissance élémentaire de la programmation orientée objet et de Git constitue un avantage.

La maîtrise préalable de pytest ou des outils de qualité logicielle n'est pas nécessaire.

Un questionnaire de positionnement peut être proposé avant la formation.

• Structurer un projet Python et gérer ses dépendances avec uv.
• Analyser et formater automatiquement du code avec Ruff.
• Exploiter les annotations de types et effectuer une vérification statique.
• Concevoir des tests unitaires et d'intégration avec pytest.
• Utiliser la paramétrisation, les fixtures et les mocks.
• Mesurer et interpréter la couverture des tests.
• Refactoriser du code en préservant ses fonctionnalités.
• Diagnostiquer les erreurs et identifier les problèmes de qualité.
• Mettre en place des contrôles automatisés avec GitHub Actions.

La formation porte sur les pratiques de tests, d'assurance qualité et de maintenance des applications Python.

Elle approfondit les outils et méthodes nécessaires à la fiabilisation du code : analyse statique, typage, tests automatisés, couverture, refactoring et intégration continue.

Les notions avancées de programmation orientée objet, les algorithmes d'optimisation et l'étude approfondie des performances relèvent des formations Python POO et Python Perfectionnement.

3 jours (21 heures).

• Inter-entreprise : formation à distance, selon le calendrier des sessions proposées.
• Intra-entreprise : formation à distance ou dans vos locaux, pour un groupe de 8 participants maximum.

JOUR 1 - Qualité du code, analyse statique et refactoring (7 h)

1. Préparer un environnement de développement professionnel (1 h)

• Présentation de Python 3.14 et de l'environnement technique.
• Comprendre les environnements virtuels et l'isolation des dépendances.
• Initialiser un projet avec uv.
• Organiser les fichiers et répertoires d'un projet Python.
• Comprendre pyproject.toml, .python-version et uv.lock.
• Installer les outils de développement avec uv add --dev.
• Exécuter les commandes du projet avec uv run.

Travaux pratiques : préparer un projet Python existant, configurer son environnement et installer les outils nécessaires aux contrôles de qualité.

2. Analyser et améliorer la qualité du code Python (1 h 30)

• Comprendre les enjeux de la qualité logicielle.
• Identifier les problèmes de lisibilité, de duplication et de complexité.
• Appliquer les conventions de codage PEP 8.
• Comprendre le rôle des docstrings et des conventions de nommage.
• Découvrir les outils de linting et de formatage.
• Analyser le code avec ruff check.
• Formater le code avec ruff format.
• Configurer les règles de qualité dans pyproject.toml.
• Distinguer corrections automatiques et corrections nécessitant une intervention humaine.

Travaux pratiques : réaliser un audit de qualité d'un projet Python comportant des erreurs de style, des imports inutilisés et plusieurs problèmes de maintenabilité.

3. Fiabiliser le code avec les annotations de types (1 h 30)

• Comprendre le typage dynamique et les annotations de types en Python.
• Annoter les variables, les paramètres et les valeurs de retour.
• Utiliser les types génériques : list, dict, tuple et set.
• Manipuler les unions de types et les valeurs optionnelles.
• Définir des alias de types simples.
• Vérifier la cohérence des annotations avec mypy.
• Comprendre les limites de la vérification statique des types.
• Corriger les incompatibilités détectées.

Travaux pratiques : ajouter des annotations à un ensemble de fonctions et corriger les erreurs révélées par l'analyse statique.

4. Refactoriser et améliorer la maintenabilité (3 h)

• Comprendre les objectifs et les risques du refactoring.
• Identifier les fonctions trop longues et les responsabilités mal réparties.
• Réduire les duplications et simplifier les conditions.
• Extraire des fonctions réutilisables.
• Améliorer le découpage du code en modules.
• Séparer les traitements métiers des entrées/sorties.
• Identifier les dépendances qui compliquent les tests.
• Préserver le comportement observable du programme pendant les modifications.
• Effectuer des changements progressifs et vérifiables.

Travaux pratiques : restructurer une application Python existante, initialement difficile à lire et à maintenir, puis vérifier son comportement à l'aide de scénarios de référence.

JOUR 2 - Tests automatisés avec pytest (7 h)

5. Comprendre et concevoir des tests logiciels (2 h)

• Comprendre le rôle des tests dans le cycle de développement.
• Distinguer tests unitaires, tests d'intégration et tests fonctionnels.
• Identifier les comportements à vérifier.
• Construire des cas de test à partir de spécifications.
• Découvrir les principes AAA : Arrange, Act, Assert.
• Présentation de unittest et de pytest.
• Organiser les fichiers et les fonctions de tests.
• Écrire des assertions avec pytest.
• Tester les résultats attendus et les exceptions.
• Comprendre les messages d'échec et diagnostiquer un test.

Travaux pratiques : développer une première suite de tests pour des fonctions métiers, puis détecter et corriger plusieurs anomalies présentes dans le programme.

6. Concevoir des tests réutilisables et paramétrés (2 h)

• Identifier les cas nominaux, les cas limites et les entrées invalides.
• Mutualiser les données et les étapes de préparation.
• Paramétrer les tests avec pytest.mark.parametrize.
• Créer et utiliser des fixtures pytest.
• Comprendre la portée des fixtures.
• Réutiliser des fixtures entre plusieurs modules de tests.
• Structurer une suite de tests pour faciliter sa maintenance.
• Organiser les données nécessaires aux tests.

Travaux pratiques : construire une batterie de tests paramétrés couvrant différentes règles métiers, puis factoriser les opérations de préparation avec des fixtures.

7. Isoler les dépendances et tester les interactions (2 h)

• Comprendre les dépendances externes et leurs effets sur les tests.
• Distinguer les objets réels, les stubs et les mocks.
• Utiliser unittest.mock.
• Simuler les appels de fonctions et les réponses externes.
• Contrôler les interactions avec Mock et patch.
• Utiliser la fixture monkeypatch.
• Tester les traitements de fichiers avec tmp_path.
• Simuler les situations d'erreur sans modifier les ressources réelles.
• Éviter les tests dépendant du réseau, du système ou de données de production.

Travaux pratiques : tester un composant utilisant des fichiers et un service externe simulé, en vérifiant les résultats, les appels effectués et les comportements en cas d'échec.

8. Mesurer la couverture et prévenir les régressions (1 h)

• Comprendre la notion de couverture des tests.
• Utiliser pytest-cov pour mesurer la couverture du code.
• Interpréter les rapports de couverture.
• Identifier les instructions et branches non couvertes.
• Comprendre pourquoi une couverture élevée ne garantit pas l'absence de défauts.
• Ajouter des tests de non-régression après la correction d'une anomalie.

Travaux pratiques : mesurer la couverture d'un projet, identifier un comportement non testé et compléter la suite de tests.

JOUR 3 - Assurance qualité et automatisation des contrôles (7 h)

9. Tester l'intégration des composants et diagnostiquer les anomalies (1 h 15)

• Comprendre les interactions entre modules.
• Construire des scénarios de tests d'intégration.
• Préparer des données et des environnements temporaires.
• Tester les chemins d'exécution complets.
• Utiliser le débogueur Python pour identifier les anomalies.
• Exploiter les traces d'exécution et la journalisation avec logging.
• Tester les comportements attendus en cas d'erreur.

Travaux pratiques : mettre en œuvre des tests d'intégration sur plusieurs modules et analyser les anomalies détectées.

10. Automatiser les contrôles de qualité (1 h 15)

• Comprendre les principes de l'intégration continue.
• Découvrir les workflows GitHub Actions.
• Automatiser l'analyse statique et le contrôle du formatage.
• Automatiser les vérifications de types et les tests pytest.
• Exécuter les contrôles lors des modifications du code.
• Interpréter les résultats d'un workflow.
• Identifier les échecs et corriger les anomalies.
• Comprendre les contrôles nécessaires avant une intégration de code.

Travaux pratiques : configurer un workflow simple permettant de vérifier automatiquement la qualité d'un projet Python.

11. Identifier les problèmes de performance (30 min)

• Comprendre la différence entre optimisation et mesure de performance.
• Mesurer le temps d'exécution avec timeit.
• Découvrir le profilage avec cProfile.
• Identifier un traitement particulièrement coûteux.
• Vérifier qu'une modification conserve le comportement attendu.

Démonstration pratique : mesurer une fonction peu performante et comparer son comportement avant et après une amélioration simple.

12. Projet final - Auditer, tester et fiabiliser une application Python (4 h)

À partir d'une application Python existante, les participants doivent mener une démarche complète d'amélioration de la qualité logicielle.

Le projet fourni comporte plusieurs modules, des règles métiers, des interactions entre composants et des anomalies volontairement introduites.

Travaux à réaliser :

• Préparer et configurer l'environnement du projet avec uv.
• Identifier les problèmes de qualité et de maintenabilité.
• Corriger les erreurs signalées par l'analyse statique.
• Ajouter des annotations de types et vérifier leur cohérence.
• Développer une suite de tests unitaires.
• Mettre en œuvre des tests paramétrés et des fixtures.
• Isoler les dépendances externes à l'aide de mocks.
• Ajouter des tests d'intégration.
• Mesurer la couverture et compléter les cas manquants.
• Refactoriser les parties du programme nécessitant des améliorations.
• Automatiser les contrôles de qualité.
• Présenter les résultats des vérifications et justifier les principales modifications.

Livrable : une application Python restructurée, accompagnée de ses tests automatisés, de sa configuration qualité et des résultats de validation.

La formation privilégie une pédagogie active combinant explications techniques, démonstrations, exercices pratiques et projet de synthèse.

Les participants travaillent sur du code Python représentatif de situations professionnelles : fonctions insuffisamment testées, composants dépendant de ressources externes, erreurs de typage et défauts de maintenabilité.

Les exercices reposent sur des énoncés à résoudre et des comportements attendus à vérifier. Les corrections sont accompagnées d'explications sur les différentes stratégies de test et les choix d'implémentation.

Un projet fil rouge permet de relier les concepts étudiés au cours des trois journées.

Les compétences sont évaluées tout au long de la formation au moyen de :

• Un questionnaire de positionnement initial.
• Des exercices pratiques et des vérifications régulières.
• La réalisation de tests automatisés sur des composants Python.
• L'analyse et la correction d'anomalies.
• Un projet final évalué selon des critères définis.

L'évaluation finale porte notamment sur la pertinence des tests, la gestion des cas limites, la fiabilité des traitements, la qualité du refactoring et la capacité à automatiser les contrôles.

Un bilan des acquis est réalisé en fin de formation.

Langage et environnement

• Python 3.14, avec mises à jour correctives compatibles.
• uv et environnements virtuels Python.
• Configuration des projets avec pyproject.toml.
• Gestion des dépendances et fichiers de verrouillage.

Qualité logicielle

• Ruff : analyse statique et formatage.
• mypy : vérification statique des types.
• PEP 8 et annotations de types Python.
• Outils de refactoring et de débogage.

Tests automatisés

• pytest et unittest.mock.
• pytest-cov pour la couverture.
• Fixtures, paramétrisation et mocks.
• Modules standard logging, timeit et cProfile.

Automatisation

• Git et GitHub.
• GitHub Actions pour l'intégration continue.

Le système d'exploitation, l'éditeur et les versions des dépendances sont précisés lors de la préparation de la session. Les outils retenus doivent être compatibles avec Python 3.14.

En intra-entreprise comme en inter-entreprise, deux modalités peuvent être envisagées :

• Budget direct : financement de la formation par l'entreprise ou le participant.
• Portage Qualiopi : réalisation via un organisme de formation partenaire certifié, sous réserve d'accord et des conditions d'éligibilité au financement.

Les modalités sont définies selon le contexte et les besoins de l'entreprise.

Vous souhaitez améliorer la fiabilité et la maintenabilité de vos projets Python ?

Contactez-moi pour étudier vos besoins et organiser une formation adaptée au niveau de votre équipe.