De l'Algorithmique à l'Expertise Python

Concepts de base de l'Algorithmique

• Définition : Recette, Itinéraire, Précision et Vocabulaire partagé.
• Cycle de vie d'un programme.

Savoir ce qu'est un algorithme et identifier un problème qui nécessite une solution algorithmique.

 

Représentation (Pseudo-code)

• Règles d'écriture et syntaxe du pseudo-code. 
• Délimiteurs.
• Passage à une traduction machine (compilation, interprétation).

Maîtriser le vocabulaire du pseudo-code pour exprimer une idée de programmation.

 

Variables et Types Simples

• Notion de variable, d'affectation (<-).
• Types fondamentaux (Entier, Réel, Texte/Chaîne, Booléen).

Définir une variable, l'initialiser et comprendre l'importance du type pour le stockage d'information.

 

Structures de Contrôle

• Les conditions (Si Alors, Si Alors Sinon, Cas).
• Les boucles (Tant que, Pour).
• Imbrication des structures.

Contrôler le flux d'exécution d'un programme pour qu'il réagisse aux données (conditions) et automatiser les tâches répétitives (boucles).

 

Organisation du Code

• Variables globales et locales.
• Notion de Fonction et Procédure.
• Passage de paramètres (par valeur, par référence).

Savoir structurer le code en blocs réutilisables (fonctions) pour améliorer la lisibilité et la modularité.

 

Structures de Données Simples

• Variables unitaires vs. structures de stockage.
• Introduction aux Tableaux/Listes (lecture, écriture, taille).

Utiliser un Tableau pour stocker et manipuler des collections de données du même type.

 

Cas Pratiques (Algorithmique & Python)

• Analyse de problèmes.
• Écriture d'algorithmes en pseudo-code.
• Déroulement manuel pour validation.
• Traduction progressive de l'algorithme en Python et exécution dans un REPL. (Algorithmes de filtrage, de recherche séquentielle, de tri simple).

Être capable d'écrire un algorithme complet en pseudo-code, de le dérouler, puis de réaliser une première traduction fonctionnelle en Python pour vérifier le résultat.

Installation et Environnement

• Installation de Python localement (Windows/Mac/Linux).
• Présentation des DevContainers.
• Découverte de l'interpréteur et de l'outil pip. Configuration de l'IDE.

Avoir un environnement de développement Python fonctionnel et savoir installer des outils externes.

 

Bases du Langage (Syntaxe)

• Syntaxe Python (indentation, commentaires).
• Les types de données fondamentaux, opérateurs.
• Gestion mémoire.

Comprendre les spécificités de Python (simplicité, typage dynamique) et écrire les premières lignes de code.

 

Structures de Données Natives (Part I)

• Listes (tableaux dynamiques), Tuples (immutables) : manipulation, slicing, méthodes courantes.

Choisir entre une Liste et un Tuple et savoir les manipuler efficacement pour stocker des séquences d'objets.

 

Structures de Données Natives (Part II)

• Chaînes de caractères (f-strings, méthodes). Dictionnaires (clé/valeur), Sets (ensembles uniques).

Utiliser les Dictionnaires pour une recherche rapide et les Sets pour la gestion d'éléments uniques.

 

Structures de Contrôle et Exceptions

• if/elif/else, for (avec range et itération sur collections), while. Gestion des exceptions (try/except/finally).

Gérer le flux d'exécution et sécuriser le code en gérant les erreurs potentielles de manière propre.

 

Fonctions et Modularité

• Définition (def), arguments positionnels et nommés.
• Portée des variables (locales/globales).
• Import de modules.

Créer des fonctions claires et réutilisables. Savoir importer et utiliser des modules Python standards.

 

Gestion des I/O (Entrées/Sorties)

• Entrée et sortie standard (input() et print()).
• Gestion des Fichiers : ouverture, lecture, écriture (méthode simple).

Interagir avec l'utilisateur via la console et savoir lire/écrire des données dans un fichier local.

 

Qualité de Code et Tests

• Normes PEP 8.
• Introduction au Type Hinting (typage statique).
• Premiers Tests Unitaires (unittest/pytest introduction).

Écrire du code respectant les standards de la communauté. Tester une fonctionnalité pour s'assurer qu'elle répond aux spécifications attendues.

 

Programmation Orientée Objet (Base)

• Classes et Objets.
• Le constructeur (__init__).
• Attributs et méthodes.
• Héritage simple et polymorphisme.

Structurer un programme autour de classes simples pour modéliser des entités du monde réel.

 

 

Partie A : Expertise en Analyse de Données (1,5 jour)

 

NumPy : Calculs Numériques

• Les Arrays (tableaux multidimensionnels).
• Calcul vectoriel et matriciel.
• Opérations performantes.

Utiliser NumPy pour effectuer des calculs lourds de manière optimisée et efficace.

 

Pandas : Manipulation de Données

• Les DataFrames (lecture CSV, Excel, JSON).
• Indexation et Slicing avancés.
• Nettoyage et préparation de données (valeurs manquantes, types).

Manipuler, nettoyer et transformer des jeux de données volumineux pour les préparer à l'analyse ou à la modélisation.

 

Agrégation et Jointures

• Regroupement de données (groupby).
• Jointures et fusions de DataFrames.
• Création de nouvelles colonnes.

Réaliser des analyses statistiques de base et fusionner différentes sources de données.

 

Visualisation

• Introduction aux librairies Matplotlib/Seaborn.
• Création des graphiques de base (histogrammes, nuages de points).

Savoir visualiser ses données pour une meilleure compréhension et communication des résultats.

 

Partie B : Fondations Avancées du Langage (1 jour)

 

Fonctions Avancées

• Decorateurs (création et usage), Fermeture (closure).
• Générateurs et Fonctions génératrices (yield pour l'optimisation mémoire).

Écrire du code plus compact, modulaire et optimisé en termes de mémoire (Générateurs).

 

Programmation Objet Avancée

• Propriétés (@property).
• Héritage multiple (MRO).
• Les méthodes DUNDER (__str__, __eq__, etc.).

Maîtriser les mécanismes avancés de l'OOP pour créer des classes puissantes et conformes aux conventions Python.

 

Context Managers

• Le protocole __enter__ et __exit__.
• Utilisation du mot-clé with.
• Création d'un Context Manager personnalisé.

Gérer correctement les ouvertures et fermetures de ressources (fichiers, connexions DB) de manière automatique et sécurisée.

 

Partie C : Industrialisation, Performance et Parallélisme (1,5 jour)

 

Gestion de Projet Avancée

• Poetry, PDM, Hatch : gestion des dépendances et packaging.
• Publication de librairies.

Mettre en place un projet robuste et facilement déployable.

 

Performance et Profiling

• Outils de Profiling (détection des goulots d'étranglement).
• Techniques d'optimisation de code.

Identifier les parties lentes du code et les optimiser pour améliorer la vitesse d'exécution.

 

Bases de Données et ORM

• Connexion à une base de données relationnelle via SQLAlchemy.
• Introduction aux bases de données NoSQL (ex: MongoDB).

Interagir avec des bases de données de manière orientée objet sans écrire directement de SQL complexe.

 

Concurrence et Asynchrone

• Multithreading vs. Multiprocessing.
• Programmation asynchrone avec Asyncio (async/await) : gestion des I/O non bloquantes.

Améliorer la réactivité et le débit des applications en gérant plusieurs tâches "simultanément".

 

Développement Web / API (Intro)

• Introduction au développement d'API avec FastAPI.
• Définition de routes simples.
• Sérialisation des données.

Exposer des fonctionnalités Python (y compris des résultats d'analyse de données) sous forme d'API web moderne.