Python | Programmation Objet Mixte : présentiel / à distance

Cette formation de cinq jours conduit les développeurs à maîtriser Python orienté objet : création de classes, héritage, organisation en modules/paquets et manipulation avancée de fichiers ou d’APIs Web. Elle aborde également la conception d’interfaces graphiques légères, l’assurance-qualité (tests unitaires, couverture, lint) et le packaging moderne avec génération de documentation et CI/CD.

Un volet « IA » illustre comment un LLM peut suggérer des tests tout en respectant la confidentialité du code. Chaque journée se conclut par un atelier pratique adaptable pour ancrer immédiatement les notions vues.

A l'issue de la formation, le stagiaire sera capable d'utiliser les principales fonctionnalités du langage de programmation Python pour développer des applications multiplateformes.

• 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

Développeurs, ingénieurs, chefs de projets proches du développement

Jour 1 – Découvrir le langage Python

Objectifs du jour :

• Écrire et exécuter un premier script
• Manipuler les types de base
• Gérer proprement les erreurs

Contenu :

• Le monde Python
  • Rôle de l'interpréteur et différence script / module
  • Installation Python et création d'un environnement virtuel
  • Convention PEP 8 : pourquoi appliquer un style homogène
• Types & séquences
  • Nombres, chaînes, listes, tuples : quand choisir l'un ou l'autre
  • Immuable vs mutable : impact sur la mémoire et les performances
  • Slicing : extraire rapidement des sous-listes ou sous-chaînes
• Structures de contrôle
  • Brancher la logique avec if / elif / else
  • Répéter des actions via « for » et « while »
  • Compréhensions de liste : filtrer ou transformer en une seule ligne
• Gestion d'exceptions
  • Bloc try / except / finally comme « air-bag » de sécurité
  • Afficher un message d'erreur clair plutôt qu'une trace illisible
• Introduction à datetime

• Atelier pratique :
  • Transformer un CSV en JSON via la ligne de commande, avec gestion d'erreurs si le fichier ou l'encodage est incorrect.

Jour 2 – Passer à la programmation orientée Objet

Objectifs du jour :

• Créer des classes réutilisables
• Appliquer héritage et encapsulation
• Structurer un projet en paquets importables

Contenu :

• Classes & objets :
  • Initialiser les attributs
  • Attributs publics, protégés, privés : règles de nommage
  • Propriétés pour contrôler l'accès en lecture/écriture
  • Exceptions personnalisées
• Héritage & polymorphisme :
  • Composition vs Héritage
  • Partager du code commun via super()
  • Surcharge de méthodes pour un comportement spécialisé
  • Duck typing (souplesse Python)
  • ABC : définir un contrat formel d'interface
• Modules & paquets :
  • Organiser les fichiers dans des dossiers
  • Imports relatifs pour éviter les chemins absolus volumineux
  • Lancer un paquet en mode exécutable
• Patterns simples : factory, Singleton à la mode Python
• Gestion des dépendances :
  • Installer une bibliothèque dans le bon environnement
  • Geler les versions dans « requirements.txt » pour la reproductibilité

• Atelier pratique :
  • Modélisation d'un petit domaine (au choix) avec rappel UML de base
  • Créer la hiérarchie de classes
  • Sérialiser un objet en JSON puis le reconstituer depuis ce fichier.

Jour 3 – Fonctions avancées, fichiers & Web

Objectifs :

• Exploiter fonctions de “première classe”
• Lire / écrire des données locales
• Interroger une API Web

Contenu :

• Fonctions « citoyens de première classe » :
  • Passer une fonction en paramètre (tri personnalisé, callbacks)
  • Lambda & closure : écrire des fonctions anonymes d'une ligne
  • Décorateurs simples : ajouter journalisation ou chronométrage
• Entrées / sorties & sérialisation :
  • Chemins multiplateformes avec pathlib
  • Lire / écrire des fichiers texte et binaires (JSON csv)
  • Précaution de sécurité
• Accès Web simplifié :
  • Envoyer une requête GET pour récupérer un JSON public
  • Uitliser requests.session pour réutiliser une connexion sur plusieurs appels
  • Gérer le délai maximal (timeout) et les erreurs réseau
  • Décoder la réponse et transformer en objets Python

• Atelier pratique :
  • Lire un CSV
  • Convertir chaque ligne en objet Python
  • Exporter en JSON et chronométrer l'opération via un décorateur.

Jour 4 – Interface utilisateur et assurance-qualité

Objectifs du jour :

• Créer une interface graphique simple
• Mettre en place tests unitaires + couverture
• Découvrir l'apport d'un LLM pour générer des tests

Contenu :

• Interface graphique (Tkinter / PySimpleGUI) :
  • Boucle d'évènements : « j'attends un clic et je réagis »
  • Positionner les widgets avec grilles ou boîtes flexibles
  • Séparer la logique (contrôleur) de l'affichage (vue)
  • Alternatives : streamlit, textual, PyWebIO
• Tests & lint :
  • Créer une « check-list automatique »
  • Mesurer ce qui n'est pas couvert avec coverage
  • Maintenir un style uniforme grâce au linter flake8 / ruff
• IA légère pour les tests :
  • Générer un squelette de test via outil LLM
  • Vérifier manuellement, corriger et compléter
  • Mention RGPD / confidentialité & responsabilité de relecture

• Atelier pratique :
  • Exemple d'exercice Mini-calculatrice GUI
  • Construire la fenêtre et ses boutons
  • Demander à l'IA un test d'addition, puis l'étendre pour gérer un cas d'erreur (division par zéro, champ vide)

Jour 5 – Packaging, documentation et CI/CD

Objectifs du jour :

• Créer un package installable
• Générer documentation HTML
• Mettre en place une chaîne CI simple

Contenu :

• Packaging moderne :
  • Déclarer nom, version, auteurs et dépendances
  • Construire un fichier installable partout
  • Différencier dépendances d'exécution et de développement
• Documentation & typage :
  • Rédiger des docstrings format Google ou NumPy
  • Générer un site HTML en quelques commandes
  • Ajouter des annotations typing et détecter les incohérences avec mypy
• Intégration continue (CI/CD) :
  • Créer un workflow GitHub / GitLab : lint ➔ tests ➔ build package
  • Recevoir un retour immédiat pour éviter les régressions
  • Publier le package sur un registre interne ou PyPI privé

• Atelier pratique :
  • Mettre en production locale
  • Puis ajouter un pyproject.toml
  • Générer la doc Sphinx, puis compléter un pipeline CI YAML (squelette fourni) pour lancer lint et les tests automatiquement
  • Auditer une fonction Python : détection mauvaise pratique

Docaposte Institute propose plusieurs dispositifs pédagogiques adaptés aux apprenants :

• Formation en présentiel
• En groupe (inter-entreprises ou intra-entreprise)
• En individuel (monitorat)
• En journée ou en cours du soir (sur demande spécifique)
• Formation en distanciel
• Distanciel synchrone
• Distanciel asynchrone

• Apports des connaissances communes.
• Mises en situation sur le thème de la formation et des cas concrets.
• Méthodologie d'apprentissage attractive, interactive et participative.
• Equilibre théorie / pratique : 60 % / 40 %.
• Supports de cours fournis au format papier et/ou numérique.
• Ressources documentaires en ligne et références mises à disposition par le formateur.
• Pour les formations en présentiel dans les locaux mis à disposition, les apprenants sont accueillis dans une salle de cours équipée d'un réseau Wi-Fi, d'un tableau blanc ou paperboard. Un ordinateur avec les logiciels appropriés est mis à disposition (le cas échéant).

En amont de la formation :

• Recueil des besoins des apprenants afin de disposer des informations essentielles au bon déroulé de la formation (profil, niveau, attentes particulières...).
• Auto-positionnement des apprenants afin de mesurer le niveau de départ.

Tout au long de la formation : 

• Évaluation continue des acquis avec des questions orales, des exercices, des QCM, des cas pratiques ou mises en situation...

A la fin de la formation : 

• Auto-positionnement des apprenants afin de mesurer l'acquisition des compétences.
• Evaluation par le formateur des compétences acquises par les apprenants.
• Questionnaire de satisfaction à chaud afin de recueillir la satisfaction des apprenants à l'issue de la formation.
• Questionnaire de satisfaction à froid afin d'évaluer les apports ancrés de la formation et leurs mises en application au quotidien.

• Admission sans disposition particulière