Passez de scripts Python à une petite application structurée en objets. Vous modélisez le domaine, choisissez entre composition et héritage, protégez les échanges et testez une interface simple sans coupler toute la logique à l’affichage.
Développeurs et professionnels disposant de premières bases Python, souhaitant structurer une application en objets.
Prérequis
Savoir utiliser variables, conditions, boucles et fonctions Python. Lire et modifier un script simple ; la conception objet est introduite pendant le parcours.
Des compétences à mettre en pratique
Objectifs pédagogiques
Comprendre les bases du langage Python et son écosystème
Acquérir les principes de la programmation objet
Comprendre et utiliser les fonctions et modules
Concevoir des interfaces graphiques
Utiliser les outils de test et d'évaluation de la qualité d'un programme Python
Votre progression, jour après jour
Programme détaillé
6 séquences · 21 heures indicatives · ateliers et évaluation
Structurer un gestionnaire d'inventaire Python avec modèle objet, interface simple et tests automatisés.
Préparer votre formation et découvrir la méthode
Préparer la formation
Premières fonctions et collections Python ; Python, éditeur, pytest et Tkinter disponibles dans le poste de formation.
Apports illustrés, exercices progressifs, ateliers sur un cas fil rouge et retour argumenté sur les productions. Les ateliers et l'évaluation font partie des heures indiquées.
Jour 01Consolider fonctions et modules7 h · 2 séquences avec mise en pratique
Séquence 1 · 3 h 30
Consolider fonctions et modules
Organiser fichiers, imports et environnement virtuel.
Préciser arguments, valeurs de retour et exceptions.
Distinguer état local, état partagé et effets de bord.
Clarifier portée, mutabilité, arguments par défaut et annotations ; structurer un paquet sans imports circulaires.
Notions et méthodes en détail
Distinguer argument mutable, copie et référence ; éviter une valeur par défaut partagée.
Organiser modules et imports pour réduire dépendances circulaires et effets au chargement.
Employer annotations de types, exceptions ciblées et documentation du contrat des fonctions.
Atelier prévuTransformer un script monolithique d'inventaire en trois modules sans modifier ses résultats.
Livrable attenduPaquet Python organisé et fonctions aux contrats explicites.
Vérification en atelierL’import d’un module ne lance pas l’application et les erreurs attendues sont testées.
Pour aller plus loin
Remplacer des variables globales par des dépendances explicites pour rendre le traitement testable.
Séquence 2 · 3 h 30
Modéliser avec des classes
Définir attributs, initialisation, méthodes et invariants.
Utiliser propriétés et dataclasses quand elles simplifient le modèle.
Distinguer identité, égalité et représentation d'un objet.
Définir invariants, attributs, propriétés et représentation des objets ; comparer classe classique et dataclass.
Notions et méthodes en détail
Définir état, invariants, constructeur et méthodes ; distinguer attribut de classe et d’instance.
Comparer classe classique et dataclass selon validation, égalité et mutabilité.
Encapsuler une modification d’état et choisir une représentation lisible pour le débogage.
Atelier prévuCréer un article dont le stock reste valide après entrée et sortie ; tester une quantité négative et un stock insuffisant.
Livrable attenduModèle objet avec invariants et exemples d’usage.
Vérification en atelierUn objet ne peut pas entrer dans un état invalide par une opération publique prévue.
Pour aller plus loin
Concevoir un objet qui refuse un état incohérent et reste compréhensible lors de son affichage ou de sa sérialisation.
Jour 02Choisir composition et héritage7 h · 2 séquences avec mise en pratique
Séquence 3 · 3 h 30
Choisir composition et héritage
Comparer composition, délégation et spécialisation.
Définir un contrat de comportement sans couplage aux détails.
Comprendre polymorphisme et responsabilité unique.
Distinguer relation est-un et possède-un ; examiner couplage, polymorphisme et substitution dans les contrats.
Notions et méthodes en détail
Utiliser composition pour déléguer une responsabilité et héritage pour une substitution justifiée.
Définir un contrat commun avec protocole ou classe abstraite ; tester les implémentations.
Examiner MRO et super sur un exemple limité sans construire une hiérarchie artificielle.
Atelier prévuAjouter deux politiques de remise sans multiplier les conditions dans le calcul de commande.
Livrable attenduDiagramme de conception et refactoring argumenté.
Vérification en atelierUne implémentation est remplacée sans modifier le code consommateur ni casser son contrat.
Pour aller plus loin
Remplacer une hiérarchie fragile par une composition et vérifier la compatibilité des comportements attendus.
Séquence 4 · 3 h 30
Fiabiliser les échanges de données
Lire et écrire JSON ou CSV avec gestion des erreurs.
Encapsuler accès aux fichiers et conversions.
Employer gestionnaires de contexte et journalisation utile.
Valider les données aux frontières, gérer exceptions métier et ressources avec des gestionnaires de contexte.
Notions et méthodes en détail
Séparer sérialisation et objets métier ; valider champs, types et version d’un document JSON.
Utiliser gestionnaires de contexte pour fermer fichiers et connexions même en cas d’erreur.
Traduire une erreur d’entrée en exception métier tout en conservant sa cause technique.
Atelier prévuConstruire un dépôt d'articles et gérer un fichier absent, corrompu ou contenant un article invalide.
Livrable attenduCouche d’échange robuste et catalogue d’erreurs.
Vérification en atelierUn fichier incorrect est refusé sans création partielle d’objets incohérents.
Pour aller plus loin
Simuler un fichier corrompu ou une interruption d’écriture et préserver un état cohérent de l’application.
Jour 03Créer une interface graphique simple7 h · 2 séquences avec mise en pratique
Séquence 5 · 3 h 30
Créer une interface graphique simple
Relier widgets, événements et validation utilisateur.
Séparer affichage, logique métier et persistance.
Éviter les traitements bloquants dans la boucle d'événements.
Séparer widgets, état de l’interface et logique métier ; expliquer la boucle d’événements et les traitements bloquants.
Notions et méthodes en détail
Construire fenêtres, widgets et callbacks avec une séparation entre interface et services.
Valider une saisie, afficher un retour et empêcher une action incompatible avec l’état courant.
Comprendre la boucle d’événements et repérer un traitement long qui bloque l’interface.
Atelier prévuCréer une fenêtre de consultation et de saisie d'articles qui réutilise les classes métier testées.
Livrable attenduInterface événementielle et découpage présentation/métier.
Vérification en atelierLa même opération métier fonctionne depuis l’interface et depuis un test sans fenêtre.
Pour aller plus loin
Maintenir l’interface réactive pendant une opération longue et éviter les modifications concurrentes de son état.
Séquence 6 · 3 h 30
Tester et améliorer la conception
Écrire tests unitaires, fixtures et cas limites.
Utiliser types et analyse statique pour clarifier les contrats.
Refactorer en conservant les comportements validés.
Tester comportements publics, cas limites et dépendances externes ; distinguer mock utile et test lié aux détails internes.
Notions et méthodes en détail
Tester invariants, erreurs et transitions avec fixtures et dépendances remplacées.
Repérer responsabilités trop larges et extraire une collaboration sans changer le comportement.
Comparer duplication, couplage et lisibilité avant/après une refonte ciblée.
Atelier prévuLivrer le gestionnaire avec tests, notice et schéma des responsabilités ; démontrer l'ajout d'un nouveau stockage sans réécrire l'interface.
Livrable attenduSuite de tests et dossier de décisions de conception.
Vérification en atelierLes tests de comportement restent verts après le changement de conception.
Pour aller plus loin
Faire évoluer une règle métier avec une suite de non-régression puis mesurer la réduction du couplage.
Mettre vos acquis à l’épreuve
Évaluation finale prévue
Mise en situation individuelle et restitution commentée, incluses dans la dernière séquence. Durée indicative : 60 minutes.
Critères de réussite
Les invariants métier sont protégés par le modèle.
La logique reste testable sans interface graphique.
Les erreurs de fichiers produisent un comportement explicite.
Adaptation et validation pédagogique. Version enrichie proposée, à valider par le formateur. Répartition pédagogique proposée sur une base de 7 heures par jour, pauses exclues. À ajuster avec le formateur au positionnement initial. Les approfondissements « Pour aller plus loin » sont sélectionnés par le formateur selon le positionnement et le temps disponible ; ils ne constituent pas des heures supplémentaires garanties.
Les ateliers décrivent les travaux prévus. Leurs fichiers, corrigés et évaluations en ligne sont à préparer, sauf ressources explicitement disponibles dans le module pilote.
Références pour approfondir
Documentation des organismes et éditeurs. La progression et les ateliers sont une rédaction originale pour Beyond Expertise.
Le centre doit confirmer les prérequis, le programme final, les dates, les horaires et le tarif avant inscription. Le délai d’accès dépend des disponibilités et du besoin. L’ouverture d’une session et la disponibilité d’un cours e-learning sont confirmées avant inscription.
Les ateliers, méthodes et évaluations du programme sont proposés pour validation pédagogique. Les supports effectivement disponibles sont indiqués dans la section « Contenu e-learning ».
Le parcours ne délivre pas de diplôme ni de certification professionnelle. Aucune éligibilité CPF ou prise en charge n’est garantie. Toute préparation à un examen externe devra faire l’objet d’informations et d’habilitations vérifiées.
Durée indicative : 7023 minutes. Ce module couvre une partie du parcours 3 jours présenté sur le site officiel.
Utiliser les nouveaux cours et notebooks10 min
Démarrer avec Python, Jupyter et les premières données20 min
Pratiquer — Démarrer avec Python, Jupyter et les premières données45 min
Interpréteur, environnements virtuels, IPython et scripts20 min
Pratiquer — Interpréteur, environnements virtuels, IPython et scripts45 min
Types, opérations et structures de données simples20 min
Pratiquer — Types, opérations et structures de données simples45 min
Décisions, boucles et match/case20 min
Pratiquer — Décisions, boucles et match/case45 min
Fonctions, paramètres, retours et exceptions simples — partie 120 min
Fonctions, paramètres, retours et exceptions simples — partie 220 min
Pratiquer — Fonctions, paramètres, retours et exceptions simples45 min
Variante — Fonctions, paramètres, retours et exceptions simples20 min
Pratiquer — Variante — Fonctions, paramètres, retours et exceptions simples45 min
Modules standard, expressions régulières et scripts exécutables — partie 120 min
Modules standard, expressions régulières et scripts exécutables — partie 220 min
Pratiquer — Modules standard, expressions régulières et scripts exécutables45 min
Variante — Modules standard, expressions régulières et scripts exécutables20 min
Pratiquer — Variante — Modules standard, expressions régulières et scripts exécutables45 min
Fondations de la programmation orientée objet20 min
Pratiquer — Fondations de la programmation orientée objet45 min
Variante — Classes, objets, self et encapsulation20 min
Pratiquer — Variante — Classes, objets, self et encapsulation45 min
Héritage, polymorphisme, méthodes de classe, dataclasses et UML — partie 120 min
Héritage, polymorphisme, méthodes de classe, dataclasses et UML — partie 220 min
Pratiquer — Héritage, polymorphisme, méthodes de classe, dataclasses et UML45 min
Variante — Cycle de vie des objets, dataclasses et UML de base20 min
Pratiquer — Variante — Cycle de vie des objets, dataclasses et UML de base45 min
Classes abstraites, polymorphisme contractuel et exceptions métier — partie 120 min
Classes abstraites, polymorphisme contractuel et exceptions métier — partie 220 min
Pratiquer — Classes abstraites, polymorphisme contractuel et exceptions métier45 min
Variante — Héritage, polymorphisme, classes abstraites et exceptions métier20 min
Pratiquer — Variante — Héritage, polymorphisme, classes abstraites et exceptions métier45 min
Héritage multiple, mixins, MRO et design patterns légers — partie 120 min
Héritage multiple, mixins, MRO et design patterns légers — partie 220 min
Pratiquer — Héritage multiple, mixins, MRO et design patterns légers45 min
Variante — Héritage multiple, mixins, MRO et design patterns légers20 min
Pratiquer — Variante — Héritage multiple, mixins, MRO et design patterns légers45 min
Collections Python : listes, tuples, dictionnaires et ensembles — partie 120 min
Collections Python : listes, tuples, dictionnaires et ensembles — partie 220 min
Pratiquer — Collections Python : listes, tuples, dictionnaires et ensembles45 min
Variante — Listes, tuples, dictionnaires et ensembles20 min
Pratiquer — Variante — Listes, tuples, dictionnaires et ensembles45 min
Compréhensions, map / filter / reduce, piles et files — partie 120 min
Compréhensions, map / filter / reduce, piles et files — partie 220 min
Pratiquer — Compréhensions, map / filter / reduce, piles et files45 min
Variante — Compréhensions, map/filter/reduce, piles et files20 min
Pratiquer — Variante — Compréhensions, map/filter/reduce, piles et files45 min
Itérateurs, générateurs et traitement progressif — partie 120 min
Itérateurs, générateurs et traitement progressif — partie 220 min
Pratiquer — Itérateurs, générateurs et traitement progressif45 min
Variante — Itérateurs, générateurs et traitement progressif20 min
Pratiquer — Variante — Itérateurs, générateurs et traitement progressif45 min
Packages, imports, PyPI et organisation d’un projet — partie 120 min
Packages, imports, PyPI et organisation d’un projet — partie 220 min
Pratiquer — Packages, imports, PyPI et organisation d’un projet45 min
Variante — Packages, imports, PyPI et organisation d'un projet20 min
Pratiquer — Variante — Packages, imports, PyPI et organisation d'un projet45 min
Fichiers CSV, JSON et XML20 min
Pratiquer — Fichiers CSV, JSON et XML45 min
Variante — Fichiers CSV, JSON et XML20 min
Pratiquer — Variante — Fichiers CSV, JSON et XML45 min
SQLite, DAO/CRUD et introduction à l'ORM20 min
Pratiquer — SQLite, DAO/CRUD et introduction à l'ORM45 min
Variante — SQLite, DAO/CRUD et introduction à l'ORM20 min
Pratiquer — Variante — SQLite, DAO/CRUD et introduction à l'ORM45 min
HTTP, API REST, JSON et validation de données20 min
Pratiquer — HTTP, API REST, JSON et validation de données45 min
Variante — HTTP, API REST, JSON et validation de données20 min
Pratiquer — Variante — HTTP, API REST, JSON et validation de données45 min
Requêtes robustes, timeouts, retries et Pydantic20 min
Pratiquer — Requêtes robustes, timeouts, retries et Pydantic45 min
Variante — Requêtes robustes, timeouts, retries et Pydantic20 min
Pratiquer — Variante — Requêtes robustes, timeouts, retries et Pydantic45 min
Tkinter : widgets, layouts et événements20 min
Pratiquer — Tkinter : widgets, layouts et événements45 min
Variante — Tkinter : widgets, layouts et événements20 min
Pratiquer — Variante — Tkinter : widgets, layouts et événements45 min
Tests, doctest, documentation, profiling et qualité de code20 min
Pratiquer — Tests, doctest, documentation, profiling et qualité de code45 min
Variante — Tests, doctest, documentation, profiling et qualité de code20 min
Pratiquer — Variante — Tests, doctest, documentation, profiling et qualité de code45 min
Du procédural à l’objet — fonctions et fichiers20 min
Pratiquer — Du procédural à l’objet — fonctions et fichiers45 min
Du procédural à l’objet — équipes sportives, classe par classe — partie 120 min
Du procédural à l’objet — équipes sportives, classe par classe — partie 220 min
Du procédural à l’objet — équipes sportives, classe par classe — partie 320 min
Pratiquer — Du procédural à l’objet — équipes sportives, classe par classe45 min
Du besoin métier au premier programme25 min
Valeurs, choix, boucles, fonctions et collections35 min
Du premier interpréteur au projet reproductible25 min
Choisir une action avec match/case15 min
Passer d’un dictionnaire à un objet métier30 min
Instanciation, __init__ et self, ligne par ligne40 min
Attributs de classe, alias et durée de vie35 min
Checkpoint 1 — Personne : un état valide20 min
Cycle de vie, diagrammes et responsabilités25 min
Un objet valide avant et après chaque opération45 min
Faire évoluer une interface avec @property30 min
Personne, Participant et Formateur45 min
Héritage multiple, MRO et composition35 min
Checkpoint 2 — Participant : identité et présentation20 min
Checkpoint 3 — Formateur : spécialiser sans dupliquer20 min
Checkpoint 4 — Formation : encapsuler la durée20 min
Utiliser des objets par leur comportement40 min
Assembler des responsabilités35 min
Checkpoint 5 — Session : composer les objets20 min
Rendre ses objets naturels à utiliser35 min
Méthodes d’instance, de classe et statiques30 min
Traiter les échecs sans masquer les défauts40 min
Décrire les contrats avec les annotations25 min
Dataclasses et valeurs par défaut indépendantes35 min
Checkpoint 6 — Inscription : capacité et doublons30 min
Modules, packages et dépendances40 min
Tester un comportement et diagnostiquer une régression40 min
Checkpoint 7 — Persistance : reconstruire des objets valides30 min
Checkpoint 8 — Évaluation : données et règles30 min
Checkpoint 9 — Tests : conserver les invariants30 min
Mesurer, documenter et relire le projet30 min
Itérateurs, générateurs et choix des collections40 min
Lire des fichiers, CSV et JSON avec des contrats explicites45 min
Base de données, transactions et requêtes paramétrées45 min
Atelier local : API, XML et interface graphique120 min
Filtrage textuel et frontières du système25 min
Atelier approfondi : stockage, validation et interface55 min
TP de synthèse — livrer une application expliquée90 min
Exemples exécutables, atelier guidé, jeu de données synthétique, TP avec remise au formateur et quiz de dix questions. Le corrigé du TP devient accessible après le retour du formateur.
Durée, niveau, modalités, objectifs et tarif relevés sur le site officiel le 11 septembre 2026. Le déroulé détaillé a été enrichi par Beyond Expertise. Validation pédagogique du formateur à réaliser avant animation.
