python -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade pip setuptools wheel

py -m venv .venv
.venv\Scripts\Activate.ps1
python -m pip install --upgrade pip setuptools wheel

python -m pip freeze > requirements.before.txt
python -m pip list --outdated

python -m pip list --outdated --format=json

python -m pip list --outdated --format=freeze \
| cut -d= -f1 \ | xargs -n1 python -m pip install --upgrade ``` For production-oriented projects, prefer upgrading in smaller groups. Example: ```bash python -m pip install --upgrade requests urllib3 certifi python -m pip install --upgrade pandas numpy ``` Small batches reduce blast radius and make root-cause analysis faster when failures appear. ### 5. Reconcile source-controlled dependency files If your project tracks dependencies in `requirements.txt` or lock files, keep environment changes aligned with source control. For plain requirements flow: ```bash python -m pip freeze > requirements.txt git diff requirements.txt ``` For modern packaging flows with lock tooling, regenerate the lock file with the project standard command, then review version diffs in pull request. The key rule is consistency. Runtime environment, dependency files, and CI installation process must describe the same versions. ### 6. Validate compatibility after upgrade Successful installation does not guarantee a healthy application. Run dependency and application-level checks: ```bash python -m pip check pytest -q python -m pip list --outdated ``` `pip check` catches conflicting requirements among installed packages. Test execution catches behavior changes that dependency metadata cannot detect. For CLI or web apps, also run one quick smoke scenario to verify startup and basic functionality. ### 7. Rollback workflow for failed upgrades If tests fail after upgrade, restore previous package set using the snapshot file: ```bash python -m pip install --requirement requirements.before.txt ``` Then isolate offending packages by upgrading in smaller groups. This approach is usually faster than repeatedly recreating environments without a clear plan. ## Common Pitfalls * Upgrading packages in system Python and breaking OS-level tooling. * Using `pip` from a different interpreter than the active project interpreter. * Updating environment packages without updating tracked dependency files. * Running large upgrades without a pre-upgrade snapshot for rollback. * Treating install success as proof that runtime behavior is unchanged. ## Summary * Isolate upgrades in a virtual environment and use `python -m pip`. * Snapshot current versions before any mass update. * Upgrade in controlled batches for production-oriented projects. * Keep dependency files and runtime environment aligned. * Validate with `pip check`, tests, and quick smoke verification.