Installation de Python et gestion des environnements virtuels

Introduction

Bienvenue dans ce cours d'apprentissage du développement avancé avec Python ! Avant de plonger dans des concepts complexes et de construire des applications robustes, il est fondamental de maîtriser les bases de l'installation de Python et, surtout, de comprendre et de gérer les environnements virtuels. Une configuration propre et bien organisée est la pierre angulaire d'un développement efficace et sans frustration.

Dans cette leçon, nous allons vous guider à travers les différentes étapes pour installer Python sur votre système d'exploitation. Plus important encore, nous allons explorer en profondeur le concept des environnements virtuels. Vous découvrirez pourquoi ils sont indispensables, comment les créer et les gérer, et comment ils vous protégeront des problèmes courants liés aux dépendances de projets.

Préparez-vous à poser les fondations solides de votre parcours de développeur Python !

1. Installation de Python

Python est un langage de programmation interprété, ce qui signifie que pour l'exécuter, vous devez d'abord installer l'interpréteur Python sur votre machine.

1.1 Choisir la bonne version de Python

Historiquement, il y a eu deux branches majeures de Python : Python 2 et Python 3.

Python 2 n'est plus maintenu et ne doit plus être utilisé pour de nouveaux projets.
Python 3 est la version actuelle et activement développée.

Pour le développement moderne, il est impératif d'utiliser Python 3. Nous recommandons de choisir la dernière version stable disponible (par exemple, Python 3.9, 3.10, 3.11 ou 3.12 au moment de la rédaction). Chaque nouvelle version apporte des améliorations de performance, des corrections de bugs et de nouvelles fonctionnalités.

1.2 Installation sur Windows

L'installation de Python sur Windows est généralement simple grâce à l'installeur officiel.

Télécharger l'installeur : Rendez-vous sur le site officiel de Python : python.org/downloads/. Téléchargez l'installeur Windows installer (64-bit recommandé).
Lancer l'installeur : Double-cliquez sur le fichier .exe téléchargé.
Attention à l'option PATH : Dans la première fenêtre de l'installeur, cochez impérativement la case "Add Python.exe to PATH". C'est crucial pour pouvoir exécuter Python et pip (le gestionnaire de paquets) depuis n'importe quel dossier de votre terminal.
Installation personnalisée (recommandé pour les débutants) : Cliquez sur "Install Now" pour une installation par défaut, ou "Customize installation" si vous souhaitez choisir le chemin d'installation ou les composants. Pour la plupart des utilisateurs, "Install Now" est suffisant après avoir coché la case PATH.
Finaliser l'installation : Suivez les instructions jusqu'à la fin.

1.3 Installation sur macOS

macOS est livré avec une version pré-installée de Python (souvent Python 2.x ou une version plus ancienne de Python 3). Il est fortement recommandé d'installer une version plus récente et de la gérer avec un gestionnaire de paquets comme Homebrew.

Installer Homebrew (si ce n'est pas déjà fait) : Homebrew est un gestionnaire de paquets indispensable pour macOS. Ouvrez votre terminal et exécutez la commande suivante :
```
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
```
Suivez les instructions à l'écran.
Installer Python avec Homebrew : Une fois Homebrew installé, vous pouvez installer la dernière version de Python 3 en utilisant :
```
brew install python
```
Homebrew gérera les dépendances et s'assurera que Python est bien configuré sur votre système.

1.4 Installation sur Linux

La plupart des distributions Linux sont livrées avec Python pré-installé. Cependant, il est souvent préférable d'installer une version plus récente ou de s'assurer d'avoir la bonne version de Python 3.

Pour Debian/Ubuntu :

sudo apt update
sudo apt install python3 python3-pip

Pour Fedora/CentOS/RHEL :
```
sudo dnf install python3 python3-pip
# ou pour les anciennes versions de CentOS/RHEL
# sudo yum install python3 python3-pip
```
Ces commandes installeront la version par défaut de Python 3 de votre distribution ainsi que pip (le gestionnaire de paquets).

1.5 Vérification de l'installation

Après l'installation, ouvrez un terminal (Invite de commandes sur Windows, Terminal sur macOS/Linux) et vérifiez que Python et pip sont correctement installés et accessibles.

# Vérifier la version de Python
python3 --version
# Ou parfois seulement "python" si c'est la seule version installée et configurée dans le PATH
# python --version

# Vérifier la version de pip (le gestionnaire de paquets de Python)
pip3 --version
# Ou parfois seulement "pip"
# pip --version

Vous devriez voir un résultat similaire à Python 3.x.x et pip 2x.x.x from .... Si vous rencontrez des erreurs comme "command not found", il se peut que Python n'ait pas été ajouté à votre PATH correctement (re-exécutez l'installeur Windows en cochant l'option PATH, ou vérifiez votre configuration Homebrew/Linux).

2. Comprendre les Environnements Virtuels

Une fois Python installé, le réflexe suivant doit être la gestion des environnements virtuels. C'est une pratique cruciale pour le développement Python avancé et professionnel.

2.1 Pourquoi les environnements virtuels ?

Imaginez que vous travaillez sur deux projets Python différents :

Projet A a besoin de la version 1.0 de la bibliothèque requests.
Projet B a besoin de la version 2.0 de la bibliothèque requests (parce qu'il utilise une fonctionnalité plus récente ou que des changements de rupture dans la v2.0 affectent la v1.0).

Si vous installez requests globalement sur votre système, vous ne pouvez avoir qu'une seule version à la fois. Si vous installez la v1.0 pour le Projet A, puis la v2.0 pour le Projet B, la v1.0 sera écrasée, et le Projet A risque de ne plus fonctionner ! C'est ce que l'on appelle "l'enfer des dépendances" (dependency hell).

Les environnements virtuels résolvent ce problème en :

Isolant les dépendances : Chaque environnement virtuel est un répertoire indépendant qui contient sa propre copie de l'interpréteur Python et de ses propres paquets site-packages. Cela signifie que les paquets installés dans un environnement ne sont pas disponibles dans d'autres environnements ou dans l'installation globale de Python.
Rendant les projets reproductibles : Vous pouvez facilement spécifier et partager les dépendances exactes de votre projet, permettant à d'autres développeurs de recréer l'environnement de développement exact.
Maintenant l'environnement global propre : Votre installation Python globale reste propre, sans être encombrée par des paquets spécifiques à un projet.

2.2 `venv` (Module intégré de Python)

Depuis Python 3.3, le module venv est intégré à la bibliothèque standard de Python. C'est l'outil recommandé pour créer et gérer des environnements virtuels pour la plupart des cas d'utilisation. Il est simple à utiliser et ne nécessite aucune installation supplémentaire.

2.3 Création d'un environnement virtuel avec `venv`

Pour créer un environnement virtuel pour votre projet, naviguez d'abord dans le répertoire racine de votre projet (là où se trouve votre code source).

Naviguer vers le répertoire du projet :
```
cd mon_super_projet/
```
(Si vous n'avez pas encore de répertoire de projet, créez-en un avec mkdir mon_super_projet puis cd mon_super_projet).
Créer l'environnement virtuel : Utilisez la commande suivante :
```
python3 -m venv nom_environnement
```
- python3 : Invoque l'interpréteur Python 3.
- -m venv : Indique à Python d'exécuter le module venv.
- nom_environnement : C'est le nom du répertoire qui contiendra votre environnement virtuel. Par convention, on utilise souvent venv, .venv, ou env.
Par exemple :
```
python3 -m venv .venv
```
Cette commande va créer un nouveau dossier nommé .venv (ou le nom que vous avez choisi) dans votre répertoire de projet. Ce dossier contient une copie de l'interpréteur Python, un répertoire Lib (Windows) ou lib (macOS/Linux) où les paquets seront installés, et des scripts d'activation.

2.4 Activation de l'environnement virtuel

La création de l'environnement ne suffit pas ; vous devez l'activer pour que votre terminal utilise l'interpréteur Python et les paquets de cet environnement spécifique.

Sur macOS et Linux (Bash/Zsh) :
```
source .venv/bin/activate
```
Sur Windows (Invite de commandes - CMD) :
```
.venv\Scripts\activate.cmd
```
Sur Windows (PowerShell) :
```
.\.venv\Scripts\Activate.ps1
```

Une fois activé, vous verrez généralement le nom de votre environnement virtuel apparaître entre parenthèses au début de votre invite de commande (par exemple, (.venv) user@machine:~/mon_super_projet$). Cela indique que vous travaillez désormais dans cet environnement isolé.

2.5 Utilisation de `pip` dans un environnement virtuel

Une fois votre environnement virtuel activé, toutes les commandes pip que vous exécuterez installeront les paquets uniquement dans cet environnement, et non globalement.

Installation de paquets :
```
# Exemple : installer la bibliothèque "requests"
pip install requests
```
Vous verrez pip télécharger et installer le paquet directement dans le répertoire site-packages de votre environnement virtuel.
Enregistrer les dépendances du projet (requirements.txt) : C'est une étape cruciale pour la reproductibilité de votre projet. Une fois que vous avez installé tous les paquets nécessaires à votre projet, vous pouvez générer un fichier requirements.txt qui liste toutes les dépendances exactes (nom et version).
```
pip freeze > requirements.txt
```
Cette commande va créer un fichier requirements.txt dans votre répertoire de projet, contenant des lignes comme :
```
requests==2.31.0
certifi==2023.7.22
charset-normalizer==3.2.0
idna==3.4
urllib3==2.0.4
```

Installer les dépendances d'un projet existant : Si vous clonez un projet Python existant qui a un fichier requirements.txt, vous pouvez facilement installer toutes ses dépendances dans un nouvel environnement virtuel :

# Créer et activer l'environnement (si pas déjà fait)
python3 -m venv .venv
source .venv/bin/activate # ou l'équivalent Windows

# Installer toutes les dépendances listées dans requirements.txt
pip install -r requirements.txt

Ce bloc de code récapitule les étapes clés de la gestion des environnements virtuels avec venv et pip :

# Assurez-vous d'être dans le répertoire racine de votre projet.
# Si le répertoire .venv existe déjà, vous pouvez le supprimer
# pour repartir de zéro :
# rm -rf .venv  # macOS/Linux
# rmdir /s /q .venv # Windows CMD (attention, supprime sans confirmation)
# Remove-Item -Recurse -Force .venv # Windows PowerShell

# 1. Création de l'environnement virtuel (nommé .venv par convention)
python3 -m venv .venv

# 2. Activation de l'environnement virtuel :

# Pour macOS/Linux (Bash, Zsh)
source .venv/bin/activate

# Pour Windows (Invite de commandes - CMD)
.venv\Scripts\activate.cmd

# Pour Windows (PowerShell)
.\.venv\Scripts\Activate.ps1

# (Une fois activé, votre invite de commande affichera (.venv) ou similaire)

# 3. Installation d'un paquet (exemple: requests)
pip install requests

# 4. Enregistrement des dépendances dans un fichier requirements.txt
pip freeze > requirements.txt

# 5. Si vous avez un fichier requirements.txt et souhaitez installer les dépendances
# Assurez-vous d'être dans l'environnement activé
# pip install -r requirements.txt

# 6. Exécuter un script Python dans cet environnement
# python votre_script.py

# 7. Désactivation de l'environnement virtuel
deactivate

Explication du code : Ces commandes illustrent le cycle de vie typique d'un environnement virtuel. Vous commencez par le créer, puis l'activez pour isoler votre travail. pip install ajoute des bibliothèques spécifiques à ce projet. pip freeze > requirements.txt est essentiel pour documenter ces dépendances, rendant votre projet portable et reproductible. Enfin, deactivate vous permet de quitter l'environnement isolé.

2.6 Désactivation et suppression d'un environnement virtuel

Désactiver : Pour quitter un environnement virtuel activé, utilisez simplement la commande :
```
deactivate
```
Votre invite de commande reviendra à la normale, et vous utiliserez à nouveau l'interpréteur Python global (ou celui de votre PATH système).
Supprimer : Un environnement virtuel n'est qu'un répertoire. Pour le supprimer, il suffit de supprimer le dossier que vous avez créé (par exemple, .venv).
- Sur macOS/Linux :
```
rm -rf .venv
```
- Sur Windows (CMD) :
```
rmdir /s /q .venv
```
- Sur Windows (PowerShell) :
```
Remove-Item -Recurse -Force .venv
```
Assurez-vous que l'environnement n'est pas activé avant de tenter de le supprimer.

3. Gestion avancée (Optionnel mais utile)

Pour des projets plus complexes ou pour gérer plusieurs versions de Python sur une même machine, des outils additionnels peuvent s'avérer très utiles.

3.1 `pyenv` (Gestionnaire de versions Python)

pyenv est un excellent outil pour gérer plusieurs versions de Python sur le même système. Plutôt que d'installer Python directement via Homebrew ou les gestionnaires de paquets Linux, pyenv vous permet d'installer diverses versions (3.8, 3.9, 3.10, etc.) et de basculer facilement entre elles, soit globalement, soit par répertoire de projet.

Utilité : Indispensable si vous travaillez sur des projets nécessitant des versions de Python différentes (par exemple, un ancien projet qui tourne sur Python 3.8 et un nouveau qui utilise Python 3.11).
pyenv ne remplace pas venv ; ils sont complémentaires. pyenv gère les versions de l'interpréteur Python, tandis que venv gère les dépendances de paquets pour une version spécifique de Python.

3.2 `Poetry` ou `Pipenv` (Gestionnaires de dépendances et d'environnements)

Alors que venv et pip sont les outils de base, Poetry et Pipenv sont des outils plus avancés qui combinent la gestion des environnements virtuels et la gestion des dépendances dans une interface plus moderne et cohérente.

Poetry : Gère la création d'environnements virtuels, l'installation de dépendances, la résolution de conflits de dépendances, et même la publication de paquets. Il utilise un fichier pyproject.toml pour définir le projet et ses dépendances, avec un fichier poetry.lock pour verrouiller les versions exactes.
Pipenv : Similaire à Poetry, il vise à remplacer pip et venv pour un workflow plus intégré. Il utilise un Pipfile et un Pipfile.lock pour gérer les dépendances.
Quand les utiliser : Pour des projets plus importants, des bibliothèques à publier, ou lorsque vous souhaitez une gestion de dépendances plus stricte et des builds reproductibles avec des fichiers de verrouillage. Pour débuter, venv et pip sont suffisants, mais ces outils valent la peine d'être explorés pour le développement avancé.

Conclusion

Félicitations ! Vous avez maintenant les connaissances nécessaires pour installer Python sur votre système et, plus important encore, pour maîtriser l'utilisation des environnements virtuels.

Points clés à retenir :

Python 3 est la norme : Toujours privilégier Python 3 pour tout nouveau développement.
Les environnements virtuels sont indispensables : Ils résolvent le problème des conflits de dépendances en isolant les paquets spécifiques à chaque projet.
venv est votre ami : C'est l'outil intégré et recommandé pour la création et l'activation d'environnements virtuels.
pip gère les paquets : Utilisez pip install pour ajouter des bibliothèques dans votre environnement activé et pip freeze > requirements.txt pour enregistrer vos dépendances.
Reproductibilité : Le fichier requirements.txt est essentiel pour que d'autres puissent recréer l'environnement exact de votre projet.

Une bonne gestion de votre environnement de développement vous épargnera bien des maux de tête à mesure que vos projets deviendront plus complexes. C'est une compétence fondamentale pour tout développeur Python sérieux. Pratiquez ces étapes régulièrement, et elles deviendront rapidement une seconde nature dans votre workflow de développement.