¿Cómo actualizar todas las bibliotecas instaladas en Python?

Cómo Actualizar Todas las Bibliotecas Instaladas en Python: Guía Completa 2026

Deja un comentario / Inteligencia Artificial / Por

📘 Este artículo forma parte de nuestra Guía Completa de Inteligencia Artificial 2026 y complementa a Problemas comunes al instalar librerías con pip. Si trabajas con Python, esas guías son tu punto de partida.

Introducción

Mantener las bibliotecas de Python actualizadas es una de las tareas más importantes —y a menudo más descuidadas— en cualquier proyecto. Las actualizaciones traen:

  • Parches de seguridad críticos.
  • Nuevas funcionalidades.
  • Mejoras de rendimiento.
  • Compatibilidad con nuevas versiones de Python.
  • Corrección de bugs.

Pero también pueden romper tu código si no se hacen con cuidado. En 2026, con la explosión de la IA y el machine learning, mantener actualizado tu entorno (PyTorch, TensorFlow, NumPy, Pandas…) es más importante que nunca.

En esta guía completa vas a aprender:

  • Por qué actualizar (y cuándo no).
  • Cómo listar todas las bibliotecas instaladas.
  • Métodos para actualizar (pip, pip-tools, poetry, uv).
  • Cómo actualizar solo el entorno virtual (sin romper el sistema).
  • Cómo actualizar con control (sin romper dependencias).
  • Herramientas modernas (uv, pipx, poetry).
  • Actualización selectiva vs masiva.
  • Cómo detectar conflictos antes de actualizar.
  • Rollback si algo se rompe.
  • Automatización con CI/CD.
  • FAQ con las preguntas más frecuentes.

Si estás empezando con Python, consulta Aprende a programar en Python desde cero. Para problemas de instalación, Problemas comunes al instalar librerías con pip.

Índice de contenidos

  1. Por qué actualizar (y cuándo no)
  2. Listar bibliotecas instaladas
  3. Método 1: pip (el estándar)
  4. Método 2: pip-upgrader
  5. Método 3: pip-tools (recomendado)
  6. Método 4: Poetry (proyectos)
  7. Método 5: uv (el más rápido)
  8. Actualización selectiva
  9. Detectar conflictos antes de actualizar
  10. Rollback si algo se rompe
  11. Automatización con CI/CD
  12. Buenas prácticas
  13. FAQ
  14. Conclusión

1. Por qué actualizar (y cuándo no)

1.1 Por qué actualizar

Seguridad:

  • Parches de CVEs críticos.
  • Vulnerabilidades conocidas.
  • Ataques a dependencias.

Funcionalidad:

  • Nuevas features.
  • Mejoras de API.
  • Compatibilidad con Python nuevo.

Rendimiento:

  • Optimizaciones internas.
  • Menos consumo de memoria.

Compatibilidad:

  • Con otras librerías.
  • Con versiones recientes de Python.

Datos:

  • +70% de las brechas explotan vulnerabilidades con parche disponible.
  • +50% de las librerías tienen actualizaciones de seguridad al año.

1.2 Cuándo NO actualizar

En producción:

  • Nunca directamente.
  • Primero staging.
  • Con tests.
  • Con backup.

En proyectos estables:

  • Si funciona, no lo toques (casi siempre).
  • Fija versiones con requirements.txt.
  • Solo actualiza por seguridad.

Antes de deadlines:

  • No actualizar en momentos críticos.
  • Esperar a tener tiempo para resolver problemas.

1.3 Riesgos de actualizar

  • Breaking changes en APIs.
  • Incompatibilidades entre librerías.
  • Deprecaciones de funciones.
  • Cambios de comportamiento.
  • Bugs nuevos.

1.4 Riesgos de NO actualizar

  • Vulnerabilidades explotables.
  • Incompatibilidad con nuevas versiones.
  • Falta de soporte.
  • Bugs conocidos.
  • Rendimiento subóptimo.

Regla: actualiza regularmente pero con cuidado.

2. Listar bibliotecas instaladas

2.1 pip list

pip list

Salida:

Package    Version
---------- -------
numpy      1.24.0
pandas     2.0.0
requests   2.31.0

Solo desactualizadas:

pip list --outdated

Salida:

Package    Version Latest  Type
---------- ------- ------- -----
numpy      1.24.0  1.26.4  wheel
pandas     2.0.0   2.2.0   wheel

2.2 pip freeze

pip freeze

Salida (formato requirements.txt):

numpy==1.24.0
pandas==2.0.0
requests==2.31.0

Útil para:

  • Backup del entorno.
  • Replicar en otro sistema.
  • Documentar versiones.
# Guardar
pip freeze > requirements_backup.txt

2.3 pip show

pip show numpy

Salida:

Name: numpy
Version: 1.24.0
Summary: Fundamental package for array computing in Python
Home-page: https://numpy.org
Author: Travis E. Oliphant et al.
License: BSD-3-Clause
Location: /usr/lib/python3/dist-packages
Requires: 
Required-by: pandas, scipy

Útil para:

  • Ver dependencias.
  • Ver quién requiere la librería.

2.4 Herramientas avanzadas

pipdeptree:

pip install pipdeptree
pipdeptree

Salida: árbol de dependencias.

Útil para: detectar conflictos.

# Ver qué requiere una librería
pipdeptree -p numpy

pip-check:

pip install pip-check
pip-check

Salida: lista de actualizaciones disponibles con colores.

3. Método 1: pip (el estándar)

3.1 Actualizar pip

Siempre primero:

python3 -m pip install --upgrade pip

O:

pip install --upgrade pip

3.2 Actualizar una librería

pip install --upgrade numpy

O:

pip install -U numpy

3.3 Actualizar todas las librerías (comando básico)

Comando clásico:

pip list --outdated --format=freeze | grep -v '^\-e' | cut -d = -f 1 | xargs -n1 pip install -U

Desglose:

  • pip list --outdated --format=freeze: lista solo desactualizadas.
  • grep -v '^\-e': excluye paquetes en modo editable.
  • cut -d = -f 1: extrae solo el nombre.
  • xargs -n1 pip install -U: actualiza uno a uno.

⚠️ Problemas:

  • No comprueba dependencias.
  • Puede romper cosas.
  • No hace rollback.

3.4 Versión más segura

Con output a archivo:

pip list --outdated --format=freeze | grep -v '^\-e' | cut -d = -f 1 > outdated.txt
cat outdated.txt

Revisar y luego:

xargs -n1 pip install -U < outdated.txt

3.5 Actualizar todo (Windows)

pip freeze > requirements.txt
pip install --upgrade -r requirements.txt

⚠️ Cuidado: esto reinstala lo mismo, no actualiza.

Comando correcto en Windows:

for /F "tokens=1" %i in ('pip list --outdated --format=freeze ^| findstr /V /R "^\-e"') do pip install -U %i

En PowerShell:

pip list --outdated --format=freeze | ForEach-Object { ($_ -split "==")[0] } | ForEach-Object { pip install -U $_ }

3.6 Versión mejorada con exclusiones

Excluir paquetes específicos:

pip list --outdated --format=freeze | grep -v '^\-e' | cut -d = -f 1 | grep -vE '^(torch|tensorflow|jax)$' | xargs -n1 pip install -U

Ejemplo: no actualizar torch/tensorflow (rompen compatibilidad).

4. Método 2: pip-upgrader

Herramienta interactiva que permite elegir qué actualizar.

4.1 Instalación

pip install pip-upgrader

4.2 Uso básico

pip-upgrade

Interfaz interactiva:

=== Outdated packages ===
[1] numpy      1.24.0 → 1.26.4
[2] pandas     2.0.0  → 2.2.0
[3] requests   2.31.0 → 2.32.0

Select packages to upgrade (e.g., 1 3, or 'all'):

4.3 Uso avanzado

Ver sin actualizar:

pip-upgrade --dry-run

Excluir paquetes:

pip-upgrade --skip-package torch --skip-package tensorflow

Con archivo requirements:

pip-upgrade requirements.txt

4.4 Ventajas y desventajas

Ventajas:

  • Interactivo.
  • Selectivo.
  • Seguro.

Desventajas:

  • No gestiona dependencias.
  • Menos popular que pip-tools.

5. Método 3: pip-tools (recomendado)

La mejor opción para proyectos serios.

5.1 Instalación

pip install pip-tools

5.2 Conceptos

pip-tools separa:

  • requirements.in: dependencias directas (lo que tú necesitas).
  • requirements.txt: dependencias resueltas con versiones fijas.

Ventaja: resolución de dependencias completa.

5.3 Uso básico

1. Crear requirements.in:

numpy
pandas
requests
scikit-learn

2. Compilar:

pip-compile requirements.in

Genera requirements.txt:

#
# This file is autogenerated by pip-compile with Python 3.12
# by the following command:
#
#    pip-compile requirements.in
#
numpy==1.26.4
    # via
    #   pandas
    #   scikit-learn
pandas==2.2.0
    # via -r requirements.in
requests==2.32.0
    # via -r requirements.in
scikit-learn==1.4.0
    # via -r requirements.in

3. Instalar:

pip-sync requirements.txt

5.4 Actualizar dependencias

pip-compile --upgrade requirements.in

Solo una librería:

pip-compile --upgrade-package numpy requirements.in

Solo librerías de seguridad:

pip-compile --upgrade-package numpy --upgrade-package requests requirements.in

5.5 Sincronizar entorno

pip-sync requirements.txt

Ventaja: el entorno queda exactamente como el requirements.txt.

⚠️ Cuidado: elimina paquetes no listados.

5.6 Dependencias de desarrollo

requirements-dev.in:

-r requirements.in
pytest
black
mypy

Compilar:

pip-compile requirements-dev.in

5.7 Ventajas y desventajas

Ventajas:

  • Resolución de dependencias.
  • Reproducibilidad.
  • Seguridad.
  • Fácil rollback.

Desventajas:

  • Más pasos.
  • Curva de aprendizaje.

Recomendación: el mejor método para proyectos serios.

Consulta Problemas comunes al instalar librerías con pip.

6. Método 4: Poetry (proyectos)

Gestión moderna de dependencias.

6.1 Instalación

curl -sSL https://install.python-poetry.org | python3 -

6.2 Crear proyecto

poetry new mi-proyecto
cd mi-proyecto

6.3 Añadir dependencias

poetry add numpy pandas requests

Añade a pyproject.toml:

[tool.poetry.dependencies]
python = "^3.12"
numpy = "^1.26"
pandas = "^2.2"
requests = "^2.32"

6.4 Actualizar dependencias

Ver qué se puede actualizar:

poetry show --outdated

Actualizar todo:

poetry update

Actualizar una librería:

poetry update numpy

Forzar actualización mayor:

poetry add numpy@latest

6.5 Instalar entorno

poetry install

Ventaja: crea entorno virtual automáticamente.

6.6 Ventajas y desventajas

Ventajas:

  • Gestión completa.
  • pyproject.toml estándar.
  • Entornos virtuales automáticos.
  • Lock file reproducible.

Desventajas:

  • Curva de aprendizaje.
  • Más lento que pip.
  • Menos flexible en algunos casos.

Recomendación: ideal para librerías y proyectos a largo plazo.

7. Método 5: uv (el más rápido)

El futuro de la gestión de dependencias Python. Creado por Astral (creadores de Ruff).

7.1 Instalación

curl -LsSf https://astral.sh/uv/install.sh | sh

O:

pip install uv

7.2 Por qué uv

  • 10-100x más rápido que pip.
  • Compatible con pip (requirements.txt).
  • Gestión de entornos virtuales.
  • Resolución de dependencias.
  • Lock files reproducibles.
  • Escrito en Rust.

7.3 Uso básico

Crear proyecto:

uv init mi-proyecto
cd mi-proyecto

Añadir dependencias:

uv add numpy pandas requests

Sincronizar entorno:

uv sync

Actualizar todo:

uv lock --upgrade
uv sync

Actualizar una librería:

uv lock --upgrade-package numpy
uv sync

7.4 Compatibilidad con pip

Reemplaza pip directamente:

uv pip install numpy
uv pip list
uv pip freeze

Usa el mismo requirements.txt:

uv pip install -r requirements.txt
uv pip compile requirements.in

7.5 Velocidad

Ejemplo real:

  • pip install numpy pandas scikit-learn: ~30 segundos.
  • uv pip install numpy pandas scikit-learn: ~2 segundos.

Ventaja: 15x más rápido.

7.6 Ventajas y desventajas

Ventajas:

  • Extremadamente rápido.
  • Compatible con pip.
  • Moderno.
  • Lock files.

Desventajas:

  • Menos maduro que pip.
  • Algunos paquetes con problemas.
  • Comunidad creciente.

Recomendación: uv es el futuro. Para proyectos nuevos, úsalo.

Consulta Lenguajes de programación para IA.

8. Actualización selectiva

No siempre hay que actualizar todo.

8.1 Estrategia por criticidad

Alta prioridad (actualizar siempre):

  • Seguridad: cryptography, requests, urllib3, pyyaml, jinja2.
  • Dependencias base: pip, setuptools, wheel.

Media prioridad (actualizar con tests):

  • Data science: numpy, pandas, matplotlib.
  • ML: scikit-learn, xgboost.

Baja prioridad (actualizar con cuidado):

  • Deep learning: torch, tensorflow (breaking changes frecuentes).
  • Frameworks: django, flask (cambios de API).

Nunca actualizar sin motivo:

  • Todo lo que funciona.

8.2 Estrategia por proyecto

Proyecto en producción:

# Solo parches de seguridad
pip list --outdated --format=json | jq -r '.[] | select(.latest_version | test("^[0-9]+\\.[0-9]+\\.[0-9]+$")) | .name' | xargs -n1 pip install -U

Proyecto en desarrollo:

# Todo, con tests
pip list --outdated --format=freeze | grep -v '^\-e' | cut -d = -f 1 | xargs -n1 pip install -U
pytest

Proyecto personal:

# Todo
pip-upgrade

8.3 Excluir paquetes problemáticos

Crea un archivo exclude.txt:

torch
tensorflow
tensorflow-gpu
jax
jaxlib

Script de actualización:

#!/bin/bash
pip list --outdated --format=freeze | \
    grep -v '^\-e' | \
    cut -d = -f 1 | \
    grep -vxF -f exclude.txt | \
    xargs -n1 pip install -U

8.4 Actualizar solo dependencias directas

Con pip-tools:

pip-compile --upgrade requirements.in

Esto actualiza solo lo que tú pediste, respetando dependencias transitivas.

8.5 Actualizar solo parches (semver)

Actualizar solo X.Y.Z (no X.Y):

# Script Python
import subprocess
import json

outdated = json.loads(
    subprocess.check_output(['pip', 'list', '--outdated', '--format=json'])
)

for pkg in outdated:
    current = pkg['version'].split('.')
    latest = pkg['latest_version'].split('.')
    
    # Solo si es mismo major.minor
    if current[0] == latest[0] and current[1] == latest[1]:
        subprocess.run(['pip', 'install', '--upgrade', pkg['name']])

Ventaja: solo actualiza parches (menor riesgo).

9. Detectar conflictos antes de actualizar

9.1 pip check

pip check

Salida si hay conflictos:

numpy 1.26.4 has requirement ... but you have ...

Ejecuta después de cada actualización.

9.2 pipdeptree

pipdeptree --warn silence

Detecta conflictos de dependencias.

Ejemplo:

pipdeptree --reverse --packages numpy

Muestra quién depende de numpy.

9.3 pip-review

Herramienta para actualización interactiva:

pip install pip-review
pip-review --interactive

Pregunta paquete por paquete.

9.4 Entorno de pruebas

Mejor práctica: probar actualización en entorno aislado.

# Crear entorno de prueba
python3 -m venv test-env
source test-env/bin/activate

# Instalar requirements
pip install -r requirements.txt

# Actualizar todo
pip list --outdated --format=freeze | grep -v '^\-e' | cut -d = -f 1 | xargs -n1 pip install -U

# Probar
pytest

# Si funciona, aplicar al entorno principal

9.5 Docker para pruebas

Aislar completamente:

FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
RUN pip list --outdated
CMD ["pytest"]
docker build -t mi-app-test .
docker run --rm mi-app-test

Consulta Qué es Docker.

10. Rollback si algo se rompe

10.1 Backup antes de actualizar

Guardar requirements actuales:

pip freeze > requirements_backup_$(date +%Y%m%d).txt

Guardar entorno virtual completo:

# Copiar entorno
cp -r venv venv_backup_$(date +%Y%m%d)

10.2 Restaurar desde backup

Reinstalar versiones anteriores:

pip install -r requirements_backup_20260101.txt

O desde el entorno copiado:

rm -rf venv
mv venv_backup_20260101 venv

10.3 Restaurar una librería específica

pip install numpy==1.24.0

Con pip-tools:

# Editar requirements.txt manualmente
# Cambiar numpy==1.26.4 → numpy==1.24.0
pip-sync requirements.txt

10.4 Poetry rollback

poetry install

Restaura desde poetry.lock.

10.5 uv rollback

uv sync --frozen

Usa el lock file anterior.

10.6 Git para código

Si el código también se rompe:

git status
git diff
git checkout -- archivo.py

Consulta Guía Completa de Linux.

11. Automatización con CI/CD

11.1 GitHub Actions

.github/workflows/update-deps.yml:

name: Update Dependencies

on:
  schedule:
    - cron: '0 0 * * 1'  <em># Lunes a medianoche</em>
  workflow_dispatch:

jobs:
  update:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.12'
      
      - name: Install pip-tools
        run: pip install pip-tools
      
      - name: Update requirements
        run: pip-compile --upgrade requirements.in
      
      - name: Run tests
        run: |
          pip-sync requirements.txt
          pytest
      
      - name: Create Pull Request
        uses: peter-evans/create-pull-request@v5
        with:
          title: 'chore: update dependencies'
          branch: update-deps

Ventaja: PR automático si los tests pasan.

11.2 Dependabot

.github/dependabot.yml:

version: 2
updates:
  - package-ecosystem: "pip"
    directory: "/"
    schedule:
      interval: "weekly"
    open-pull-requests-limit: 5
    groups:
      dev-dependencies:
        patterns:
          - "pytest*"
          - "black"
          - "mypy"

Ventaja: Dependabot gestiona todo.

11.3 Renovate

Alternativa open source a Dependabot.

renovate.json:

{
  "extends": ["config:base"],
  "packageRules": [
    {
      "matchUpdateTypes": ["minor", "patch"],
      "automerge": true
    },
    {
      "matchUpdateTypes": ["major"],
      "automerge": false
    }
  ]
}

11.4 Pre-commit hooks

.pre-commit-config.yaml:

repos:
  - repo: https://github.com/pycqa/pip-audit
    rev: v2.6.0
    hooks:
      - id: pip-audit

Ventaja: detecta vulnerabilidades antes de commit.

11.5 pip-audit

Auditoría de seguridad:

pip install pip-audit
pip-audit

Salida:

Found 2 known vulnerabilities in 1 package
Name   Version ID             Fix Versions
------ ------- -------------- ------------
urllib3 1.26.0  GHSA-xxxx-xxxx 1.26.5

Integración con CI:

- name: Security audit
  run: pip-audit --strict

Consulta Seguridad en CI/CD.

12. Buenas prácticas

12.1 Entorno virtual siempre

python3 -m venv venv
source venv/bin/activate

Nunca actualices el sistema con sudo pip install.

Consulta Cómo instalar JupyterLab en Ubuntu.

12.2 requirements.txt siempre

pip freeze > requirements.txt

O mejor: pip-tools, poetry, uv.

12.3 Prueba antes de producción

  1. Backup del entorno.
  2. Actualizar en entorno de prueba.
  3. Ejecutar tests.
  4. Verificar aplicación.
  5. Aplicar a producción.

12.4 Actualiza regularmente

Recomendación:

  • Mensualmente para proyectos activos.
  • Trimestralmente para proyectos estables.
  • Inmediatamente para CVEs críticos.

12.5 Documenta versiones

requirements.txt con comentarios:

# Web
flask==3.0.0
requests==2.32.0

# Data
numpy==1.26.4
pandas==2.2.0

12.6 Monitorea vulnerabilidades

Herramientas:

  • pip-audit.
  • Safety.
  • Dependabot.
  • Snyk.
pip install safety
safety check

12.7 No actualices todo a la vez

Si algo se rompe, no sabes qué fue.

Estrategia:

  1. Actualiza grupo a grupo.
  2. Test después de cada grupo.
  3. Commit entre grupos.

12.8 Usa lock files

Lock files fijan versiones exactas de todas las dependencias.

Herramientas:

  • pip-tools: requirements.txt.
  • Poetry: poetry.lock.
  • uv: uv.lock.

Ventaja: reproducibilidad total.

12.9 No rompas el sistema

⚠️ NUNCA:

sudo pip install --upgrade numpy  # ❌

✅ SÍ:

pip install --upgrade numpy  # ✅ (en venv)

12.10 Documenta breaking changes

Antes de actualizar:

# Ver changelog
pip show numpy | grep -i "home-page"
# Abrir y leer

Apunta cambios importantes.

13. FAQ

¿Cómo actualizo todas las librerías en Python?

Método rápido (cuidado):

pip list --outdated --format=freeze | grep -v '^\-e' | cut -d = -f 1 | xargs -n1 pip install -U

Método recomendado (seguro):

pip install pip-tools
pip-compile --upgrade requirements.in
pip-sync requirements.txt

¿Cómo veo qué librerías están desactualizadas?

pip list --outdated

Salida:

Package    Version Latest  Type
---------- ------- ------- -----
numpy      1.24.0  1.26.4  wheel

¿Puedo actualizar solo un paquete?

Sí:

pip install --upgrade numpy

Con pip-tools:

pip-compile --upgrade-package numpy requirements.in

¿Cómo actualizo pip?

python3 -m pip install --upgrade pip

Siempre antes de actualizar otros paquetes.

¿Qué es un entorno virtual?

Espacio aislado con sus propias librerías.

Crear:

python3 -m venv venv
source venv/bin/activate

Ventaja: no rompe el sistema.

¿Por qué usar entorno virtual?

Razones:

  • Aislamiento.
  • Diferentes versiones por proyecto.
  • No rompe el sistema.
  • Reproducibilidad.

¿Cómo actualizo solo paquetes de seguridad?

pip install pip-audit
pip-audit --fix

O:

safety check --fix

¿Qué es pip-tools?

Herramienta que resuelve dependencias y genera requirements.txt reproducible.

pip install pip-tools
pip-compile requirements.in
pip-sync requirements.txt

¿Qué es Poetry?

Gestor moderno de dependencias y entornos.

poetry add numpy
poetry update

¿Qué es uv?

Alternativa ultrarápida a pip, escrita en Rust.

uv pip install numpy
uv add numpy
uv sync

Ventaja: 10-100x más rápido.

¿Cómo hago rollback si algo se rompe?

Backup antes:

pip freeze > backup.txt

Rollback:

pip install -r backup.txt

¿Cómo detecto conflictos de dependencias?

pip check

O:

pipdeptree

¿Cómo actualizo en Windows?

PowerShell:

pip list --outdated --format=freeze | ForEach-Object { ($_ -split "==")[0] } | ForEach-Object { pip install -U $_ }

CMD:

for /F "tokens=1" %i in ('pip list --outdated --format=freeze ^| findstr /V /R "^\-e"') do pip install -U %i

¿Cómo actualizo en Linux?

Bash:

pip list --outdated --format=freeze | grep -v '^\-e' | cut -d = -f 1 | xargs -n1 pip install -U

¿Cómo actualizo en macOS?

Igual que Linux:

pip list --outdated --format=freeze | grep -v '^\-e' | cut -d = -f 1 | xargs -n1 pip install -U

¿Cómo actualizo solo lo que yo instalé?

pip-tools:

pip-compile --upgrade requirements.in

Esto actualiza solo dependencias directas.

¿Cómo evito actualizar paquetes problemáticos?

Excluir:

pip list --outdated --format=freeze | grep -v '^\-e' | cut -d = -f 1 | grep -vE '^(torch|tensorflow)$' | xargs -n1 pip install -U

¿Qué es un lock file?

Archivo con versiones exactas de todas las dependencias.

Herramientas:

  • pip-tools: requirements.txt.
  • Poetry: poetry.lock.
  • uv: uv.lock.

¿Cada cuánto actualizo?

Recomendación:

  • Mensual para proyectos activos.
  • Trimestral para estables.
  • Inmediato para CVEs críticos.

¿Debo actualizar todo a la vez?

No recomendado.

Mejor:

  1. Por grupos.
  2. Con tests.
  3. Con commits.

¿Qué pasa si actualizo y algo se rompe?

Rollback:

pip install -r backup.txt

Y documenta qué falló.

¿Cómo actualizo solo parches (no major)?

Con script Python:

import subprocess, json

outdated = json.loads(
    subprocess.check_output(['pip', 'list', '--outdated', '--format=json'])
)

for pkg in outdated:
    current = pkg['version'].split('.')
    latest = pkg['latest_version'].split('.')
    
    if current[0] == latest[0] and current[1] == latest[1]:
        subprocess.run(['pip', 'install', '--upgrade', pkg['name']])

¿Cómo automatizo las actualizaciones?

GitHub Actions:

- name: Update dependencies
  run: pip-compile --upgrade requirements.in

Dependabot: activado en el repo.

¿Qué es pip-audit?

Herramienta que detecta vulnerabilidades en dependencias.

pip install pip-audit
pip-audit

¿Qué es Safety?

Alternativa a pip-audit (freemium).

pip install safety
safety check

¿Cómo sé si una librería tiene CVEs?

pip-audit o Safety:

pip-audit
safety check

Consulta: https://nvd.nist.gov/

¿Qué es breaking change?

Cambio en una API que rompe código existente.

Ejemplo: numpy 2.0 eliminó funciones deprecadas en 1.x.

Solución: leer changelog antes de actualizar.

¿Cómo leo el changelog de una librería?

pip show numpy | grep Home-page
# Ir a la web

O en GitHub: CHANGELOG.md.

¿Qué es semver?

Semantic Versioning: MAJOR.MINOR.PATCH.

  • MAJOR: breaking changes.
  • MINOR: nuevas features (compatible).
  • PATCH: bug fixes.

Regla: ^1.2.3 = >=1.2.3, <2.0.0.

¿Qué es un requirements.txt?

Archivo que lista dependencias:

numpy==1.26.4
pandas==2.2.0
requests==2.32.0

Uso:

pip install -r requirements.txt

¿Cómo instalo requirements.txt?

pip install -r requirements.txt

Siempre en entorno virtual.

¿Qué diferencia hay entre pip y pip3?

  • pip: puede ser pip de Python 2 (raro).
  • pip3: siempre Python 3.

Recomendación: python3 -m pip para garantizar Python 3.

¿Cómo desinstalo una librería?

pip uninstall numpy

Sin confirmar:

pip uninstall -y numpy

¿Cómo actualizo una librería a una versión específica?

pip install numpy==1.24.0

O:

pip install "numpy>=1.24,<1.26"

¿Cómo veo la versión de una librería?

pip show numpy | grep Version

O en Python:

import numpy
print(numpy.__version__)

¿Qué es un conflicto de dependencias?

Dos librerías requieren versiones incompatibles de una tercera.

Ejemplo:

  • librería A requiere numpy<1.25.
  • librería B requiere numpy>=1.25.

Solución: actualizar librería A o usar versión compatible.

14. Conclusión

Actualizar las librerías de Python es una tarea esencial pero que debe hacerse con cuidado. Un entorno desactualizado es vulnerable, pero una actualización descontrolada puede romper tu proyecto.

Puntos clave:

  1. Siempre entorno virtual.
  2. Backup antes de actualizar.
  3. pip-tools es el método recomendado.
  4. Poetry para proyectos modernos.
  5. uv para velocidad máxima.
  6. pip-audit para seguridad.
  7. Tests después de actualizar.
  8. Rollback preparado siempre.
  9. Automatiza con CI/CD.
  10. Actualiza regularmente.

Recomendación paso a paso:

  1. Activa entorno virtual.
  2. Backup: pip freeze > backup.txt.
  3. Verifica: pip list --outdated.
  4. Actualiza pip.
  5. Actualiza con cuidado: pip-upgrade o pip-tools.
  6. Test: pytest.
  7. Verifica: pip check.
  8. Documenta.
  9. Aplica a producción.

Si quieres profundizar:

Te puede interesar

Deja un comentario