Entornos virtuales de Python: una guía completa de venv, virtualenv y Conda

Name

Soren Atelier

Updated on 11/2/2026

Los desarrolladores de Python se enfrentan a un reto común: conflictos de dependencias entre proyectos. Cuando varias aplicaciones requieren versiones diferentes de la misma librería, las instalaciones a nivel de sistema crean incompatibilidades que rompen el código. Un proyecto de ciencia de datos puede necesitar pandas 1.3.5 mientras que una aplicación web requiere pandas 2.0.0, lo que hace imposible ejecutar ambos sobre la misma instalación de Python.

Este problema se intensifica en entornos de equipo, donde los desarrolladores trabajan con versiones distintas de paquetes, o al desplegar aplicaciones en servidores de producción. Sin un aislamiento adecuado, instalar una nueva dependencia para un proyecto puede romper otro, dando lugar al clásico escenario de “en mi máquina funciona”, que desperdicia horas de depuración.

Los entornos virtuales de Python resuelven esto creando espacios aislados donde cada proyecto mantiene sus propias dependencias de forma independiente. Esta guía cubre desde el uso básico de venv hasta la gestión avanzada de entornos con conda, ayudándote a elegir la herramienta adecuada e implementar buenas prácticas para el desarrollo profesional en Python.

Por qué importan los entornos virtuales

Los entornos virtuales abordan tres problemas críticos en el desarrollo con Python:

Aislamiento de dependencias: Cada proyecto obtiene sus propias instalaciones de paquetes sin afectar al Python del sistema ni a otros proyectos. Instalar Django 4.2 en un entorno no impacta a un proyecto legacy que ejecuta Django 2.2 en otro entorno.

Gestión de versiones: Distintos proyectos pueden usar diferentes versiones de Python. Un proyecto de machine learning podría usar Python 3.11 por rendimiento, mientras que una base de código legacy requiere Python 3.8 por compatibilidad con librerías antiguas.

Reproducibilidad: Los entornos virtuales permiten recrear exactamente configuraciones de desarrollo en distintas máquinas. Al exportar listas de dependencias, los miembros del equipo pueden replicar el mismo entorno, eliminando errores por desajustes de versión.

Sin entornos virtuales, los desarrolladores se arriesgan a romper la instalación de Python del sistema, de la que los sistemas operativos a menudo dependen para funciones esenciales. Instalar paquetes incompatibles globalmente puede inutilizar herramientas del sistema, requiriendo arreglos complejos o incluso una reinstalación completa del SO en casos graves.

Módulo venv de Python: la solución integrada

Python 3.3 introdujo venv como un módulo incorporado para crear entornos virtuales ligeros. No requiere instalación adicional y ofrece funcionalidad suficiente para la mayoría de proyectos.

Crear un entorno virtual con venv

Navega a tu directorio del proyecto y crea un entorno virtual:

python -m venv myenv

Este comando crea un directorio myenv que contiene:

• Una copia del intérprete de Python
• La librería estándar
• El gestor de paquetes pip
• Scripts para activar el entorno

Para versiones específicas de Python cuando existen varias instalaciones:

python3.11 -m venv myenv

Activar entornos virtuales

La activación varía según el sistema operativo:

Linux y macOS:

source myenv/bin/activate

Windows Command Prompt:

myenv\Scripts\activate.bat

Windows PowerShell:

myenv\Scripts\Activate.ps1

Tras la activación, el prompt de la terminal muestra el nombre del entorno entre paréntesis:

(myenv) user@machine:~/project$

Todas las instalaciones con pip ahora se dirigen al entorno virtual en lugar del Python del sistema.

Instalar paquetes en venv

Con el entorno activado, instala paquetes normalmente:

pip install pandas numpy matplotlib

Estos paquetes se instalan solo en el entorno virtual. Para verificarlo:

pip list

Esto muestra los paquetes específicos del entorno activo, no las instalaciones a nivel de sistema.

Desactivar entornos virtuales

Vuelve al Python del sistema:

deactivate

El nombre del entorno desaparece del prompt, y los comandos de pip vuelven a afectar al Python del sistema.

virtualenv: la alternativa mejorada

virtualenv precede a venv y ofrece funciones adicionales, aunque requiere instalación separada. Soporta versiones antiguas de Python (2.7+) y proporciona una creación de entornos más rápida mediante optimizaciones.

Instalar virtualenv

pip install virtualenv

Crear y usar entornos con virtualenv

virtualenv myenv

La activación funciona igual que con venv. virtualenv añade opciones útiles:

Especificar versión de Python:

virtualenv -p python3.10 myenv

Crear sin pip (instalarlo después por separado):

virtualenv --no-pip myenv

Copiar site-packages del sistema (acceder a paquetes instalados globalmente):

virtualenv --system-site-packages myenv

venv vs virtualenv

Para proyectos nuevos en Python 3, venv es suficiente. Usa virtualenv cuando trabajes con Python 2, necesites crear entornos más rápido o requieras opciones avanzadas de configuración.

Entornos Conda: el estándar en computación científica

Conda gestiona tanto paquetes como entornos y es especialmente popular en ciencia de datos para manejar dependencias complejas, como librerías numéricas con componentes en C/C++.

Instalar Conda

Descarga:

• Anaconda: Distribución completa con 1.500+ paquetes preinstalados (3GB+)
• Miniconda: Instalador mínimo con conda, Python y paquetes esenciales (400MB)

Miniconda es adecuado para la mayoría de desarrolladores, ya que instala paquetes bajo demanda.

Crear entornos Conda

conda create -n myenv python=3.11

Crear con paquetes específicos:

conda create -n datascience python=3.11 pandas numpy scikit-learn jupyter

Activar y desactivar entornos Conda

conda activate myenv

conda deactivate

Gestionar paquetes con Conda

Instala desde repositorios conda:

conda install tensorflow

Conda gestiona automáticamente dependencias complejas, compilando paquetes con librerías optimizadas para un mejor rendimiento que los equivalentes con pip en muchos casos.

Listar paquetes instalados:

conda list

Exportar y clonar entornos Conda

Exportar la especificación del entorno:

conda env export > environment.yml

Recrear el entorno en otra máquina:

conda env create -f environment.yml

Clonar un entorno existente:

conda create --name newenv --clone myenv

Conda vs pip

Los entornos conda pueden usar tanto conda como pip, pero mezclar ambos requiere cautela:

conda install pandas
pip install custom-package

Instala primero los paquetes conda y después los paquetes con pip para evitar conflictos en la resolución de dependencias.

Comparación integral: herramientas modernas de entornos en Python

Elige venv para proyectos sencillos en Python 3 sin requisitos complejos.

Elige conda para ciencia de datos, machine learning o proyectos con dependencias binarias que requieren librerías compiladas.

Elige poetry cuando publiques paquetes en PyPI o necesites una gestión estricta de dependencias.

Elige pipenv para aplicaciones web que necesitan entornos reproducibles con gestión automática del entorno virtual.

Gestionar dependencias con requirements.txt

Los archivos requirements.txt especifican versiones exactas de paquetes para reproducir un entorno.

Crear requirements.txt

Congela los paquetes del entorno actual:

pip freeze > requirements.txt

Esto genera:

pandas==2.1.4
numpy==1.26.2
matplotlib==3.8.2

Instalar desde requirements.txt

Crea un entorno nuevo:

python -m venv newenv
source newenv/bin/activate  # or appropriate activation for your OS
pip install -r requirements.txt

Esto instala las versiones exactas especificadas, garantizando consistencia entre entornos.

Buenas prácticas para requirements.txt

Fijar versiones para producción:

Django==4.2.7
psycopg2-binary==2.9.9

Usar rangos de versiones para flexibilidad en desarrollo:

Django>=4.2,<5.0
pytest>=7.0

Separar dependencias de desarrollo y producción:

requirements.txt (producción):

Django==4.2.7
gunicorn==21.2.0

requirements-dev.txt (desarrollo):

-r requirements.txt
pytest==7.4.3
black==23.12.0

Instalar requisitos de desarrollo:

pip install -r requirements-dev.txt

Añadir comentarios para mayor claridad:

# Web framework
Django==4.2.7

# Database adapter
psycopg2-binary==2.9.9

# Development tools
pytest==7.4.3  # Testing framework

Empaquetado moderno de Python con pyproject.toml

PEP 518 introdujo pyproject.toml como archivo de configuración estandarizado que reemplaza setup.py y otros archivos de configuración.

Estructura básica de pyproject.toml

[build-system]
requires = ["setuptools>=61.0"]
build-backend = "setuptools.build_meta"
 
[project]
name = "myproject"
version = "1.0.0"
description = "A sample Python project"
readme = "README.md"
requires-python = ">=3.8"
dependencies = [
    "pandas>=2.0.0",
    "numpy>=1.24.0",
]
 
[project.optional-dependencies]
dev = [
    "pytest>=7.0",
    "black>=23.0",
]

Usar pyproject.toml con pip

Instalar dependencias del proyecto:

pip install -e .

Instalar con dependencias de desarrollo:

pip install -e ".[dev]"

Flujo de trabajo con Poetry

Poetry usa pyproject.toml para la gestión completa de dependencias:

poetry new myproject
cd myproject
poetry add pandas numpy
poetry add --group dev pytest black

Poetry crea y gestiona automáticamente entornos virtuales:

poetry install  # Creates venv and installs dependencies
poetry shell    # Activates environment

Entornos virtuales en IDEs

Configuración en VS Code

VS Code detecta automáticamente entornos virtuales en ubicaciones estándar (.venv, venv, env).

Seleccionar intérprete de Python:

1. Pulsa Ctrl+Shift+P (Windows/Linux) o Cmd+Shift+P (macOS)
2. Escribe "Python: Select Interpreter"
3. Elige tu entorno virtual

Activación automática: VS Code activa el entorno seleccionado al abrir terminales integradas.

Configura en .vscode/settings.json:

{
    "python.defaultInterpreterPath": "${workspaceFolder}/.venv/bin/python",
    "python.terminal.activateEnvironment": true
}

Configuración en PyCharm

PyCharm ofrece una integración completa con entornos virtuales:

Crear entorno virtual:

1. File → Settings → Project → Python Interpreter
2. Haz clic en el icono de engranaje → Add
3. Selecciona "Virtualenv Environment"
4. Elige un entorno nuevo o existente

Auto-activación: PyCharm activa automáticamente el intérprete del proyecto para terminales y configuraciones de ejecución.

Jupyter Notebooks y entornos virtuales

Instala ipykernel en tu entorno virtual:

source myenv/bin/activate
pip install ipykernel
python -m ipykernel install --user --name=myenv

Esto hace que el entorno esté disponible como kernel en Jupyter:

jupyter notebook

Selecciona "myenv" en el menú de kernels.

Para científicos de datos que trabajan intensamente en Jupyter, RunCell (opens in a new tab) ofrece un entorno Jupyter con IA que gestiona automáticamente entornos virtuales y dependencias, simplificando el flujo de trabajo sin configuración manual del entorno.

Problemas comunes con entornos virtuales

Versión de Python incorrecta

Problema: El entorno virtual usa una versión de Python incorrecta.

Solución: Especifica el intérprete de Python explícitamente:

python3.11 -m venv myenv

O con virtualenv:

virtualenv -p /usr/bin/python3.11 myenv

No se encuentra el script de activación

Problema: "activate: No such file or directory"

Solución: Verifica que la creación del entorno se completó correctamente. Recréalo si es necesario:

rm -rf myenv
python -m venv myenv

Error de política de ejecución en PowerShell

Problema: Windows PowerShell bloquea scripts de activación.

Solución: Permite la ejecución de scripts para el usuario actual:

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

El entorno no se reconoce en PATH

Problema: El entorno activado sigue usando el Python del sistema.

Solución: Verifica la activación comprobando la ubicación de Python:

which python  # Linux/macOS
where python  # Windows

Debería apuntar al directorio del entorno virtual. Si no, desactiva y vuelve a activar:

deactivate
source myenv/bin/activate

Fallos al instalar paquetes

Problema: Errores de pip install en el entorno virtual.

Solución: Actualiza pip, setuptools y wheel:

pip install --upgrade pip setuptools wheel

Conflictos en entornos Conda

Problema: Mezclar conda y pip causa problemas de dependencias.

Solución: Instala primero paquetes conda, luego paquetes pip:

conda install numpy pandas
pip install custom-library

O usa conda exclusivamente cuando sea posible:

conda install -c conda-forge package-name

Buenas prácticas para entornos virtuales

Convenciones de nombres

Usa nombres descriptivos y consistentes:

• .venv - Directorio oculto estándar para entornos específicos del proyecto
• venv - Alternativa común
• myproject-env - Descriptivo para múltiples proyectos

Evita nombres genéricos como "env" o "python" que generan confusión.

Configuración de .gitignore

Excluye siempre los entornos virtuales del control de versiones:

# Virtual environments
venv/
.venv/
env/
ENV/
myenv/

# Conda environments
conda-env/

# Virtual environment markers
pyvenv.cfg

Estructura del proyecto

Organiza proyectos con una separación clara del entorno:

myproject/
├── .venv/                 # Virtual environment (not in git)
├── src/
│   └── myproject/
│       └── __init__.py
├── tests/
│   └── test_main.py
├── requirements.txt       # Production dependencies
├── requirements-dev.txt   # Development dependencies
├── pyproject.toml         # Project configuration
├── README.md
└── .gitignore

Un entorno por proyecto

Crea un entorno virtual dedicado para cada proyecto en lugar de compartir entornos. Esto evita conflictos de dependencias y simplifica la depuración.

Documentar la configuración del entorno

Incluye instrucciones de configuración en README.md:

## Setup
 
1. Create virtual environment:

python -m venv .venv

2. Activate environment:
- Linux/macOS: `source .venv/bin/activate`
- Windows: `.venv\Scripts\activate`

3. Install dependencies:

pip install -r requirements.txt

Actualizaciones periódicas de dependencias

Actualiza paquetes periódicamente mientras pruebas compatibilidad:

pip list --outdated
pip install --upgrade package-name
pip freeze > requirements.txt

Usa herramientas como pip-review para actualizaciones en lote:

pip install pip-review
pip-review --local --interactive

Docker vs entornos virtuales

Los contenedores Docker y los entornos virtuales resuelven niveles distintos de aislamiento:

Los entornos virtuales aíslan paquetes de Python dentro del mismo sistema operativo. Ofrecen:

• Uso ligero de recursos
• Creación y activación rápidas
• Aislamiento suficiente para la mayoría del desarrollo
• Integración fácil con herramientas locales

Los contenedores Docker aíslan stacks completos de aplicaciones, incluyendo SO, librerías del sistema y servicios. Ofrecen:

• Reproducibilidad completa del entorno
• Comportamiento consistente entre desarrollo y producción
• Aislamiento de dependencias a nivel de sistema
• Soporte para aplicaciones multi-servicio

Cuándo usar cada uno

Usa entornos virtuales:

• Desarrollo y pruebas locales
• Proyectos solo de Python sin dependencias del sistema
• Prototipado rápido y experimentación
• Flujos de trabajo individuales

Usa Docker:

• Despliegues a producción
• Aplicaciones con dependencias a nivel de sistema
• Arquitecturas multi-servicio (web app + base de datos + caché)
• Entornos estandarizados para equipos
• Pipelines CI/CD

Combinar ambos

Muchos proyectos usan entornos virtuales en desarrollo y Docker para despliegue:

Dockerfile:

FROM python:3.11-slim
 
WORKDIR /app
 
COPY requirements.txt .
RUN python -m venv /opt/venv
ENV PATH="/opt/venv/bin:$PATH"
 
RUN pip install -r requirements.txt
 
COPY . .
 
CMD ["python", "app.py"]

Este enfoque aprovecha entornos virtuales incluso dentro de contenedores para una gestión de dependencias más limpia.

Gestionar múltiples versiones de Python con pyenv

pyenv simplifica la instalación y el cambio entre versiones de Python, complementando las herramientas de entornos virtuales.

Instalar pyenv

Linux/macOS:

curl https://pyenv.run | bash

Windows: Usa pyenv-win:

Invoke-WebRequest -UseBasicParsing -Uri "https://raw.githubusercontent.com/pyenv-win/pyenv-win/master/pyenv-win/install-pyenv-win.ps1" -OutFile "./install-pyenv-win.ps1"; &"./install-pyenv-win.ps1"

Instalar versiones de Python

Listar versiones disponibles:

pyenv install --list

Instalar versiones específicas:

pyenv install 3.11.7
pyenv install 3.10.13

Establecer versiones de Python

Global (a nivel del sistema):

pyenv global 3.11.7

Local (directorio del proyecto):

cd myproject
pyenv local 3.10.13

Esto crea el archivo .python-version que especifica la versión para este directorio.

Combinar pyenv con entornos virtuales

pyenv local 3.11.7
python -m venv .venv
source .venv/bin/activate

O usa el plugin pyenv-virtualenv:

pyenv virtualenv 3.11.7 myproject-env
pyenv activate myproject-env

Esto integra la gestión de versiones de Python con la creación de entornos virtuales en un flujo de trabajo unificado.

Técnicas avanzadas de entornos virtuales

Variables de entorno en entornos virtuales

Guarda la configuración en archivos específicos del entorno:

.env:

DATABASE_URL=postgresql://localhost/mydb
SECRET_KEY=development-secret-key
DEBUG=True

Cárgalo con python-dotenv:

pip install python-dotenv

from dotenv import load_dotenv
import os
 
load_load_dotenv()
database_url = os.getenv('DATABASE_URL')

Scripts de pre y post activación

Personaliza el comportamiento de activación del entorno modificando scripts de activación.

Linux/macOS - Edita myenv/bin/activate:

Añade antes de la última línea:

export DATABASE_URL="postgresql://localhost/mydb"
export FLASK_ENV="development"

Windows - Crea myenv/Scripts/activate.bat:

Añade:

set DATABASE_URL=postgresql://localhost/mydb
set FLASK_ENV=development

Compartir entornos virtuales entre proyectos

Aunque generalmente no se recomienda, los entornos compartidos funcionan para proyectos relacionados con dependencias idénticas:

python -m venv ~/shared-envs/data-science
source ~/shared-envs/data-science/bin/activate

Activa este entorno en múltiples directorios de proyecto. Sin embargo, este enfoque arriesga romper todos los proyectos si las dependencias entran en conflicto.

FAQ

Conclusión

Los entornos virtuales de Python forman la base del desarrollo profesional en Python, evitando conflictos de dependencias y habilitando configuraciones de proyecto reproducibles. El módulo integrado venv cubre la mayoría de casos de uso de forma eficiente, mientras que conda destaca en proyectos de ciencia de datos con dependencias binarias complejas. Herramientas modernas como poetry y pipenv añaden resolución avanzada de dependencias para proyectos que requieren un control estricto de versiones.

Una gestión exitosa de entornos virtuales sigue patrones claros: un entorno por proyecto, reglas completas en .gitignore y procedimientos de configuración documentados. Combinados con pyenv para gestionar versiones de Python e integración con IDEs para flujos de trabajo más ágiles, los entornos virtuales transforman una gestión caótica de dependencias en procesos sistemáticos y predecibles.

Para científicos de datos que trabajan en notebooks de Jupyter, RunCell (opens in a new tab) ofrece un entorno con IA que maneja automáticamente la complejidad de los entornos virtuales, permitiendo centrarse en el análisis en lugar de la configuración. Ya sea usando venv para proyectos sencillos o conda para computación científica, los entornos virtuales siguen siendo herramientas esenciales que todo desarrollador de Python debe dominar.

Empieza tu próximo proyecto con un entorno virtual limpio y documenta el proceso de configuración. Tu yo futuro y tus compañeros agradecerán la reproducibilidad y el aislamiento que evitan horas de depuración de misteriosos problemas de dependencias.