Formation Python Initiation – 5 jours intensifs

🌟 Pourquoi choisir cette formation ?

Python est aujourd'hui le langage le plus accessible et polyvalent pour débuter en programmation. Pourquoi ?

• Simple et intuitif : Une syntaxe claire et lisible qui permet de se concentrer sur la logique de programmation plutôt que sur des détails techniques complexes.
• Puissant dès le début : Une bibliothèque standard riche qui vous permet de créer des programmes utiles rapidement, sans avoir à tout réinventer.
• Universel : Un langage qui fonctionne partout (Windows, Linux, macOS) et s'applique à tous les domaines : web, data, automatisation, scripts...

Mais pour bien démarrer, il faut maîtriser les fondamentaux :

• Comprendre la syntaxe et les structures de base du langage.
• Savoir créer et utiliser des fonctions pour organiser son code.
• Manipuler les structures de données essentielles (listes, dictionnaires, etc.).
• Adopter les bonnes pratiques dès le début pour écrire du code propre et maintenable.

🎯 En 5 jours seulement, cette formation vous donnera les clés pour :

• Écrire vos premiers programmes Python de manière autonome.
• Résoudre des problèmes concrets en appliquant la logique de programmation.
• Manipuler des données et automatiser des tâches du quotidien.
• Structurer votre code avec des fonctions et des modules réutilisables.
• Comprendre les concepts qui vous permettront d'aller plus loin ensuite (POO, frameworks, etc.).

Que vous débutiez totalement en programmation ou que vous connaissiez déjà un autre langage, cette formation est conçue pour vous rendre autonome et confiant avec Python.

🎯 Objectifs pédagogiques

Acquérir les fondamentaux de Python 3 et de la programmation : syntaxe, opérateurs, structures de contrôle, fonctions, structures de données, manipulation de fichiers et bonnes pratiques.

• Maîtriser la syntaxe Python et les types de données fondamentaux.
• Comprendre et utiliser les opérateurs (arithmétiques, logiques, de comparaison).
• Contrôler le flux d'exécution avec les structures conditionnelles et les boucles (programmation impérative).
• Créer et organiser son code avec des fonctions (programmation procédurale).
• Découvrir la programmation fonctionnelle (lambda, map, filter, reduce).
• Manipuler les structures de données essentielles (listes, dictionnaires, tuples, sets).
• Lire et écrire dans des fichiers (txt, csv, json).
• Structurer son code en modules réutilisables.
• Appliquer les bonnes pratiques et conventions PEP 8.

📌 Prérequis

✅ Aucun prérequis en programmation n'est nécessaire.
💻 Connaissances de base en informatique : navigation fichiers/dossiers, installation de logiciels.
🧠 Logique et curiosité : envie d'apprendre et de résoudre des problèmes.
Cette formation est conçue pour les débutants complets en programmation.

👥 Public cible

Tous les professionnels souhaitant débuter avec Python :

• Débutants complets en programmation voulant apprendre leur premier langage.
• Professionnels en reconversion vers les métiers du développement, de la data ou de l'automatisation.
• Analystes, chargés d'études et data analysts souhaitant automatiser leurs traitements.
• Chefs de projet, product owners voulant comprendre les bases de la programmation pour mieux collaborer avec les équipes techniques.
• Scientifiques, chercheurs ayant besoin de traiter des données ou d'automatiser des calculs.
• Administrateurs systèmes et techniciens IT voulant automatiser des tâches d'administration.
• Toute personne curieuse souhaitant découvrir la programmation par un langage accessible et puissant.

🚀 Compétences acquises

• Écrire des programmes Python fonctionnels et bien structurés
• Utiliser les opérateurs et structures de contrôle efficacement
• Créer et documenter des fonctions réutilisables
• Manipuler les structures de données Python (listes, dictionnaires, etc.)
• Lire et écrire des fichiers de différents formats
• Organiser son code en modules
• Gérer les erreurs de manière appropriée
• Appliquer les conventions et bonnes pratiques Python

📅 Programme de la formation

# JOUR 1 – Découverte de Python et premiers pas

1. Introduction à Python

• Qu'est-ce que Python ? Historique et domaines d'application
• Python 2 vs Python 3
• Nouveautés Python 3.14
• Installation de Python, PIP, UV
• Environnements de développement (IDLE, VS Code, PyCharm)
• Premier programme : "Hello World"
• Compilation vs interprétation

2. Syntaxe de base et types de données

• Conventions PEP 8 (style de code)
• Commentaires et documentation
• Variables et affectation
• Types de données primitifs : bool, int, float, complex, str
• Conversions de types (casting)
• Opérateurs arithmétiques (+, -, *, /, //, %, **)
• Opérateurs de comparaison (==, !=, <, >, <=, >=)
• Opérateurs logiques (and, or, not)
• Opérateurs d'affectation composée (+=, -=, *=, etc.)

3. Chaînes de caractères et formatage

• Manipulation de chaînes (concaténation, répétition)
• Méthodes de chaînes (upper, lower, strip, split, join, etc.)
• Indexation et slicing
• f-strings (formatted string literals)
• t-strings (nouveauté Python 3.14)
• Formatage avec format()

# JOUR 2 – Structures de contrôle et fonctions

4. Structures conditionnelles

• Instructions if, elif, else
• Conditions imbriquées
• Opérateur ternaire
• match case (Python 3.10+)
• Valeurs booléennes et expressions logiques

5. Boucles et itérations

• Boucle while : syntaxe et cas d'usage
• Boucle for : itération sur des séquences
• range() : générer des séquences de nombres
• break : sortir d'une boucle
• continue : passer à l'itération suivante
• else avec les boucles
• Boucles imbriquées

6. Introduction aux fonctions

• Définition et appel de fonctions (def)
• Paramètres et arguments
• Valeurs de retour (return)
• Portée des variables (scope : local vs global)
• Documentation des fonctions (docstrings)

# JOUR 3 – Structures de données et fonctions avancées

7. Listes (lists)

• Création et initialisation
• Indexation et slicing
• Méthodes : append, extend, insert, remove, pop, sort, reverse
• List comprehensions (compréhensions de listes)
• Parcours et manipulation

8. Tuples et sets

• Tuples : création, immutabilité, cas d'usage
• Unpacking (déballage de tuples)
• Sets : création, opérations ensemblistes
• Frozensets

9. Dictionnaires (dicts)

• Création et initialisation
• Accès aux valeurs par clé
• Méthodes : get, keys, values, items, update
• Dictionary comprehensions
• Parcours de dictionnaires

10. Fonctions avancées

• Arguments positionnels et nommés
• Arguments par défaut
• *args et **kwargs (arguments variables)
• Fonctions lambda (fonctions anonymes)
• Fonctions map, filter, reduce
• Fonctions récursives (introduction)

# JOUR 4 – Manipulation de fichiers et modules

11. Gestion des erreurs

• Comprendre les exceptions
• try, except, else, finally
• Capturer des exceptions spécifiques
• Lever des exceptions (raise)
• Créer ses propres exceptions

12. Manipulation de fichiers

• Ouverture et fermeture de fichiers (open, close)
• Modes d'ouverture (r, w, a, r+, etc.)
• Lecture de fichiers (read, readline, readlines)
• Écriture dans des fichiers (write, writelines)
• Context manager (with statement)
• Manipulation de fichiers texte (.txt)
• Fichiers CSV (module csv)
• Fichiers JSON (module json : dumps, loads, dump, load)

13. Modules et packages

• Qu'est-ce qu'un module ?
• Importer des modules (import, from...import)
• Créer ses propres modules
• Organisation en packages
• Bibliothèque standard Python
• Installation de packages externes avec pip

14. Modules de la bibliothèque standard

• sys : arguments ligne de commande, informations système
• os et os.path : manipulation de fichiers et répertoires
• datetime : manipulation de dates et heures
• re : expressions régulières (introduction)
• random : génération de nombres aléatoires
• math : fonctions mathématiques

# JOUR 5 – Introduction à la POO et projet final

15. Introduction à la Programmation Orientée Objet

• Concepts de base : classes et objets
• Création d'une classe simple (class)
• Attributs et méthodes
• Constructeur (__init__)
• self : référence à l'instance
• Méthodes d'instance vs méthodes de classe
• Encapsulation de base (attributs privés : convention _)
• Quand utiliser la POO vs programmation fonctionnelle

16. Bonnes pratiques et conseils

• PEP 8 : conventions de style
• Nommage des variables, fonctions et classes
• Organisation du code
• Commentaires et documentation
• Déboguer son code (print debugging, debugger)
• Ressources pour continuer à apprendre

17. Projet final

• Projet pratique intégrant tous les concepts vus
• Analyse du problème et conception
• Structuration en fonctions et modules
• Manipulation de données et fichiers
• Gestion des erreurs
• Code propre et documenté
• Présentation du projet

💡 Note : Cette formation enseigne principalement la programmation impérative et procédurale, avec une introduction à la programmation fonctionnelle (lambda, map, filter). La POO est abordée en fin de formation uniquement pour comprendre les concepts de base et savoir quand l'utiliser. Pour maîtriser pleinement la programmation orientée objet, les principes SOLID et les design patterns, nous recommandons notre formation Python Orienté Objet.