37 pip et l’écosystème Python

La force de Python, c’est son écosystème : plus de 500 000 packages disponibles sur le dépôt officiel PyPI (Python Package Index). Pour manipuler des images, analyser des données, faire du web, de l’IA… il existe presque toujours une bibliothèque toute prête. Ce chapitre vous explique comment les installer et les gérer proprement avec pip et les environnements virtuels.

37.1 Qu’est-ce qu’un package ?

Un package (ou bibliothèque) est un module (ou ensemble de modules) développé par la communauté Python, publié sur PyPI, et installable en une commande.

Quelques packages célèbres

Package	Domaine
`numpy`	Calcul numérique (matrices, vecteurs)
`pandas`	Analyse de données tabulaires
`matplotlib`, `seaborn`	Visualisation
`requests`	Requêtes HTTP
`flask`, `django`, `fastapi`	Serveurs web
`beautifulsoup4`	Parsing HTML
`pillow`	Manipulation d’images
`pytest`	Tests unitaires
`scikit-learn`, `tensorflow`, `pytorch`	Machine learning / IA

L’écosystème couvre quasiment tous les domaines de l’informatique.

37.2 `pip` — l’outil d’installation

pip (Pip Installs Packages) est le gestionnaire de paquets officiel de Python. Il est installé par défaut avec Python 3.

Vérifier `pip`

pip --version

Devrait afficher quelque chose comme pip 24.0 (python 3.10). Sur certains systèmes, la commande est pip3 (pour distinguer de la version Python 2).

Installer un package

pip install nom_du_package

Exemple :

pip install requests

Après installation, le package est importable dans Python :

import requests

r = requests.get("https://api.github.com")
print(r.status_code)

Installer une version spécifique

pip install requests==2.31.0        # version exacte
pip install "requests>=2.30"        # minimum
pip install "requests>=2.30,<3.0"   # plage

Mettre à jour / désinstaller

pip install --upgrade requests       # mettre à jour
pip uninstall requests               # désinstaller

Lister les packages installés

pip list                             # tous les packages installés
pip show requests                    # détails d'un package

Exemple de sortie de pip show requests :

Name: requests
Version: 2.31.0
Summary: Python HTTP for Humans.
Home-page: https://requests.readthedocs.io
Author: Kenneth Reitz
License: Apache 2.0
...

37.3 Les environnements virtuels

Le problème qu’ils résolvent

Imaginez que vous travaillez sur deux projets :

Projet A utilise django 4.2.
Projet B utilise django 5.0.

Si pip install installait tout globalement, les deux versions entreraient en conflit. L’environnement virtuel résout ce problème en isolant chaque projet.

Un environnement virtuel est un dossier isolé qui contient :

Sa propre copie de Python.
Ses propres packages installés.
Complètement séparé du Python système et des autres projets.

Créer un environnement virtuel : `venv`

Python fournit le module venv dans sa bibliothèque standard.

python -m venv mon_env

Cette commande crée un dossier mon_env/ contenant l’environnement.

Activer l’environnement

Sur Linux / macOS :

source mon_env/bin/activate

Sur Windows (PowerShell) :

mon_env\Scripts\Activate.ps1

Sur Windows (cmd.exe) :

mon_env\Scripts\activate.bat

Une fois activé, votre terminal affiche (mon_env) au début de la ligne. Toutes les commandes pip install installeront les packages dans cet environnement seulement.

Désactiver

deactivate

Vérifier qu’on est bien dans l’environnement

which python          # Linux/Mac
where python          # Windows

Le chemin devrait pointer vers mon_env/bin/python (ou mon_env/Scripts/python.exe).

Bonne pratique : un environnement par projet

Pour chaque nouveau projet Python, créez un nouvel environnement virtuel dans le dossier du projet. Convention fréquente : appeler le dossier .venv, venv ou env.

cd mon_projet/
python -m venv .venv
source .venv/bin/activate     # Linux/Mac
pip install -r requirements.txt

Ajoutez .venv/ à votre .gitignore — inutile de versionner l’environnement, on peut toujours le recréer.

37.4 `requirements.txt` — la liste des dépendances

Un fichier requirements.txt liste toutes les dépendances d’un projet. Il permet à n’importe qui de reconstruire votre environnement en une commande.

Générer `requirements.txt` à partir de l’existant

pip freeze > requirements.txt

Exemple de fichier généré :

certifi==2024.2.2
charset-normalizer==3.3.2
idna==3.6
requests==2.31.0
urllib3==2.2.1

Installer à partir d’un `requirements.txt`

pip install -r requirements.txt

Cette commande installe toutes les dépendances listées, avec leurs versions exactes. Essentiel pour :

Reproduire votre environnement sur une autre machine.
Déployer en production.
Collaborer avec d’autres développeurs.

Deux philosophies pour requirements.txt

Version stricte (versions exactes) :

requests==2.31.0
pandas==2.2.0

→ Reproductibilité parfaite, mais les mises à jour sont manuelles.

Version permissive (versions minimales) :

requests>=2.30
pandas>=2.0

→ Mise à jour automatique, mais potentiels conflits ou régressions.

En pratique, on utilise souvent la forme stricte pour les déploiements de production, et la forme permissive pour le développement.

37.5 Workflow type d’un nouveau projet

Voici le flux standard de création d’un projet Python :

# 1. Créer le dossier du projet
mkdir mon_projet && cd mon_projet

# 2. Créer l'environnement virtuel
python -m venv .venv

# 3. L'activer
source .venv/bin/activate       # Linux/Mac
# ou
.venv\Scripts\Activate.ps1      # Windows

# 4. Installer les packages nécessaires
pip install requests pandas matplotlib

# 5. Figer les versions
pip freeze > requirements.txt

# 6. Commit les fichiers importants (pas .venv/)
git init
echo ".venv/" > .gitignore
git add requirements.txt .gitignore

Quand quelqu’un clone votre projet, il fait :

git clone <url>
cd mon_projet
python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
# C'est prêt !

37.6 Outils modernes alternatifs à `pip + venv`

L’écosystème évolue. Voici les outils récents qui gagnent en popularité :

Outil	Rôle
`pipx`	Installer des outils CLI Python dans des envs isolés
`poetry`	Gestion de dépendances + packaging, remplace `pip`/`venv`/`setuptools`
`pdm`	Similaire à Poetry, plus léger
`uv`	Installateur ultra-rapide (écrit en Rust), drop-in replacement pour pip
`conda`	Gestionnaire alternatif, populaire en data science

Pour le niveau Avancé du TOSA, pip + venv est le combo à maîtriser. Les autres sont utilisés en entreprise mais ne sont pas au programme.

37.7 `init.py` et packages locaux

Pour organiser un projet en sous-modules, Python utilise des dossiers contenant un fichier __init__.py.

Exemple de structure :

mon_projet/
├── main.py
└── utils/
    ├── __init__.py
    ├── maths.py
    └── strings.py

Dans utils/maths.py :

def carre(x):
    return x ** 2

Dans main.py :

from utils.maths import carre

print(carre(5))

Le fichier __init__.py (souvent vide) signale à Python : « ce dossier est un package importable ». Depuis Python 3.3, il est techniquement optionnel pour les packages « namespace », mais incluez-le par clarté.

Que mettre dans `init.py` ?

Le plus souvent : rien. Parfois, on y expose certains noms du package pour faciliter les imports :

# utils/__init__.py
from .maths import carre
from .strings import nettoyer

Ainsi, l’utilisateur peut faire :

from utils import carre         # au lieu de from utils.maths import carre

37.8 `from . import` et imports relatifs

À l’intérieur d’un package, on peut faire des imports relatifs avec . :

# Dans utils/strings.py
from .maths import carre          # importe depuis le même package

Le . signifie « le package courant ». .. remonte d’un niveau.

Les imports relatifs ne fonctionnent pas dans un script principal

Si vous lancez python strings.py directement, from .maths import carre plante. Les imports relatifs ne fonctionnent que si le fichier est importé comme module d’un package, pas exécuté en script.

Pour les scripts principaux, utilisez des imports absolus :

# ✅ Dans un script qu'on lance directement
from utils.maths import carre

37.9 Où chercher des packages ?

Pour trouver des packages de qualité :

PyPI : https://pypi.org — le dépôt officiel avec recherche.
Awesome Python : https://github.com/vinta/awesome-python — liste curée par domaine.
GitHub : le code source de la plupart des packages est sur GitHub. Les stars donnent une idée de la popularité.

Critères pour choisir un package

Avant d’installer un package, vérifiez :

Dernière version récente ? (pas abandonnée)
Nombreux téléchargements ? (populaire = mature)
Documentation correcte ?
Licence compatible avec votre usage ?
Nombre d’issues ouvertes raisonnable ?

Un package avec 1000 étoiles et 3 contributeurs actifs est plus fiable qu’un package avec 50 étoiles dormant depuis 3 ans.

🧩 Quiz 8.1 — pip et l’écosystème

Question 1

Comment installer le package requests ?

python install requests
pip install requests
import requests
apt install python-requests

🔍 Réponse

b) pip install requests — pip est le gestionnaire de paquets officiel. apt install fonctionnerait aussi sur Linux pour le package système, mais c’est déconseillé (préférer pip dans un environnement virtuel).

Question 2

À quoi sert un environnement virtuel ?

À exécuter Python plus rapidement
À isoler les dépendances d’un projet
À chiffrer le code
À compiler Python

🔍 Réponse

b) — chaque projet a son propre environnement avec ses propres packages et versions, sans conflit avec d’autres projets.

Question 3

Quelle commande liste tous les packages installés ?

pip packages
pip list
pip show all
pip all

🔍 Réponse

b) pip list — pip show <nom> affiche les détails d’un package précis.

Question 4

Que fait pip freeze > requirements.txt ?

Bloque pip temporairement
Écrit la liste des packages installés (avec versions) dans le fichier
Supprime tous les packages
Met à jour pip

🔍 Réponse

b) — pip freeze affiche la liste des packages au format nom==version. Redirigée dans un fichier, elle permet de reproduire l’environnement ailleurs.

Question 5

Comment créer un environnement virtuel ?

pip env create
python -m venv mon_env
virtualenv new
python create env

🔍 Réponse

b) python -m venv mon_env — venv est un module inclus dans Python 3. virtualenv est un outil externe plus ancien, similaire mais qui doit être installé séparément.

Question 6

Que contient le fichier __init__.py ?

La fonction main du projet
La configuration de l’installateur
Il signale qu’un dossier est un package Python (souvent vide)
La documentation du package

🔍 Réponse

c) — c’est le marqueur d’un package. Il peut être vide ou contenir des imports. Depuis Python 3.3, il est optionnel pour les packages « namespace », mais il est recommandé de l’inclure.

Question 7

Vous voulez installer exactement la version 2.31.0 de requests. Quelle commande ?

pip install requests-2.31.0
pip install requests==2.31.0
pip install requests 2.31.0
pip install requests:2.31.0

🔍 Réponse

b) pip install requests==2.31.0 — le double == pour une version exacte. >=, <=, <, > pour des plages.

✏️ Exercice 8.1 — Créer un projet complet

Suivez ce mini-workflow pour créer un projet Python isolé.

Énoncé
Solution

Sur votre machine, dans un terminal :

Créez un dossier mon_projet et entrez dedans.
Créez un environnement virtuel .venv.
Activez-le.
Installez requests.
Créez un fichier main.py qui fait une requête HTTP vers https://api.github.com et affiche le statut.
Exécutez python main.py.
Générez requirements.txt avec pip freeze.
Désactivez l’environnement.

Sur Linux/Mac :

mkdir mon_projet && cd mon_projet
python -m venv .venv
source .venv/bin/activate
pip install requests

# Créer main.py
cat > main.py << 'EOF'
import requests

r = requests.get("https://api.github.com")
print(f"Statut : {r.status_code}")
print(f"Type de contenu : {r.headers.get('content-type')}")
EOF

python main.py
pip freeze > requirements.txt
cat requirements.txt

deactivate

Sur Windows (PowerShell) :

mkdir mon_projet
cd mon_projet
python -m venv .venv
.venv\Scripts\Activate.ps1
pip install requests

# Créer main.py avec Notepad ou votre éditeur
# Contenu : les mêmes lignes Python

python main.py
pip freeze > requirements.txt
type requirements.txt

deactivate

Ce que vous devriez observer :

requirements.txt liste requests et ses sous-dépendances (certifi, charset-normalizer, idna, urllib3…).
Le dossier .venv/ est plus volumineux que votre projet — c’est normal, il contient Python.
Après deactivate, tenter d’importer requests depuis un autre terminal échoue : l’isolation fonctionne.

✏️ Exercice 8.2 — Organiser un projet en package

Créez un petit package calculs avec cette structure :

mon_projet/
├── main.py
└── calculs/
    ├── __init__.py
    ├── geometrie.py
    └── statistiques.py

Énoncé
Solution

geometrie.py doit exposer aire_rectangle(l, w) et aire_cercle(r).
statistiques.py doit exposer moyenne(notes) et mediane(notes).
Le __init__.py doit permettre d’importer ces fonctions directement depuis calculs.
main.py doit utiliser ces fonctions.

calculs/geometrie.py :

"""Fonctions de calculs géométriques."""
from math import pi


def aire_rectangle(longueur, largeur):
    return longueur * largeur


def aire_cercle(rayon):
    return pi * rayon ** 2

calculs/statistiques.py :

"""Fonctions de statistiques."""


def moyenne(notes):
    if not notes:
        return 0
    return sum(notes) / len(notes)


def mediane(notes):
    if not notes:
        return None
    tri = sorted(notes)
    n = len(tri)
    if n % 2 == 1:
        return tri[n // 2]
    return (tri[n // 2 - 1] + tri[n // 2]) / 2

calculs/__init__.py :

"""Package calculs."""
from .geometrie import aire_rectangle, aire_cercle
from .statistiques import moyenne, mediane

__all__ = ["aire_rectangle", "aire_cercle", "moyenne", "mediane"]

main.py :

from calculs import aire_rectangle, aire_cercle, moyenne, mediane

# Géométrie
print(f"Aire 4×3 : {aire_rectangle(4, 3)}")
print(f"Aire disque r=5 : {aire_cercle(5):.2f}")

# Statistiques
notes = [12, 15, 9, 17, 11]
print(f"Moyenne : {moyenne(notes):.2f}")
print(f"Médiane : {mediane(notes)}")

Simulation de l’import (équivalent à ce qui se passerait) :

from math import pi

# Simule le contenu consolidé
def aire_rectangle(l, w):
    return l * w

def aire_cercle(r):
    return pi * r ** 2

def moyenne(notes):
    return sum(notes) / len(notes) if notes else 0

def mediane(notes):
    if not notes:
        return None
    tri = sorted(notes)
    n = len(tri)
    if n % 2 == 1:
        return tri[n // 2]
    return (tri[n // 2 - 1] + tri[n // 2]) / 2


# Tests
print(f"Aire 4x3 : {aire_rectangle(4, 3)}")
print(f"Aire disque : {aire_cercle(5):.2f}")

notes = [12, 15, 9, 17, 11]
print(f"Moyenne : {moyenne(notes):.2f}")
print(f"Médiane : {mediane(notes)}")

Aire 4x3 : 12
Aire disque : 78.54
Moyenne : 12.80
Médiane : 12

Notes

__all__ déclare les noms publics exportés — bonne pratique.
Les imports relatifs (.geometrie) fonctionnent uniquement dans le contexte du package.
main.py utilise des imports absolus (from calculs import ...).

✏️ Exercice 8.3 — `requirements.txt` partagé

Analysez le fichier requirements.txt suivant. À quoi servent les différents packages ? Quelle serait la commande pour tout installer ?

requests==2.31.0
pandas>=2.0
matplotlib
pytest>=7.0,<8.0

Énoncé
Solution

Expliquez chaque ligne.
Donnez la commande pour installer.
Expliquez la différence entre les quatre formes de spécification de version.

Signification :

requests==2.31.0 : HTTP en Python. Version exacte (2.31.0, pas autre).
pandas>=2.0 : analyse de données tabulaires. Version 2.0 ou plus.
matplotlib : visualisation/graphiques. N’importe quelle version (dernière disponible).
pytest>=7.0,<8.0 : tests unitaires. Entre 7.0 inclus et 8.0 exclu.

Installation :

pip install -r requirements.txt

Philosophies :

Spécification	Avantage	Inconvénient
Version exacte (`==`)	Reproductible	Pas de correctifs auto
Minimum (`>=`)	Auto-mise à jour	Peut casser avec des breaking changes
Sans contrainte	Toujours la plus récente	Très risqué
Plage (`>=X,<Y`)	Compromis équilibré	Plus complexe à maintenir

Recommandation : privilégier les plages majeures, comme pytest>=7.0,<8.0, qui accepte les correctifs sans risquer une montée de version majeure incompatible.

À retenir

Points clés du chapitre

PyPI (https://pypi.org) : 500 000+ packages Python disponibles.
pip install nom pour installer, pip uninstall pour supprimer.
venv crée un environnement virtuel isolé par projet.
Workflow : créer env → activer → pip install → pip freeze > requirements.txt.
pip install -r requirements.txt pour reproduire un environnement.
Versions : pkg==1.0 (exact), pkg>=1.0 (min), pkg>=1.0,<2.0 (plage).
Package local : dossier avec un __init__.py. Imports relatifs avec ..
.venv/ doit être dans .gitignore — on versionne requirements.txt à la place.

← Chapitre précédent : Fichiers • Chapitre suivant : Complexité →

37.1 Qu’est-ce qu’un package ?

Quelques packages célèbres

37.2 pip — l’outil d’installation

Vérifier pip

Installer un package

Installer une version spécifique

Mettre à jour / désinstaller

Lister les packages installés

37.3 Les environnements virtuels

Créer un environnement virtuel : venv

Activer l’environnement

Désactiver

Vérifier qu’on est bien dans l’environnement

37.4 requirements.txt — la liste des dépendances

Générer requirements.txt à partir de l’existant

Installer à partir d’un requirements.txt

37.5 Workflow type d’un nouveau projet

37.6 Outils modernes alternatifs à pip + venv

37.7 __init__.py et packages locaux

Que mettre dans __init__.py ?

37.8 from . import et imports relatifs

37.9 Où chercher des packages ?

Critères pour choisir un package

🧩 Quiz 8.1 — pip et l’écosystème

Question 1

Question 2

Question 3

Question 4

Question 5

Question 6

Question 7

✏️ Exercice 8.1 — Créer un projet complet

✏️ Exercice 8.2 — Organiser un projet en package

Notes

✏️ Exercice 8.3 — requirements.txt partagé

À retenir

37.2 `pip` — l’outil d’installation

Vérifier `pip`

Créer un environnement virtuel : `venv`

37.4 `requirements.txt` — la liste des dépendances

Générer `requirements.txt` à partir de l’existant

Installer à partir d’un `requirements.txt`

37.6 Outils modernes alternatifs à `pip + venv`

37.7 `init.py` et packages locaux

Que mettre dans `init.py` ?

37.8 `from . import` et imports relatifs

✏️ Exercice 8.3 — `requirements.txt` partagé