Votre avenir commence ici

Inscrivez-vous à la formation et réalisez votre projet !

Intitulé : Maîtriser la Programmation en Python 3

Durée : 35 heures réparties sur 5 jours (Du lundi au vendredi de 9h à 17h)

Objectifs pédagogiques :

  • Comprendre les fondamentaux de la programmation avec Python 3 (syntaxe, structures de contrôle, types de données)

  • Écrire, lire et corriger des scripts Python simples et bien structurés

  • Utiliser les principales structures de données (listes, dictionnaires, ensembles, tuples)

  • Concevoir et utiliser des fonctions pour factoriser le code et favoriser la réutilisation

  • Gérer les erreurs avec les instructions d’exception (try, except, finally)

  • Découvrir la programmation orientée objet (classes, objets, héritage simple)

  • Manipuler des modules standards pour enrichir les fonctionnalités des programmes (ex : math, random, os)

  • Lire et écrire dans des fichiers en Python (I/O basique)

  • Appliquer les bonnes pratiques de codage (PEP8, clarté, modularité)

  • Développer des mini-projets pratiques comme des calculateurs, jeux simples, ou scripts d'automatisation

Public visé :

  • Débutants motivés sans connaissance préalable en programmation

  • Professionnels souhaitant s'initier au développement Python pour des projets métiers

  • Étudiants en reconversion vers des métiers de la tech

Prérequis :

  • Savoir utiliser un ordinateur : naviguer dans les dossiers, installer un logiciel

  • Aucun prérequis en programmation n'est nécessaire
    (La formation commence des bases absolues vers un premier niveau d'autonomie)

Méthodes pédagogiques :

  • Approche progressive

  • Pédagogie active (en direct)

  • Micro-projets

  • Visualisation

  • QCM et auto-évaluation

  • Projet final synthétique

Niveau 1 : Initiation à la programmation Python

Durée : 7 heures

Objectifs pédagogiques :

  • Comprendre ce qu’est un langage de programmation et à quoi sert Python

  • Créer, nommer et manipuler des variables simples

  • Afficher des données à l’écran

  • Travailler avec les types de base : chaînes de caractères, nombres, booléens

  • Écrire des conditions logiques avec if, else, elif

  • Créer des fonctions et structurer une réponse (liste, dictionnaire)

  • Utiliser des modules standards (math, random)

  • Produire un petit programme complet structuré et lisible

Contenu :

  • Introduction à Python et variables.

  • Qu’est-ce qu’un langage ?

  • Variables, types de base (int, str, float)

  • Fonction print()

  • Commentaires et lisibilité

  • Commentaires simples avec #

  • Docstrings

  • Importance des noms explicites et de la clarté du code

  • Chaînes et numériques

  • Manipulation de chaînes : upper(), replace(), len()

  • Opérations mathématiques

  • Conversion entre texte et nombre

  • Booléens et conditions

  • Valeurs True, False

  • Opérateurs de comparaison : ==, !=, >, <

  • Structures conditionnelles : if, else, elif

  • Modules et packages

  • Utilité d’un module

  • Import de modules : math, random

  • Fonctions intégrées (sqrt, randint, choice)

  • Fonctions et retour structuré

  • Définir une fonction avec def

  • Différence entre print() et return

  • Retourner des listes, dictionnaires, tuples

  • Mini projet de synthèse

  • Création d’un générateur de profil utilisateur

  • Réutilisation des fonctions

  • Structuration et affichage clair des résultats

Compétences visées :

  • Langage et syntaxe

  • Comprendre la structure d’un programme Python

  • Utiliser les conventions de nommage

  • Afficher du contenu avec print()

  • Structures de données

  • Manipuler des types simples (str, int, float, bool)

  • Utiliser des listes et dictionnaires simples

  • Logique de programmation

  • Réaliser des tests conditionnels avec if, elif, else

  • Construire des expressions logiques (avec and, or, not)

  • Fonctions

  • Définir une fonction avec def

  • Utiliser return pour produire un résultat

  • Retourner des formats standards (liste, tuple, dictionnaire)

  • Modules et packages

  • Connaître l’utilité des packages

  • Importer et utiliser un module de la bibliothèque standard

Méthodes pédagogiques :

  • Approche progressive chaque notion est introduite avec des explications simples, suivies d’exemples pratiques, puis d’un exercice guidé.

  • Pédagogie active

    chaque participant code en même temps que le formateur (exercices pratiques en direct).

  • Micro-projets

    mini-défis pour ancrer les compétences.

  • Visualisation

    explication visuelle des blocs de code, des types de données, des structures.

  • QCM et auto-évaluation

    intégrés après chaque module pour valider les acquis.

  • Projet final synthétique pour réutiliser toutes les notions dans un cas concret.

Niveau 2 : Approfondissement des fondamentaux

Durée : 7 heures

Objectifs pédagogiques :

  • Utiliser les opérateurs arithmétiques et les flux de contrôle conditionnels

  • Maîtriser les boucles for et while

  • Manipuler efficacement les structures de données intégrées : liste, dictionnaire, ensemble

  • Importer et exploiter les fonctions de modules standards

  • Lire et traiter des entrées utilisateur multiples

  • Choisir le type de données adapté à chaque cas d’usage

  • Réaliser un script structuré et interactif, intégrant plusieurs types de données et une logique conditionnelle

Contenu :

  • Python dans le monde réel & rappels fondamentaux

  • Cas d’usage pro de Python

  • Types simples et type()

  • Arithmétique et conditions

  • Opérateurs mathématiques

  • Conditions simples, imbriquées

  • Flux de contrôle

  • Boucles et itérations

  • for, while, range()

  • Interruption (break) et saut (continue)

  • Structures de données

  • Listes, dictionnaires, ensembles

  • Manipulation, ajout/suppression, parcours

  • Modules

  • Import de fonctions / modules

  • Utilisation de math, random, datetime

  • Entrées et typage

  • input() et conversion de types

  • Stockage et adaptation au type

  • Atelier final

  • Script interactif complet (mini gestionnaire de notes, ou simulateur de panier)

Compétences visées :

  • Langage et syntaxe

  • Identifier les types (str, int, float, bool)

  • Comprendre les cas d’usage de Python dans le monde réel

  • Utiliser les opérateurs : +, -, *, /, //, %, **

  • Structurer le flux d’un programme avec if, elif, else

  • Logique de contrôle et boucles

  • Créer des boucles avec for et while

  • Gérer les interruptions avec break et continue

  • Parcourir des chaînes, des listes, des range()

  • Structures de données

  • Créer et manipuler des listes, dictionnaires, ensembles

  • Utiliser les fonctions intégrées : min(), max(), len()

  • Accéder et modifier des éléments dans des structures combinées

  • Modules et réutilisabilité

  • Importer un module ou une fonction avec import et from ... import

  • Utiliser les fonctions de modules tels que math, random, datetime

  • Entrée de données et typage

  • Lire une ou plusieurs entrées utilisateur avec input()

  • Convertir des entrées en int, float, bool

  • Combiner différents types dans un même traitement

  • Autonomie et structuration du code

  • Organiser les instructions dans un script clair et logique

  • Structurer des données selon leur usage

  • Écrire un programme interactif cohérent de A à Z

Méthodes pédagogiques :

  • Approche progressive chaque notion est introduite avec des explications simples, suivies d’exemples pratiques, puis d’un exercice guidé.

  • Pédagogie active

    chaque participant code en même temps que le formateur (exercices pratiques en direct).

  • Micro-projets

    mini-défis pour ancrer les compétences.

  • Visualisation

    explication visuelle des blocs de code, des types de données, des structures.

  • QCM et auto-évaluation

    intégrés après chaque module pour valider les acquis.

  • Projet final synthétique pour réutiliser toutes les notions dans un cas concret

Niveau 3 : Structuration, automatisation, et traitement de données complexes

Durée : 7 heures

Objectifs pédagogiques :

  • Maîtriser la logique de traitement algorithmique

  • Créer et documenter leurs propres fonctions

  • Modéliser et extraire des informations à partir de structures complexes

  • Utiliser des packages standards et comprendre l’organisation d’un module Python

  • Lire et traiter un flux d’entrée (standard ou fichier)

  • Organiser du code modulaire, réutilisable et lisible

  • Structurer un programme pour traiter, trier et analyser un volume important de données

Contenu :

  • Introduction & rappels évolutifs

  • Différences entre versions Python

  • Compatibilité ascendante

  • Évolution des fonctionnalités (ex : print, division, f-strings)

    Arithmétique et logique

  • Priorité des opérations

  • Opérateurs de comparaison

  • Combinaisons logiques dans des conditions imbriquées

  • Exécution conditionnelle dans les boucles

  • Fonctions avancées

  • Définition propre avec paramètres

  • Valeur de retour claire et typée

  • Documentation de la fonction avec """docstring"""

  • Bonnes pratiques de découpage du code

  • Itération sur objets structurés

  • Boucles for sur list, dict, tuple, set

  • Méthodes utiles : .items(), .keys(), .values()

  • Utilisation de enumerate() et zip()

  • Exemples d’algorithmes d’itération

  • Modules standards utiles

  • Utilisation des fonctions de math : sqrt(), ceil(), pow()

  • Génération d’aléatoire avec random() et randint()

  • Création et utilisation de modules personnalisés

  • Gestion des import, from, et visibilité

  • Traitement et tri de données

  • Trier une liste de nombres, de chaînes, de tuples

  • Trier un dictionnaire par clé ou par valeur

  • Appliquer des clés de tri personnalisées avec lambda

  • Filtrer des structures selon des règles conditionnelles

  • Complexité et modélisation de problème

  • Notion de complexité (O(1), O(n), O(n²))

  • Création de structures type graphe avec dictionnaires imbriqués

  • Simulations simples de parcours de graphe

  • Choix stratégique des boucles et conditions

  • Projet final synthétique

  • Exemples de mini-projets

  • Classement d’élèves avec notes, tri, moyenne

  • Générateur de jeux de données aléatoires

  • Visualisation de connexions dans un graphe simplifié

  • Structuration en fonctions, modules, appels

Compétences visées :

  • Langage et syntaxe

  • Connaître les différences entre versions Python

  • Maîtriser l’ordre des opérations dans une expression

  • Créer des variables pertinentes et bien nommées

  • Utiliser les instructions de contrôle avancées dans les boucles

  • Lire des données en entrée standard (manuelle ou automatisée)

  • Structures de données et objets

  • Documenter une fonction proprement (docstring)

  • Itérer sur des objets structurés (liste de dictionnaires, dictionnaire de listes…)

  • Utiliser les méthodes associées aux objets (append(), items(), keys(), etc.)

  • Créer des fonctions claires, paramétrables et testables

  • Modules et packages

  • Importer et utiliser des modules spécifiques (math, random)

  • Créer un fichier de module réutilisable (.py)

  • Distinguer les composants internes d’un module : __name__, __doc__, etc.

  • Identifier et connaître les packages principaux de la bibliothèque standard

  • Optimisation et traitement de données

  • Trier des listes ou dictionnaires selon des critères personnalisés

  • Créer des boucles imbriquées avec conditions multiples

  • Modéliser un graphe simple (en dict ou liste d’adjacence) et le parcourir

  • Extraire automatiquement une information pertinente d’un grand volume de données

Méthodes pédagogiques :

  • Approche progressive

    chaque notion est introduite avec des explications simples, suivies d’exemples pratiques, puis d’un exercice guidé.

  • Pédagogie active

    chaque participant code en même temps que le formateur (exercices pratiques en direct).

  • Micro-projets

    mini-défis pour ancrer les compétences.

  • Visualisation

    explication visuelle des blocs de code, des types de données, des structures.

  • QCM et auto-évaluation

    intégrés après chaque module pour valider les acquis.

  • Projet final synthétique pour réutiliser toutes les notions dans un cas concret

Niveau 4 : Conception orientée objet, performance, et exploitation avancée des ressources Python

Durée : 7 heures

Objectifs pédagogiques :

  • Distinguer les composants fondamentaux du langage Python (cœur du langage vs bibliothèques)

  • Gérer la lecture, l’écriture et la modification de fichiers

  • Maîtriser les structures par compréhension (list, set, dict)

  • Choisir les structures selon leur mutabilité

  • Utiliser des f-strings pour un affichage structuré

  • Créer des fonctions avec arguments variés (*args, **kwargs)

  • Écrire et initialiser des classes Python

  • Naviguer dans un package et installer un module externe avec pip

  • Optimiser le code avec des structures performantes et natives

  • Distinguer les complexités algorithmiques simples (O(1), O(n), O(n²))

Contenu :

  • Introduction avancée

  • Ce qui fait la spécificité du langage Python

  • Différence entre Python et ses bibliothèques externes

  • Structure d’un script lisible et modulaire

  • Littéraux, print et fichiers

  • Types littéraux (True, None, 0x, chaînes multilignes)

  • Utilisation avancée de print()

  • Écriture et lecture de fichiers avec open() et context manager (with)

  • Compréhensions et mutabilité

  • Création de listes, ensembles, dictionnaires par compréhension

  • Comparaison entre objets mutables et immuables

  • Impact sur la performance et la conception

  • f-strings et fonctions avancées

  • Utilisation de f"{variable:.2f}", f"{len(nom)} caractères"

  • Fonctions avec paramètres variables (*args, **kwargs)

  • Typage facultatif avec annotations

  • POO : classes simples

  • Création d’une classe avec __init__()

  • Déclaration des attributs et méthodes

  • Introduction aux méthodes spéciales (__str__, __repr__)

  • Modules, packages et pip

  • Exploration d’un module (math, random, os)

  • Utilisation de dir(), help(), __doc__

  • Installation avec pip install, gestion d’environnement virtuel

  • Cas d’usage de json, datetime, os.path, re

  • Optimisation et complexité

  • Choix de structures selon le contexte

  • Utilisation de zip(), map(), filter(), enumerate()

  • Exemples de complexité : boucle simple (O(n)), double boucle (O(n²))

  • Lecture de gros volumes de données (fichiers, listes)

  • Mini projet de synthèse

  • Création d’un outil simple type :

  • Analyseur de fichier texte avec résumé

  • Outil de regroupement / nettoyage de données

  • Générateur structuré d’objets (ex. : simulateur de fiches produits)

  • Structuration en plusieurs fichiers et modules

Compétences visées :

  • Langage et syntaxe

  • Comprendre les spécificités fondamentales de Python (indentation, gestion mémoire, etc.)

  • Maîtriser les littéraux (chaînes, numériques, booléens, None)

  • Respecter les règles syntaxiques sur la déclaration et le nommage des variables

  • Utiliser print() avec ses paramètres (sep, end, file)

  • Lire et écrire dans un fichier texte

  • Structures de données et objets

  • Utiliser des listes, dictionnaires et ensembles en compréhension

  • Identifier et choisir les structures selon leur mutabilité

  • Créer et formater des f-strings dynamiques

  • Définir des fonctions avec paramètres optionnels, nommés et multiples

  • Créer une classe avec un constructeur __init__() et des attributs

  • Modules et packages

  • Naviguer dans un package avec dir(), help()

  • Installer des packages avec pip

  • Réutiliser des fonctions de la bibliothèque standard

  • Identifier les cas d’usage des modules comme os, json, datetime, re, etc.

  • Optimisation de code

  • Créer des structures optimisées selon le problème (sets, tuples, dictionnaires imbriqués)

  • Utiliser des fonctions natives performantes : map(), filter(), zip(), enumerate()

  • Distinguer les niveaux de complexité algorithmique : constant, linéaire, quadratique

Méthodes pédagogiques :

  • Approche progressive

    chaque notion est introduite avec des explications simples, suivies d’exemples pratiques, puis d’un exercice guidé.

  • Pédagogie active

    chaque participant code en même temps que le formateur (exercices pratiques en direct).

  • Micro-projets

    mini-défis pour ancrer les compétences.

  • Visualisation

    explication visuelle des blocs de code, des types de données, des structures.

  • QCM et auto-évaluation

    intégrés après chaque module pour valider les acquis.

  • Projet final synthétique pour réutiliser toutes les notions dans un cas concret

Niveau 5 : Python expert

Durée : 7 heures

Objectifs pédagogiques :

  • Gérer les erreurs de manière fine (try/except, exceptions personnalisées)

  • Manipuler les scopes, namespaces et comprendre le fonctionnement de l’interpréteur

  • Utiliser des fonctions lambda, des décorateurs et des générateurs

  • Créer des classes avancées avec héritage et méthodes spéciales

  • Travailler avec des modules système, charger dynamiquement des fichiers

  • Dialoguer avec des APIs web ou télécharger du contenu Internet

  • Refactoriser et optimiser un code existant en le rendant modulaire, lisible et performant

  • Produire un script Python connecté, structuré, modulaire et autonome

Contenu :

  • Gestion des erreurs et environnement d’exécution

  • try / except / else / finally

  • Création d’exceptions personnalisées

  • Utilisation d’exceptions dans la logique métier

  • Découverte des scopes Python (LEGB)

  • Identification des contextes d’exécution (terminal, IDE, notebook, script)

  • Programmation fonctionnelle avancée

  • Création de lambda simples et combinées

  • Mise en place de décorateurs avec ou sans paramètres

  • Utilisation des générateurs avec yield

  • Intérêt pour les traitements longs ou paresseux

  • Programmation orientée objet avancée

  • Définition de méthodes spéciales (__str__, __len__, __eq__)

  • Mise en place d’une hiérarchie d’objets

  • Héritage, surcharge de méthodes avec super()

  • Structuration d’un projet orienté objet

  • Modules, fichiers compilés et système

  • Structure des modules, __pycache__, .pyc

  • Import dynamique avec __import__() et getattr()

  • Utilisation de os, sys, gestion des chemins, arguments CLI

  • Lecture et traitement de fichiers JSON, CSV, XML

  • Scripts Python connectés

  • Envoi de requêtes HTTP avec requests

  • Récupération et traitement de données JSON issues d’une API

  • Téléchargement de fichiers depuis le web

  • Script dynamique prenant des entrées, interagissant avec un serveur

  • Optimisation, refactoring, modularisation

  • Refactorisation de code long : nommage, factorisation, découpage

  • Réorganisation en fichiers fonctionnels : main.py, utils.py, api.py…

  • Choix stratégique des structures (dict, set, list) selon le besoin

  • Notions de complexité algorithmique appliquées au quotidien

  • Atelier final : projet complet expert

  • Mini-projet Python avec :

  • lecture de données depuis un fichier

  • appel à une API publique

  • décorateur, générateur, classe métier

  • écriture dans un fichier

  • structure multi-fichier

  • Résultat : un script robuste, connecté, modulaire, lisible, autonome

Compétences visées :

  • Langage et syntaxe

  • Créer et manipuler des exceptions personnalisées

  • Intégrer des erreurs aux flux de contrôle métier

  • Comprendre et gérer les scopes LEGB (Local, Enclosed, Global, Built-in)

  • Distinguer différents environnements d’exécution Python

  • Structures de données et objets

  • Créer et utiliser des lambda functions

  • Utiliser des générateurs avec yield

  • Appliquer et créer des décorateurs personnalisés

  • Définir les méthodes spéciales d’une classe (__str__, __len__, etc.)

  • Organiser et gérer l’héritage multiple ou complexe

  • Modules et packages

  • Reconnaître et comprendre les fichiers compilés .pyc

  • Utiliser les références internes dynamiques (__import__, getattr)

  • Travailler avec des modules système (os, sys)

  • Lire, traiter, exporter des documents JSON, CSV, XML

  • Interagir avec des ressources web (API)

  • Optimisation de code

  • Lire, analyser et refactoriser un script complexe

  • Identifier les structures de données optimales

  • Réorganiser un script en fonctions et modules

  • Appliquer des notions de performance et complexité

Méthodes pédagogiques :

  • Approche progressive chaque notion est introduite avec des explications simples, suivies d’exemples pratiques, puis d’un exercice guidé.

  • Pédagogie active

    chaque participant code en même temps que le formateur (exercices pratiques en direct).

  • Micro-projets

    mini-défis pour ancrer les compétences.

  • Visualisation

    explication visuelle des blocs de code, des types de données, des structures.

  • QCM et auto-évaluation

    intégrés après chaque module pour valider les acquis.

  • Projet final synthétique pour réutiliser toutes les notions dans un cas concret

C’est parti ?

Tarifs et Financements
La formation complète

1 490 € TTC

Ce tarif comprend :

  • L’accès à l’ensemble des modules de formation (35 heures).

  • Les supports pédagogiques (guides PDF, fiches pratiques, modèles de documents).

  • Les outils et ressources numériques utilisés pendant la formation.

  • Un suivi individualisé par un formateur dédié.

  • La délivrance d’une attestation de formation en fin de parcours.

Modalités de Paiement

  • Paiement en une fois

    • Montant total : 1 490 € TTC.

    • À régler avant le début de la formation.

Tarifs et Financements
Par module

590 € TTC

Ce tarif comprend :

  • L’accès à 1 modules de formation (7 heures).

  • Le supports pédagogiques (guides PDF, fiches pratiques, modèles de documents).

  • Les outils et ressources numériques utilisés pendant la formation.

  • Un suivi individualisé par un formateur dédié.

Modalités de Paiement

  • Paiement en une fois

    • Montant total : 590 € TTC.

    • À régler avant le début de la formation.