
# Fichier: python_cheats/cheatsheets/virtualenv.txt
# Cheatsheet Environnements Virtuels Python - Guide Complet


[OK] VENV (MÉTHODE STANDARD - Python 3.3+)

# Créer un environnement virtuel
python -m venv myenv
python3 -m venv myenv
python3.11 -m venv myenv        # Version spécifique

# Créer avec nom personnalisé
python -m venv .venv            # Convention commune
python -m venv env
python -m venv venv

# Options de création
python -m venv myenv --without-pip              # Sans pip
python -m venv myenv --system-site-packages     # Hérite packages système
python -m venv myenv --clear                    # Nettoie dossier existant
python -m venv myenv --upgrade                  # Met à jour venv existant
python -m venv myenv --upgrade-deps             # Met à jour pip/setuptools
python -m venv myenv --prompt="MyProject"       # Nom personnalisé du prompt

# Créer avec Python spécifique
/usr/bin/python3.9 -m venv myenv
C:\Python311\python.exe -m venv myenv

[OK] ACTIVATION & DÉSACTIVATION

# === LINUX / MAC ===

# Activation (bash/zsh)
source myenv/bin/activate
. myenv/bin/activate            # Équivalent

# Activation (fish shell)
source myenv/bin/activate.fish

# Activation (csh/tcsh)
source myenv/bin/activate.csh

# === WINDOWS ===

# Activation (CMD)
myenv\Scripts\activate.bat
myenv\Scripts\activate          # Marche aussi

# Activation (PowerShell)
myenv\Scripts\Activate.ps1
.\myenv\Scripts\Activate.ps1    # Avec chemin relatif

# Activation (Git Bash sur Windows)
source myenv/Scripts/activate

# === DÉSACTIVATION (tous OS) ===
deactivate

[OK] VÉRIFICATION & INFORMATIONS

# Vérifier quel Python est utilisé
which python                    # Linux/Mac
which python3
where python                    # Windows
Get-Command python              # PowerShell

# Vérifier version Python
python --version
python -V

# Vérifier pip
which pip                       # Linux/Mac
where pip                       # Windows
pip --version

# Vérifier si environnement est actif
echo $VIRTUAL_ENV               # Linux/Mac (affiche chemin si actif)
echo %VIRTUAL_ENV%              # Windows CMD
$env:VIRTUAL_ENV                # PowerShell

# Lister packages installés
pip list
pip list --format=columns
pip list --format=json

# Voir où sont installés les packages
pip show package_name
python -m site                  # Tous les chemins

# Vérifier intégrité environnement
pip check

[OK] GESTION DES PACKAGES

# Installer package
pip install package_name

# Installer plusieurs packages
pip install package1 package2 package3

# Installer version spécifique
pip install package==1.2.3
pip install "package>=1.0.0,<2.0.0"
pip install package~=1.2.0      # Version compatible (1.2.x)

# Installer depuis requirements.txt
pip install -r requirements.txt
pip install -r requirements/dev.txt

# Installer en mode éditable (développement)
pip install -e .
pip install -e ./src/mypackage

# Mettre à jour package
pip install --upgrade package_name
pip install -U package_name

# Mettre à jour pip lui-même
pip install --upgrade pip
python -m pip install --upgrade pip

# Désinstaller
pip uninstall package_name
pip uninstall package_name -y   # Sans confirmation
pip uninstall -r requirements.txt

[OK] REQUIREMENTS.TXT

# Générer requirements.txt
pip freeze > requirements.txt

# Générer sans packages editables
pip freeze --exclude-editable > requirements.txt

# Générer seulement packages user
pip freeze --user > requirements.txt

# Générer avec pipreqs (uniquement imports utilisés)
pip install pipreqs
pipreqs . --force

# === Structure requirements.txt ===

# requirements.txt (production)
django==4.2.0
requests>=2.28.0,<3.0.0
celery[redis]>=5.3.0
psycopg2-binary~=2.9.0

# requirements-dev.txt (développement)
-r requirements.txt             # Include requirements.txt

pytest>=7.4.0
black>=23.0.0
flake8>=6.0.0
mypy>=1.0.0
ipython>=8.0.0

# requirements-test.txt (tests)
-r requirements.txt
pytest>=7.4.0
pytest-cov>=4.1.0
pytest-mock>=3.11.0
faker>=19.0.0

# requirements-docs.txt (documentation)
-r requirements.txt
sphinx>=7.0.0
sphinx-rtd-theme>=1.3.0

# Installer tous les requirements
pip install -r requirements.txt
pip install -r requirements-dev.txt

[OK] VIRTUALENV (OUTIL TIERS)

# Installer virtualenv
pip install virtualenv

# Créer environnement
virtualenv myenv

# Créer avec Python spécifique
virtualenv -p python3.11 myenv
virtualenv -p /usr/bin/python3.9 myenv
virtualenv --python=python3.11 myenv

# Options
virtualenv myenv --no-pip                   # Sans pip
virtualenv myenv --system-site-packages     # Hérite packages système
virtualenv myenv --clear                    # Nettoie existant
virtualenv myenv --always-copy              # Copie au lieu de symlinks

# Activation/désactivation (même que venv)
source myenv/bin/activate       # Linux/Mac
myenv\Scripts\activate          # Windows

[OK] VIRTUALENVWRAPPER (LINUX/MAC)

# Installer
pip install virtualenvwrapper

# Configuration dans ~/.bashrc ou ~/.zshrc
export WORKON_HOME=$HOME/.virtualenvs
export PROJECT_HOME=$HOME/projects
source /usr/local/bin/virtualenvwrapper.sh

# Ou trouver le script
# Ubuntu/Debian: /usr/local/bin/virtualenvwrapper.sh
# Mac (Homebrew): /usr/local/bin/virtualenvwrapper.sh

# Recharger config
source ~/.bashrc
source ~/.zshrc

# === Commandes ===

# Créer environnement
mkvirtualenv myenv
mkvirtualenv myenv -p python3.11    # Avec Python spécifique

# Lister environnements
lsvirtualenv
lsvirtualenv -b                     # Affichage bref

# Activer environnement
workon myenv

# Désactiver
deactivate

# Supprimer environnement
rmvirtualenv myenv

# Copier environnement
cpvirtualenv oldenv newenv

# Lier environnement à dossier projet
mkproject myproject                 # Crée env et dossier
setvirtualenvproject               # Lie env existant à dossier
cdproject                          # Va au dossier projet

# Afficher info environnement
showvirtualenv myenv

# Hooks personnalisés
# ~/.virtualenvs/postmkvirtualenv
# ~/.virtualenvs/postactivate
# ~/.virtualenvs/predeactivate

[OK] VIRTUALENVWRAPPER-WIN (WINDOWS)

# Installer
pip install virtualenvwrapper-win

# Variables d'environnement (optionnel)
# WORKON_HOME: où stocker les environnements (défaut: %USERPROFILE%\Envs)

# Commandes (mêmes que Linux)
mkvirtualenv myenv
workon myenv
deactivate
rmvirtualenv myenv
lsvirtualenv

[OK] PIPENV (MODERNE & RECOMMANDÉ)

# Installer pipenv
pip install pipenv

# Créer environnement et Pipfile
pipenv install

# Installer package
pipenv install requests
pipenv install django==4.2.0

# Installer package de développement
pipenv install --dev pytest
pipenv install --dev black flake8 mypy

# Installer depuis requirements.txt
pipenv install -r requirements.txt

# Installer toutes les dépendances depuis Pipfile
pipenv install
pipenv install --dev                # Include dev dependencies

# Activer shell de l'environnement
pipenv shell

# Exécuter commande sans activer shell
pipenv run python script.py
pipenv run python manage.py runserver
pipenv run pytest

# Vérifier vulnérabilités de sécurité
pipenv check

# Mettre à jour packages
pipenv update
pipenv update package_name

# Désinstaller
pipenv uninstall package_name

# Supprimer environnement
pipenv --rm

# Localiser environnement
pipenv --venv

# Localiser projet
pipenv --where

# Générer requirements.txt depuis Pipfile.lock
pipenv requirements > requirements.txt
pipenv requirements --dev > requirements-dev.txt

# Fichiers générés
# Pipfile - Dépendances (lisible)
# Pipfile.lock - Versions exactes (lock file)

# === Structure Pipfile ===
[[source]]
url = "https://pypi.org/simple"
verify_ssl = true
name = "pypi"

[packages]
django = ">=4.2,<5.0"
requests = "*"

[dev-packages]
pytest = "*"
black = "*"

[requires]
python_version = "3.11"

# Options utiles
pipenv --python 3.11                # Spécifier version Python
pipenv --site-packages              # Accès packages système
pipenv install --ignore-pipfile     # Installer depuis Pipfile.lock
pipenv lock                         # Regénérer Pipfile.lock

[OK] POETRY (MODERNE & PROFESSIONNEL)

# Installer poetry
curl -sSL https://install.python-poetry.org | python3 -
pip install poetry                  # Alternative (moins recommandé)

# Vérifier installation
poetry --version

# Créer nouveau projet
poetry new myproject
poetry new myproject --name mypackage    # Nom personnalisé

# Structure créée:
# myproject/
#   myproject/
#     __init__.py
#   tests/
#     __init__.py
#   pyproject.toml
#   README.md

# Initialiser projet existant
poetry init                         # Mode interactif
poetry init --no-interaction        # Mode automatique

# Ajouter dépendance
poetry add requests
poetry add django@^4.2              # Version spécifique
poetry add "django>=4.2,<5.0"

# Ajouter dépendance de développement
poetry add --group dev pytest
poetry add --group dev black flake8 mypy

# Installer toutes les dépendances
poetry install
poetry install --no-dev             # Sans dev dependencies
poetry install --only dev           # Seulement dev

# Mettre à jour dépendances
poetry update
poetry update requests              # Package spécifique

# Supprimer dépendance
poetry remove requests

# Exécuter commande
poetry run python script.py
poetry run pytest
poetry run black .

# Activer shell
poetry shell

# Désactiver shell
exit

# Informations environnement
poetry env info
poetry env list

# Utiliser Python spécifique
poetry env use python3.11
poetry env use /usr/bin/python3.9

# Supprimer environnement
poetry env remove python3.11

# Afficher dépendances
poetry show
poetry show --tree                  # Vue arborescente
poetry show --outdated              # Packages obsolètes

# Exporter requirements.txt
poetry export -f requirements.txt --output requirements.txt
poetry export -f requirements.txt --output requirements.txt --without-hashes
poetry export --with dev -f requirements.txt --output requirements-dev.txt

# Build package
poetry build

# Publier sur PyPI
poetry publish
poetry publish --build              # Build et publish

# Configuration
poetry config --list
poetry config virtualenvs.in-project true    # .venv dans projet
poetry config virtualenvs.path ~/.poetry-envs

# === Structure pyproject.toml ===
[tool.poetry]
name = "myproject"
version = "0.1.0"
description = ""
authors = ["Your Name <you@example.com>"]

[tool.poetry.dependencies]
python = "^3.11"
django = "^4.2"
requests = "^2.28"

[tool.poetry.group.dev.dependencies]
pytest = "^7.4"
black = "^23.0"

[build-system]
requires = ["poetry-core"]
build-backend = "poetry.core.masonry.api"

[OK] CONDA (DATA SCIENCE)

# Installer Miniconda ou Anaconda
# https://docs.conda.io/en/latest/miniconda.html

# Créer environnement
conda create -n myenv
conda create -n myenv python=3.11
conda create -n myenv python=3.11 numpy pandas

# Créer depuis fichier
conda env create -f environment.yml

# Activer environnement
conda activate myenv

# Désactiver environnement
conda deactivate

# Lister environnements
conda env list
conda info --envs

# Supprimer environnement
conda env remove -n myenv
conda remove --name myenv --all

# Installer packages
conda install numpy
conda install numpy pandas matplotlib
conda install numpy=1.24

# Installer depuis conda-forge
conda install -c conda-forge package_name

# Installer avec pip dans conda env
conda install pip
pip install package_name

# Mettre à jour packages
conda update numpy
conda update --all

# Lister packages
conda list
conda list -n myenv

# Rechercher package
conda search numpy

# Exporter environnement
conda env export > environment.yml
conda env export --no-builds > environment.yml
conda list --export > requirements.txt

# === Structure environment.yml ===
name: myenv
channels:
  - defaults
  - conda-forge
dependencies:
  - python=3.11
  - numpy>=1.24
  - pandas>=2.0
  - matplotlib
  - pip
  - pip:
    - requests
    - django

# Cloner environnement
conda create --name newenv --clone oldenv

# Nettoyer cache
conda clean --all

[OK] PDM (MODERNE)

# Installer PDM
pip install pdm

# Initialiser projet
pdm init

# Ajouter dépendance
pdm add requests
pdm add --dev pytest

# Installer dépendances
pdm install

# Exécuter script
pdm run python script.py

# Utiliser Python spécifique
pdm use python3.11

[OK] COMPARAISON DES OUTILS

# venv
# [OK] Standard (Python 3.3+)
# [OK] Pas d'installation requise
# [OK] Simple et léger
# [X] Pas de gestion avancée des dépendances

# virtualenv
# [OK] Compatible anciennes versions Python
# [OK] Plus d'options que venv
# [X] Nécessite installation
# [X] Remplacé par venv pour Python 3.3+

# virtualenvwrapper
# [OK] Commandes pratiques
# [OK] Organisation centralisée
# [OK] Hooks personnalisables
# [X] Linux/Mac seulement (virtualenvwrapper-win pour Windows)

# pipenv
# [OK] Gestion moderne des dépendances
# [OK] Pipfile.lock pour reproductibilité
# [OK] Sécurité (pipenv check)
# [X] Plus lent que pip
# [X] Parfois problématique avec résolution dépendances

# poetry
# [OK] Outil professionnel complet
# [OK] Build et publish packages
# [OK] Gestion dépendances excellente
# [OK] pyproject.toml (standard moderne)
# [X] Courbe d'apprentissage
# [X] Installation séparée

# conda
# [OK] Excellent pour data science
# [OK] Gère dépendances non-Python
# [OK] Packages optimisés scientifiques
# [X] Plus lourd
# [X] Peut conflictuer avec pip

[OK] STRUCTURE PROJET RECOMMANDÉE

# Structure avec venv
myproject/
├── .venv/                  # Environnement virtuel
├── src/
│   └── mypackage/
│       ├── __init__.py
│       └── module.py
├── tests/
│   └── test_module.py
├── docs/
├── .gitignore
├── README.md
├── requirements.txt
├── requirements-dev.txt
└── setup.py

# Structure avec poetry
myproject/
├── mypackage/
│   ├── __init__.py
│   └── module.py
├── tests/
│   └── test_module.py
├── docs/
├── .gitignore
├── README.md
└── pyproject.toml


[OK] .GITIGNORE POUR PYTHON


# .gitignore
# Environnements virtuels
venv/
env/
.venv/
ENV/
env.bak/
venv.bak/
myenv/

# Python
__pycache__/
*.py[cod]
*$py.class
*.so
.Python
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
*.egg-info/
.installed.cfg
*.egg

# PyCharm
.idea/

# VSCode
.vscode/

# Jupyter
.ipynb_checkpoints

# pytest
.pytest_cache/
.coverage
htmlcov/

# mypy
.mypy_cache/

# Environnements spécifiques
.env
.env.local


[OK] BONNES PRATIQUES


# 1. Un environnement par projet
# [OK] Isole les dépendances
# [OK] Évite les conflits
# [X] Ne jamais installer dans environnement système

# 2. Nommer l'environnement
# Convention: .venv, venv, env
# Avec virtualenvwrapper: nom du projet

# 3. Activer avant de travailler
source .venv/bin/activate       # TOUJOURS activer!

# 4. Versionner requirements.txt
git add requirements.txt
# Ne PAS versionner venv/ lui-même

# 5. Pin versions en production
django==4.2.0                   # Production
django>=4.2,<5.0                # Développement

# 6. Séparer requirements
requirements/
├── base.txt                    # Commun
├── dev.txt                     # Développement
├── prod.txt                    # Production
└── test.txt                    # Tests

# 7. Utiliser requirements-dev.txt
-r requirements.txt
pytest>=7.4.0
black>=23.0.0

# 8. Documenter versions Python
# README.md
Python 3.11+ requis

# pyproject.toml
[tool.poetry.dependencies]
python = "^3.11"

# 9. Automatiser avec Makefile
# Makefile
.PHONY: install dev test

install:
	python -m venv .venv
	.venv/bin/pip install -r requirements.txt

dev:
	.venv/bin/pip install -r requirements-dev.txt

test:
	.venv/bin/pytest

# 10. CI/CD
# GitHub Actions: setup-python action gère venv
# GitLab CI: cache pip


[OK] DÉPANNAGE


# === PROBLÈME: Permission denied (Windows PowerShell) ===
# Solution: Autoriser scripts
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

# Ou exécuter PowerShell en admin et:
Set-ExecutionPolicy RemoteSigned

# === PROBLÈME: Module venv introuvable ===
# Ubuntu/Debian
sudo apt-get install python3-venv
sudo apt-get install python3.11-venv

# Fedora/RHEL
sudo dnf install python3-venv

# === PROBLÈME: Environnement corrompu ===
# Supprimer et recréer
rm -rf venv
python -m venv venv
source venv/bin/activate
pip install -r requirements.txt

# === PROBLÈME: pip pas dans PATH ===
# Utiliser python -m pip
python -m pip install package_name

# === PROBLÈME: Mauvais Python activé ===
# Vérifier
which python
python --version

# Désactiver et réactiver
deactivate
source venv/bin/activate

# === PROBLÈME: Packages système dans venv ===
# Recréer sans --system-site-packages
rm -rf venv
python -m venv venv

# === PROBLÈME: Espace disque insuffisant ===
# Nettoyer cache pip
pip cache purge

# Conda
conda clean --all

# === PROBLÈME: Conflits de dépendances ===
# Avec pip
pip install --upgrade pip
pip check

# Avec pipenv
pipenv lock --clear
pipenv install

# Avec poetry
poetry update
poetry lock --no-update

# === PROBLÈME: ImportError malgré package installé ===
# Vérifier environnement actif
echo $VIRTUAL_ENV

# Vérifier où pip installe
pip show package_name

# Réinstaller
pip uninstall package_name
pip install package_name


[OK] SCRIPTS UTILES


# Activer automatiquement venv en entrant dans dossier
# Ajouter à ~/.bashrc ou ~/.zshrc

# Auto-activate venv
function cd() {
    builtin cd "$@"
    if [[ -d ".venv" ]] ; then
        source .venv/bin/activate
    fi
}

# Créer environnement complet (Bash)
#!/bin/bash
python -m venv .venv
source .venv/bin/activate
pip install --upgrade pip
pip install -r requirements.txt
pip install -r requirements-dev.txt
echo "Environnement créé et activé!"

# Créer environnement complet (PowerShell)
# setup-env.ps1
python -m venv .venv
.\.venv\Scripts\Activate.ps1
python -m pip install --upgrade pip
pip install -r requirements.txt
pip install -r requirements-dev.txt
Write-Host "Environnement créé et activé!"

# Mettre à jour tous les packages (Bash)
#!/bin/bash
pip list --outdated --format=json | \
python -c "import json, sys; \
print('\n'.join([x['name'] for x in json.load(sys.stdin)]))" | \
xargs -n1 pip install -U


[OK] WORKFLOWS COURANTS


# === Nouveau projet ===
# 1. Créer dossier
mkdir myproject && cd myproject

# 2. Créer venv
python -m venv .venv

# 3. Activer
source .venv/bin/activate  # Linux/Mac
.venv\Scripts\activate     # Windows

# 4. Mettre à jour pip
pip install --upgrade pip

# 5. Installer dépendances
pip install django requests

# 6. Freeze requirements
pip freeze > requirements.txt

# 7. Git
git init
echo ".venv/" >> .gitignore
git add .
git commit -m "Initial commit"

# === Cloner projet existant ===
# 1. Cloner
git clone repo_url
cd repo_name

# 2. Créer venv
python -m venv .venv

# 3. Activer
source .venv/bin/activate

# 4. Installer requirements
pip install -r requirements.txt

# === Avec poetry (nouveau projet) ===
poetry new myproject
cd myproject
poetry add django requests
poetry add --group dev pytest black
poetry install
poetry shell

# === Avec poetry (projet existant) ===
git clone repo_url
cd repo_name
poetry install
poetry shell


[OK] RESSOURCES


# Documentation officielle:
# venv: https://docs.python.org/3/library/venv.html
# virtualenv: https://virtualenv.pypa.io/
# pipenv: https://pipenv.pypa.io/
# poetry: https://python-poetry.org/
# conda: https://docs.conda.io/

# Guides:
# Real Python - Virtual Environments
# https://realpython.com/python-virtual-environments-a-primer/

# Outils:
# pyenv - Gestion versions Python
# https://github.com/pyenv/pyenv