- À propos du fichier requirements.txt en Python
- Comprendre le rôle du fichier requirements.txt
- Créer manuellement un fichier requirements.txt
- Générer automatiquement requirements.txt avec pip freeze
- Installer les dépendances depuis requirements.txt
- Spécifier les versions des packages dans requirements.txt
- Mettre à jour et supprimer des dépendances
- Utiliser requirements.txt avec un environnement virtuel
- Partager et reconstruire un environnement Python
- À retenir !
1. À propos du fichier requirements.txt en Python
Un projet Python utilise souvent des bibliothèques externes installées avec pip. Par exemple, une application peut dépendre de requests, Django, Flask, NumPy ou d'autres packages disponibles sur PyPI. Pour qu'un projet puisse être installé facilement sur un autre ordinateur, il est nécessaire de conserver une liste de ses dépendances.
Le fichier requirements.txt est couramment utilisé pour enregistrer les packages nécessaires à un projet Python ainsi que, si nécessaire, leurs versions. Il peut ensuite être transmis avec le projet afin de permettre l'installation de ces dépendances avec une seule commande pip.
Le contenu suivant représente un exemple simple de fichier requirements.txt contenant trois dépendances avec des versions précises.
1 2 3 | requests==2.32.5 Flask==3.1.2 numpy==2.3.3 |
Sortie :
1 2 3 4 | Le fichier requirements.txt contient 3 dépendances : requests Flask numpy |
Le fichier requirements.txt est particulièrement utile lorsqu'un projet est associé à un environnement virtuel Python, car il permet de conserver une description reproductible des packages nécessaires au projet.
2. Comprendre le rôle du fichier requirements.txt
Le fichier requirements.txt ne contient généralement pas le code source du programme. Il contient des spécifications de dépendances que pip peut lire afin d'installer les packages nécessaires au fonctionnement du projet.
Supposons qu'un programme utilise la bibliothèque requests. Le code Python suivant nécessite que cette bibliothèque soit disponible dans l'environnement.
1 2 3 | import requests print(requests.__version__) |
Sortie possible :
1 | 2.32.5 |
Si le projet est transféré sur un autre ordinateur sur lequel requests n'est pas installé, le programme ne pourra pas importer cette bibliothèque. Nous pouvons donc déclarer cette dépendance dans requirements.txt.
1 | requests==2.32.5 |
Sortie :
1 | La dépendance requests version 2.32.5 est déclarée dans requirements.txt. |
Le principal intérêt du fichier requirements.txt est donc de faciliter l'installation, le partage et la reproduction de l'environnement nécessaire au projet.
3. Créer manuellement un fichier requirements.txt
Un fichier requirements.txt peut être créé manuellement avec un éditeur de texte tel que Visual Studio Code. Il suffit de créer à la racine du projet un fichier nommé exactement requirements.txt, puis d'ajouter les dépendances nécessaires, généralement une par ligne.
Pour un projet utilisant requests, Flask et NumPy, le fichier peut par exemple contenir les lignes suivantes.
1 2 3 | requests==2.32.5 Flask==3.1.2 numpy==2.3.3 |
Sortie :
1 2 3 4 | requirements.txt ├── requests==2.32.5 ├── Flask==3.1.2 └── numpy==2.3.3 |
Il est également possible d'utiliser Python lui-même pour créer ce fichier. La méthode write_text() de pathlib permet par exemple d'écrire les dépendances dans requirements.txt.
1 2 3 4 5 6 7 8 9 | from pathlib import Path contenu = """requests==2.32.5 Flask==3.1.2 numpy==2.3.3 """ Path("requirements.txt").write_text(contenu, encoding="utf-8") print("Fichier requirements.txt créé.") |
Sortie :
1 | Fichier requirements.txt créé. |
Cette seconde méthode peut être utile lorsqu'un programme Python doit générer automatiquement un fichier de dépendances à partir d'une configuration déterminée.
4. Générer automatiquement requirements.txt avec pip freeze
Lorsque plusieurs packages ont déjà été installés dans un environnement virtuel, il n'est pas nécessaire de saisir manuellement toutes les dépendances. La commande pip freeze affiche les packages installés avec leurs versions dans un format utilisable par pip.
La commande suivante affiche les packages actuellement installés dans l'environnement actif.
1 | python -m pip freeze |
Sortie possible :
1 2 3 4 5 | certifi==2025.8.3 charset-normalizer==3.4.3 idna==3.10 requests==2.32.5 urllib3==2.5.0 |
Pour enregistrer directement cette liste dans requirements.txt, nous pouvons utiliser la redirection > du terminal.
1 | python -m pip freeze > requirements.txt |
Sortie :
1 2 | Aucun texte n'est normalement affiché dans le terminal. Le fichier requirements.txt est créé ou remplacé. |
Nous pouvons ensuite afficher son contenu depuis le terminal sous Windows avec la commande suivante.
1 | type requirements.txt |
Sortie possible :
1 2 3 4 5 | certifi==2025.8.3 charset-normalizer==3.4.3 idna==3.10 requests==2.32.5 urllib3==2.5.0 |
La commande pip freeze enregistre les distributions installées visibles dans l'environnement concerné. Il est donc recommandé de l'utiliser dans un environnement virtuel propre au projet afin d'éviter d'inclure des packages sans rapport avec celui-ci.
5. Installer les dépendances depuis requirements.txt
L'un des principaux avantages du fichier requirements.txt est la possibilité d'installer toutes les dépendances déclarées avec une seule commande. L'option -r indique à pip qu'il doit lire les spécifications contenues dans un fichier.
La commande suivante installe toutes les dépendances déclarées dans requirements.txt.
1 | python -m pip install -r requirements.txt |
Sortie possible :
1 2 3 4 5 | Collecting requests==2.32.5 Collecting Flask==3.1.2 Collecting numpy==2.3.3 ... Successfully installed Flask-3.1.2 numpy-2.3.3 requests-2.32.5 |
Après l'installation, la commande pip list permet de vérifier les packages disponibles dans l'environnement.
1 | python -m pip list |
Sortie possible :
1 2 3 4 5 6 | Package Version ----------- ------- Flask 3.1.2 numpy 2.3.3 requests 2.32.5 ... |
Les points de suspension indiquent que d'autres packages peuvent également apparaître, notamment les dépendances transitives installées automatiquement par les packages principaux.
6. Spécifier les versions des packages dans requirements.txt
Un fichier requirements.txt peut utiliser différents opérateurs pour contrôler les versions acceptées. L'opérateur == impose une version précise, tandis que >=, <=, > et < permettent d'exprimer des contraintes de version.
Imposer une version précise
La ligne suivante demande exactement la version 2.32.5 de requests.
1 | requests==2.32.5 |
Sortie :
1 | Version demandée : requests 2.32.5 exactement |
Définir une version minimale
L'opérateur >= permet d'accepter la version indiquée ou une version plus récente compatible avec les autres contraintes du projet.
1 | requests>=2.32.0 |
Sortie :
1 | Version demandée : requests 2.32.0 ou supérieure |
Définir un intervalle de versions
Plusieurs contraintes peuvent être combinées avec une virgule. L'exemple suivant accepte requests à partir de la version 2.32.0 tout en excluant la future branche majeure 3.
1 | requests>=2.32.0,<3.0 |
Sortie :
1 | Version demandée : requests >= 2.32.0 et < 3.0 |
Le choix entre une version exacte et un intervalle dépend du niveau de reproductibilité et de flexibilité recherché pour le projet.
7. Mettre à jour et supprimer des dépendances
Le fichier requirements.txt doit évoluer lorsque les dépendances du projet changent. Si un nouveau package est installé dans l'environnement virtuel, nous pouvons régénérer le fichier avec pip freeze.
Supposons que nous ajoutions le package Flask au projet. La commande suivante l'installe dans l'environnement actif.
1 | python -m pip install Flask |
Sortie possible :
1 2 3 | Collecting Flask ... Successfully installed Flask-3.1.2 ... |
Après cette installation, nous pouvons actualiser requirements.txt en utilisant à nouveau pip freeze.
1 | python -m pip freeze > requirements.txt |
Sortie :
1 2 | Aucun texte n'est normalement affiché. requirements.txt est régénéré avec l'état actuel de l'environnement. |
Lorsqu'un package n'est plus nécessaire, il peut être désinstallé avec pip uninstall.
1 | python -m pip uninstall Flask |
Sortie possible :
1 2 3 | Found existing installation: Flask 3.1.2 Uninstalling Flask-3.1.2: Successfully uninstalled Flask-3.1.2 |
Nous pouvons ensuite régénérer requirements.txt pour qu'il reflète à nouveau les packages actuellement installés.
1 | python -m pip freeze > requirements.txt |
Sortie :
1 | requirements.txt est mis à jour avec les packages présents dans l'environnement. |
Il faut toutefois noter que la suppression d'un package principal ne supprime pas nécessairement toutes les dépendances qui avaient été installées avec lui. Une vérification du fichier généré reste donc utile.
8. Utiliser requirements.txt avec un environnement virtuel
L'association de requirements.txt et d'un environnement virtuel constitue une méthode courante pour isoler les dépendances d'un projet. Chaque projet peut ainsi utiliser ses propres packages et ses propres versions sans modifier directement les dépendances des autres projets.
La première étape consiste à créer un environnement virtuel nommé .venv avec le module venv.
1 | python -m venv .venv |
Sortie :
1 2 | Aucun message n'est généralement affiché. Le dossier .venv est créé dans le projet. |
Sous Windows avec l'invite de commandes CMD, l'environnement peut être activé avec le script activate.bat.
1 | .venv\Scripts\activate.bat |
Sortie possible :
1 | (.venv) C:\mon_projet> |
Sous Windows PowerShell, le script d'activation est Activate.ps1.
1 | .venv\Scripts\Activate.ps1 |
Sortie possible :
1 | (.venv) PS C:\mon_projet> |
Sous Linux et macOS, la commande source permet d'activer l'environnement virtuel.
1 | source .venv/bin/activate |
Sortie possible :
1 | (.venv) utilisateur@ordinateur:~/mon_projet$ |
Une fois l'environnement activé, nous pouvons installer les dépendances déclarées dans requirements.txt.
1 | python -m pip install -r requirements.txt |
Sortie possible :
1 2 3 4 | Collecting requests==2.32.5 Collecting Flask==3.1.2 ... Successfully installed Flask-3.1.2 requests-2.32.5 ... |
Les packages sont alors installés dans l'environnement virtuel du projet plutôt que d'être mélangés avec ceux d'un autre environnement Python.
9. Partager et reconstruire un environnement Python
Le fichier requirements.txt est particulièrement utile lorsqu'un projet doit être transféré vers un autre ordinateur, partagé avec un collaborateur ou déployé sur un serveur. Le dossier de l'environnement virtuel .venv n'a généralement pas besoin d'être partagé : il peut être recréé à partir de Python et du fichier de dépendances.
Sur le nouvel ordinateur, nous commençons par créer un nouvel environnement virtuel.
1 | python -m venv .venv |
Sortie :
1 | Le nouvel environnement virtuel .venv est créé. |
Après avoir activé cet environnement avec la commande adaptée au système, nous installons les dépendances déclarées dans requirements.txt.
1 | python -m pip install -r requirements.txt |
Sortie possible :
1 2 3 4 5 | Collecting requests==2.32.5 Collecting Flask==3.1.2 Collecting numpy==2.3.3 ... Successfully installed Flask-3.1.2 numpy-2.3.3 requests-2.32.5 ... |
Nous pouvons ensuite utiliser pip check pour demander à pip de vérifier si les packages installés possèdent des dépendances compatibles.
1 | python -m pip check |
Sortie possible :
1 | No broken requirements found. |
Cette méthode permet de reconstruire plus facilement l'environnement Python nécessaire au projet sans copier directement le dossier .venv d'un ordinateur à un autre.
10. À retenir !
Le fichier requirements.txt est un moyen simple et largement utilisé pour déclarer les dépendances d'un projet Python. Associé à pip et à un environnement virtuel, il facilite l'installation, le partage et la reproduction d'un environnement de développement.
- requirements.txt contient des spécifications de packages nécessaires au projet.
- Une dépendance peut être écrite sous la forme requests==2.32.5 pour imposer une version précise.
- Des opérateurs comme >= et < permettent de définir des contraintes de versions.
- python -m pip freeze affiche les distributions installées dans l'environnement.
- python -m pip freeze > requirements.txt permet de générer un fichier à partir de l'environnement actuel.
- python -m pip install -r requirements.txt installe les dépendances déclarées dans le fichier.
- Il est préférable de générer requirements.txt depuis l'environnement virtuel correspondant au projet.
- Le fichier doit être actualisé lorsque les dépendances du projet changent.
- Le dossier .venv n'a généralement pas besoin d'être transféré puisque l'environnement peut être recréé.
- python -m pip check permet de vérifier la cohérence des dépendances installées.
Le processus suivant résume les commandes essentielles permettant de créer un environnement virtuel, installer des packages et générer le fichier requirements.txt.
1 2 3 4 | python -m venv .venv .venv\Scripts\activate.bat python -m pip install requests Flask python -m pip freeze > requirements.txt |
Sortie possible :
1 2 3 4 5 6 7 8 9 10 11 12 13 | (.venv) C:\mon_projet>python -m pip freeze blinker==1.9.0 certifi==2025.8.3 charset-normalizer==3.4.3 click==8.3.0 Flask==3.1.2 idna==3.10 itsdangerous==2.2.0 Jinja2==3.1.6 MarkupSafe==3.0.3 requests==2.32.5 urllib3==2.5.0 Werkzeug==3.1.3 |
Sur un autre ordinateur, il suffit ensuite de créer et d'activer un nouvel environnement virtuel puis d'installer les dépendances à partir du fichier.
1 2 3 | python -m venv .venv .venv\Scripts\activate.bat python -m pip install -r requirements.txt |
Sortie possible :
1 2 3 4 5 | Collecting blinker==1.9.0 Collecting Flask==3.1.2 Collecting requests==2.32.5 ... Successfully installed blinker-1.9.0 Flask-3.1.2 requests-2.32.5 ... |
Auteur : Younes Derfoufi
Lieu de travail : CRMEF OUJDA
Site Web : www.tresfacile.net
Chaine YouTube : https://www.youtube.com/user/InformatiquesFacile
Me contacter : https://www.tresfacile.net/me-contacter/
