Lernzettel: Maîtrise des environnements virtuels et gestion des dépendances

📋 Plan du Cours

1. Objectifs du cours Projets et Fichiers
2. Environnements virtuels venv et isolation
3. Activation venv et gestion des dépendances pip
4. Geler et partager les dépendances requirements.txt
5. Modules packages et import sans exécution parasite
6. Point d’entrée if name == main
7. Librairie standard Python indispensables
8. Gestion de fichiers avec open et with
9. Formats de données CSV et JSON
10. Sérialisation pickle et joblib pour objets

📖 1. Objectifs du cours Projets et Fichiers

🔑 Notions clés & Définitions

• Environnement virtuel venv : Un environnement virtuel est un dossier de projet qui isole Python et ses bibliothèques pour éviter les conflits entre dépendances.
• Modules et packages : Les modules et packages sont des unités de code organisées en plusieurs fichiers pour structurer un projet et favoriser la réutilisation.
• Librairie standard Python : La librairie standard regroupe les outils natifs fournis avec Python, utilisables sans installation externe supplémentaire.
• Gestion de fichiers : La gestion de fichiers regroupe les opérations pour lire et écrire des données sur le disque, par exemple en .txt, .csv ou .json.

📝 Points essentiels

• Le cours vise à passer de scripts jetables à une organisation de projet plus professionnelle.
• Les environnements virtuels servent à isoler les projets et à gérer leurs dépendances via des outils comme pip ou uv.
• La structuration en modules et packages permet de découper le code en fichiers propres et réutilisables.
• La librairie standard fournit des outils natifs à explorer avant d’aller chercher des bibliothèques externes.
• La gestion de fichiers couvre la lecture et l’écriture de données sur disque au format .txt, .csv et .json.
• Le problème “It works on my machine” vient d’installations globales qui peuvent casser un projet quand une version écrase une autre.

💡 Astuce mémo

venv = “projet = bulle” : chaque projet a sa propre copie de Python et de ses libs.

📖 2. Environnements virtuels venv et isolation

🔑 Notions clés & Définitions

• venv : Environnement virtuel Python créé pour isoler un projet et ses dépendances du système global.
• .venv : Dossier conventionnel où venv stocke l’environnement virtuel d’un projet, généralement nommé .venv.
• Activation d’un environnement : Action qui configure le terminal pour utiliser le Python et les outils de l’environnement virtuel courant.
• pip : Gestionnaire de paquets Python utilisé pour installer et mettre à jour des bibliothèques dans l’environnement virtuel.
• requirements.txt : Fichier texte listant les dépendances à installer, produit via pip freeze pour partager un environnement.

📝 Points essentiels

• Créer un environnement avec $python -m venv <nom> ou$ python -m venv .venv génère un dossier .venv/.
• Ne jamais écrire de code dans le dossier .venv et ne jamais le versionner, typiquement via .gitignore.
• Sur Mac/Linux, activer avec source .venv/bin/activate ; sur Windows Command Prompt avec .venv\Scripts\activate.bat ; sur PowerShell avec .venv\Scripts\Activate.ps1.
• Quand l’activation fonctionne, le nom de l’environnement apparaît entre parenthèses au début du terminal, par ex. (.venv).
• Dans l’environnement activé, installer des bibliothèques avec pip install, par ex. pip install numpy ou pip install pandas matplotlib.
• Pour partager les dépendances, figer la liste avec pip freeze > requirements.txt puis demander à l’autre d’exécuter pip install -r requirements.txt dans son environnement.

💡 Astuce mémo

Bulle isolée : crée (.venv) → active (terminal affiche (.venv)) → installe (pip) → gèle (pip freeze) → partage (pip install -r).

📖 3. Activation venv et gestion des dépendances pip

🔑 Notions clés & Définitions

• Environnement virtuel venv : Un environnement virtuel isole les dépendances d’un projet pour éviter les conflits avec les autres projets ou le Python système.
• pip : pip est l’outil standard de Python pour installer, mettre à jour et lister des paquets dans un environnement comme .venv.
• PyPI : PyPI est le dépôt central officiel où sont publiés la plupart des logiciels tiers Python installables via pip.
• pyproject.toml : pyproject.toml est un fichier de configuration moderne utilisé par des outils comme Poetry pour gérer les dépendances et leurs versions.
• requirements.txt : requirements.txt est un fichier listant des dépendances à installer, souvent utilisé avec pip pour des déploiements ou des contextes plus légers.

📝 Points essentiels

• Pour vérifier les paquets d’un environnement, on utilise pip list en pointant sur le Python de .venv (ex. rs\mon_projet.venv\Scripts\python.exe).
• pip install se connecte à PyPI pour télécharger le code (source ou binaire) puis l’installe dans le .venv actif.
• PyPI étant ouvert, une faute de frappe peut installer un paquet différent et potentiellement malveillant (ex. pandass au lieu de pandas).
• Poetry gère les conflits de versions via pyproject.toml, qui remplace l’usage historique de requirements.txt dans ce workflow.
• uv est un outil récent écrit en Rust qui remplace à la fois pip et venv et vise une exécution beaucoup plus rapide (annoncé 10 à 100 fois).
• pip n’est pas obsolète : il reste utile avec requirements.txt pour l’embarqué et pour des conteneurs (Docker, Podman) quand on veut rester léger.

💡 Astuce mémo

PyPI = “dépôt public” → faute de frappe = mauvais paquet ; venv = “bulle” → pip n’installe que dedans.

📖 4. Geler et partager les dépendances requirements.txt

🔑 Notions clés & Définitions

• Module Python : Un module Python est un fichier .py qui regroupe du code réutilisable comme des fonctions, classes et variables.
• Package Python : Un package Python est un dossier qui contient plusieurs modules pour organiser et structurer un projet.
• Librairie standard : La librairie standard regroupe des modules Python préinstallés, disponibles sans installation supplémentaire.
• Module tiers : Un module tiers est un module installé via pip, généralement depuis PyPI, pour ajouter des fonctionnalités externes.
• Module utilisateur : Un module utilisateur est un module créé par vous, sous forme de fichier .py dans votre projet.

📝 Points essentiels

• Un import en Python exécute le fichier importé et charge ses objets en mémoire, contrairement à l’idée d’un simple lien côté compilateur en Java.
• En Java, l’instruction import sert au compilateur à localiser une classe (ex : ArrayList) sans exécuter son code au moment de l’import.
• En Python, l’instruction import déclenche l’exécution du code du module importé jusqu’à la fin du fichier.
• Si geometrie.py contient un test avec print au niveau global, l’import dans main.py affichera ce test même si vous ne l’avez pas demandé.
• La garde name == "main" permet d’exécuter du code seulement quand le fichier est lancé directement, pas quand il est importé.

💡 Astuce mémo

Java : import = “je trouve”, Python : import = “j’exécute”.

📖 5. Modules packages et import sans exécution parasite

🔑 Notions clés & Définitions

• name : Variable système de Python qui indique le contexte d’exécution d’un fichier, notamment si le module est lancé directement ou importé.
• Bloc if name == "main" : Condition qui exécute un code seulement quand le fichier est lancé directement, pas quand il est importé par un autre module.
• Point d’entrée du programme : Fonction ou bloc appelé comme démarrage officiel du programme, typiquement protégé par la condition main.
• Package Python : Dossier contenant des modules importables, organisé pour regrouper du code sous un même espace de noms.
• init.py : Fichier placé dans un dossier pour que Python le considère comme un package importable (recommandé et requis avant Python 3.3).

📝 Points essentiels

• Si vous lancez un fichier directement avec python fichier.py, name vaut "main".
• Si un fichier est importé, name prend le nom du module (par exemple "geometrie").
• Le bloc if name == "main": sert à protéger le code de test pour qu’il ne s’exécute pas lors d’un import.
• En pratique, main.py contient souvent un bloc if name == "main": qui appelle une fonction main().
• Un package correspond à un dossier contenant des modules, importable via from package import module ou from package.module import fonction.
• Avant Python 3.3, init.py est nécessaire pour qu’un dossier soit reconnu comme package importable.

💡 Astuce mémo

name = "main" quand tu lances le fichier; sinon c’est le nom du module importé.

📖 6. Point d’entrée if name == main

🔑 Notions clés & Définitions

• Bloc if name == main : Un bloc conditionnel exécuté seulement quand le fichier Python est lancé directement, pas quand il est importé comme module.
• Module Python : Un fichier Python importable qui expose des fonctions ou données sans exécuter son code principal à l’import.
• Exécution directe : Le lancement d’un script depuis l’interpréteur, qui déclenche le code placé dans le bloc if name == main.
• Importation : L’utilisation d’un fichier Python via import, qui évite d’exécuter le code principal du script importé.

📝 Points essentiels

• Le bloc if name == main sert de point d’entrée pour regrouper le code “principal” d’un script.
• Quand un fichier est importé, le code du bloc if name == main n’est pas exécuté.
• Quand un fichier est exécuté directement, le code du bloc if name == main est exécuté.
• Cette séparation permet de réutiliser les fonctions d’un module sans déclencher automatiquement des traitements.
• Elle aide à structurer les projets avec des scripts (exécution) et des modules (réutilisation).

💡 Astuce mémo

Direct = main ; Import = silence : le code principal ne tourne que si tu lances le fichier.

📖 7. Librairie standard Python indispensables

🔑 Notions clés & Définitions

• Fonction open() : Fonction d’ouverture d’un fichier qui renvoie un objet fichier utilisable pour lire ou écrire selon le mode choisi.
• Context Manager with : Mécanisme Python qui garantit la fermeture automatique du fichier à la fin du bloc, même en cas d’erreur.
• Mode r : Mode de lecture qui ouvre un fichier existant pour le lire, sans le créer ni l’écraser.
• Mode w : Mode d’écriture qui crée le fichier s’il n’existe pas, ou écrase son contenu s’il existe.
• Mode a : Mode d’ajout qui écrit à la fin du fichier existant, sans supprimer son contenu.

📝 Points essentiels

• Le mode 'r' lit un fichier existant et plante si le fichier n’existe pas.
• Le mode 'w' crée le fichier s’il manque et écrase son contenu s’il existe.
• Le mode 'a' ajoute du contenu à la fin du fichier existant.
• La fermeture manuelle (open/close) peut échouer si une erreur survient avant close, laissant un verrou OS.
• En Python, le mot-clé with assure la fermeture automatique même en cas de plantage, contrairement à une fermeture non protégée.
• Pour lire un fichier : f.read() charge tout, f.readlines() renvoie une liste de lignes, et parcourir f est la méthode la plus économe en mémoire.

💡 Astuce mémo

with = fermeture garantie (même si ça plante) ; r=read (fichier doit exister), w=wipe (écrase), a=append (ajoute).

📖 8. Gestion de fichiers avec open et with

🔑 Notions clés & Définitions

• Instruction with open : Construction de gestion de fichiers qui ouvre un fichier et garantit sa fermeture automatique à la fin du bloc.
• Encodage utf-8 : Paramètre d’ouverture de fichier qui force l’interprétation des caractères selon UTF-8 pour éviter les caractères corrompus.
• Module csv : Module Python natif permettant de lire et écrire des fichiers CSV sous forme de lignes ou de structures dictionnaire.
• csv.reader : Lecteur CSV qui parcourt un fichier et renvoie chaque ligne sous forme de liste de champs.
• Module json : Module Python natif qui convertit des données entre objets Python et fichiers JSON.

📝 Points essentiels

• with open("nom", "r", encoding="utf-8") as f ferme automatiquement le fichier même en cas d’erreur dans le bloc.
• Sous Windows, forcer encoding="utf-8" évite le Mojibake quand le fichier contient des caractères accentués.
• write() n’ajoute pas de retour à la ligne automatiquement, donc il faut ajouter "\n" si on veut une ligne par ligne.
• csv.reader(f, delimiter=",") lit un CSV en renvoyant chaque ligne comme une liste, avec accès aux champs par index.
• next(lecteur) permet de sauter l’en-tête (ex. "Nom,Age,Ville") avant de traiter les lignes de données.
• json.dump(mon_dict, f, indent=4) écrit un dictionnaire Python dans un fichier JSON en le formatant avec indentation lisible.

💡 Astuce mémo

with = ouverture + fermeture automatique ; encoding="utf-8" = anti-Mojibake ; write() = pas de "\n" par défaut.

📖 9. Formats de données CSV et JSON

🔑 Notions clés & Définitions

• JSON : Format de données textuel basé sur des paires clé→valeur et des structures (listes, dictionnaires) facilement lisibles par un programme.
• Dictionnaire Python : Structure de données Python associant des clés à des valeurs, pratique pour manipuler directement le contenu chargé depuis un fichier JSON.
• Sérialisation : Technique de transformation d’objets en une représentation stockable, afin de les recharger plus tard dans le même programme.
• pickle : Module Python de sérialisation qui permet d’écrire et de restaurer des objets Python dans un fichier binaire.
• joblib : Bibliothèque Python optimisée pour sauvegarder et charger efficacement de gros objets de science des données, notamment des modèles et tableaux.

📝 Points essentiels

• Lecture JSON : un fichier JSON chargé via json.load renvoie un dictionnaire Python prêt à être parcouru et modifié.
• Accès JSON : on récupère une valeur avec la clé, par exemple donnees_recuperees["admis"], puis on peut utiliser une autre clé comme donnees_recuperees['nom'].
• pickle : l’écriture et la lecture se font en mode binaire, avec 'wb' pour dump et 'rb' pour load.
• pickle : la sérialisation peut concerner des objets variés (dictionnaires, classes, etc.), mais elle est décrite comme relativement lente pour de grosses matrices.
• joblib : la sauvegarde et le chargement sont présentés comme quasi instantanés pour des objets lourds (tableaux NumPy, modèles Scikit-Learn).
• Sécurité : ne jamais charger un fichier .pkl ou .joblib non fiable depuis Internet, car la désérialisation peut exécuter du code malveillant.

💡 Astuce mémo

JSON → dictionnaire prêt à l’emploi ; pickle = binaire généraliste ; joblib = rapide pour gros modèles ; sécurité : .pkl/.joblib non fiables = danger.

📖 10. Sérialisation pickle et joblib pour objets

🔑 Notions clés & Définitions

• Sérialisation : La sérialisation transforme un objet Python en une représentation stockable ou transmissible, puis permet de le reconstruire plus tard.
• pickle : pickle est un mécanisme de sérialisation Python capable de reconstruire des objets, y compris ceux dont la classe est définie ailleurs.
• joblib : joblib est une bibliothèque de sérialisation pensée pour stocker et recharger efficacement des objets, souvent utilisés en contexte de calcul.
• Désérialisation : La désérialisation reconstruit des objets à partir d’une représentation sérialisée, en exécutant potentiellement des opérations liées à l’objet.
• Environnement virtuel : Un environnement virtuel isole les bibliothèques d’un projet pour éviter de casser le système et garantir la cohérence des dépendances.

📝 Points essentiels

• La désérialisation de données non fiables peut exécuter du code malveillant sur la machine, donc il faut éviter de charger du pickle provenant de sources non sûres.
• pickle et joblib permettent de charger des objets, mais la reconstruction dépend des classes et bibliothèques disponibles au moment du chargement.
• Si un objet a été défini via des librairies externes, il faut utiliser les mêmes versions de ces librairies dans le nouvel environnement pour que le chargement fonctionne correctement.
• L’environnement virtuel (.venv) sert à isoler les dépendances afin de charger les bonnes versions sans impacter le reste du système.
• Le risque de sécurité et la compatibilité de versions sont deux raisons distinctes de ne pas désérialiser n’importe quoi, même si le fichier “semble” correct.

💡 Astuce mémo

Sécurité + compatibilité : pickle = “peut exécuter” et “dépend des versions” ; .venv = “mêmes libs, même comportement”.

📊 Tableaux de synthèse

Modes d’ouverture de fichiers

⚠️ Pièges & confusions fréquents

1. Oublier d’activer le venv avant pip install : tu installes alors globalement et tu retombes dans le problème “It works on my machine”.
2. Écrire ou versionner le dossier .venv : tu risques de polluer le projet et de casser la reproductibilité côté collègues.
3. Confondre import et exécution : en Python, import exécute le fichier importé jusqu’à la fin, donc les tests “print” parasites apparaissent sans name == "main".
4. Croire que with open(...) est optionnel : sans with, une erreur peut empêcher close() et laisser le fichier verrouillé par l’OS.
5. Lire un gros fichier avec f.read() : tu charges tout en mémoire, alors que l’itération (for ligne in f) est la méthode recommandée.
6. Écrire avec write() sans ajouter "\n" : tu n’obtiens pas une ligne par ligne comme attendu.
7. Charger un .pkl/.joblib non fiable depuis Internet : la désérialisation peut exécuter du code malveillant.

✅ Checklist Examen

1. Expliquer pourquoi un environnement virtuel venv évite le problème “It works on my machine” et isoler les dépendances par projet.
2. Donner la commande de création d’un venv (python -m venv .venv) et rappeler la convention de ne pas écrire ni versionner .venv (gitignore).
3. Donner les commandes d’activation selon OS (Mac/Linux, Windows Command Prompt, Windows PowerShell) et reconnaître le prompt avec (.venv).
4. Décrire le rôle de pip et le flux pip install vers PyPI, puis citer comment partager les dépendances via pip freeze > requirements.txt et pip install -r requirements.txt.
5. Vérifier l’isolation : expliquer comment contrôler quel Python est utilisé (which/where) et comment lister uniquement les paquets du venv (pip list).
6. Comparer les outils évoqués : pip/venv historiques, Poetry via pyproject.toml, et uv (remplace pip et venv, annoncé 10 à 100 fois plus rapide).
7. Définir module vs package, et classer les 3 types de modules (librairie standard, tiers via pip depuis PyPI, et vos propres modules).
8. Expliquer la différence Java vs Python pour import : en Python l’import exécute le fichier et charge ses objets en mémoire.
9. Identifier et appliquer le garde-fou if name == "main" pour empêcher l’exécution de code de test lors d’un import.
10. Décrire la structure d’un package avec init.py (recommandé et obligatoire avant Python 3.3) et donner un exemple d’import (from package import module).
11. Maîtriser open() : choisir r/w/a, utiliser encoding="utf-8", et appliquer la règle d’or d’utiliser presque toujours with pour garantir la fermeture.
12. Savoir lire/écrire : f.read() vs f.readlines() vs itération, write() sans retour à la ligne automatique, et lire CSV avec csv.reader + next(lecteur) pour l’en-tête.
13. Savoir manipuler JSON : json.dump pour écrire et json.load pour obtenir un dict prêt à l’emploi, puis accéder aux valeurs par clé.
14. Savoir sérialiser : pickle en binaire (wb/rb) et joblib pour objets lourds, avec la règle de sécurité sur fichiers non fiables et la compatibilité de versions en nouvel environnement.