Entornos virtuales en Python
¿Qué es un entorno virtual en Python?
Un entorno virtual en Python, es un espacio aislado o, valga la redundancia, un entorno aislado.
El objetivo de crear un entorno es poder instalar y gestionar bibliotecas específicas para diferentes proyectos de tal manera, que no interfieran entre sí.
El problema que resuelve un entorno virtual es ese, evitar conflictos.
Para ponernos en situación, imagina que tienes muchos proyectos en Python, pues bien, es muy probable que necesites diferentes versiones de librerías, por ejemplo, podemos tener un proyecto que requiera Django 3.2 y luego otro, que requiera Django 4.1.
Sin entornos virtuales, solo podríamos tener una versión instalada globalmente, lo que causaría conflictos.
Gracias a los entornos, resolvemos este problema creando espacios independientes. Así que, para cada proyecto, es ideal crear un entorno virtual y poder trabajar con grupos independientes de bibliotecas.
Para ello, Python viene con el módulo venv que se encarga de crear entornos virtuales.
¿Cómo trabaja?
Cuando activamos un entorno, Python modifica temporalmente las variables de sistema para apuntar a la instalación local del entorno en lugar de la global. Esto quiere decir que cualquier paquete que instalemos con el comando pip install, se guardará solo en ese entorno específico.
El flujo típico de trabajo es:
- Crear el entorno
- Activarlo
- Instalar las dependencias necesarias y trabajar en tu proyecto
- Cuando terminemos de trabajar desactivarlo
Crear entorno
Normalmente los entornos se crean dentro del directorio de nuestro proyecto, aunque siempre haya excepciones, nosotros vamos a seguir la convención o regla general.
Para crear nuestro primer entorno, vamos a crear un proyecto de prueba y dentro de él incluiremos el entorno.
Vamos a simular que queremos crear una web con Python usando el framework Django.
Da igual si estamos en Linux, Windows o Mac, abrimos la consola/terminal y escribimos:
mkdir proyecto_web cd proyecto_web/ python -m venv venv
Ahora, si estamos en Linux o Mac lo activamos así:
source venv/bin/activate
Y si es Windows de esta otra manera:
venv\Scripts\activate
En mi caso:
Lo que hemos hecho ha sido crear un directorio llamado “proyecto_web”, hemos accedió a él, después, mediante el comando “python -m venv venv”, hemos creado el entorno que se llama “venv” (veremos más adelante el motivo) y por último hemos activado el entorno para poder trabajar dentro de él, es decir, ahora, cualquier cosa que hagamos, por ejemplo, instalar una biblioteca, se instalara dentro de ese entorno y solo para ese entorno.
Por cierto, la última línea “(venv) C:\Users\nosfe\Python\proyecto_web>”, concretamente (venv), ya nos está indicando que estamos dentro del entorno.
Ahora el siguiente paso es instalar las bibliotecas o dependencias necesarias. Como dijimos al principio, en el ejemplo vamos a usar Django, concretamente la última versión, la 5.2.3.
Así que a continuación escribimos en la misma terminal:
python -m pip install Django==5.2.3
¡Perfecto! Ahora ya tenemos nuestro entorno creado con Django, pero no vamos a crear ningún proyecto en Django, ya que lo siento, pero no es el objetivo de este artículo ;-P
A continuación, para finalizar y sin salirnos del entorno, es muy importante generar un archivo llamado requirements.txt.
Para ello escribimos:
pip freeze > requirements.txt
¡Y ya está!
Lo que acabamos de hacer ahora es:
- pip freeze: Genera una lista con todos los paquetes instalados en el entorno virtual con sus versiones exactas
- >: Redirecciona la salida a un archivo
- requirements.txt: El nombre del archivo por convención
Como acabamos de ver, el archivo requirements.txt es fundamental en proyectos Python porque nos permite:
- Registra todas las dependencias del proyecto con sus versiones exactas (ya sabemos las ventajas que tiene eso)
- Permite replicar el entorno en otra máquina o entorno de producción
Más adelante, si queremos replicar este entorno, para instalar las dependencias haremos:
pip install -r requirements.txt
Eso instalara todas las dependencias que necesita el entorno o proyecto.
Y ahora ya si, si hemos terminado de trabajar en el proyecto, desactivamos el entorno escribiendo:
deactivate
Recuerda el orden mencionado arriba: creamos entorno, lo activamos, instalamos dependencias y trabajamos y ya, por último, desactivamos.
Ahora, si te preguntas: «¿Por qué al entorno hay que llamarlo “venv”? o ¿Qué pasa si queremos (por lo que sea) más de un entorno por proyecto?»
Bueno, bueno…
veámoslo más abajo.
Convenciones de nombres
Como buena práctica y buenos desarrolladores y programadores que queremos ser jeje, lo ideal es seguir algunas normas de estilo o convenciones que, aunque no sean oficiales no importa, ya que como digo, si queremos ser buenos hay que seguirlas 😁
¿Por qué al entorno hay que llamarlo venv?
Realmente lo puedes llamar como quieras, pero que sepas que la buena práctica es:
- ✔venv o .venv (casi siempre se usa este)
- ✔ django_aplicacion_1 (es un buen nombre corto y descriptivo)
- ✖ Espacios o caracteres especiales: “mi primer proyecto#1”
Como recomendación personal y ya casi por la gran mayoría de desarrolladores, intenta llamarlo siempre .venv en proyectos modernos ya que, si trabajas en git y VS Code, será detectado automáticamente e ignorado en el archivo .gitignore.
Por último, siempre te quedará una estructura de tu proyecto más bonita, organizada y similar a esta:
mi_proyecto/
.venv/ # Entorno virtual
src/
app.py
requirements.txt
Crear más de un entorno
¿Qué pasa si queremos (por lo que sea) más de un entorno por proyecto?
No pasa nada, en ese caso lo ideal es “crear una convención” por nosotros mismos.
Por ejemplo, imagina que queremos probar diferentes versiones de Python, pues tan fácil como crear los entornos que necesitemos, pero eso sí, con nombres descriptivos:
mi_proyecto/
venv_py39/ # Entorno para Python 3.9
venv_py311/ # Entorno para Python 3.11
venv_py312/ # Entorno para Python 3.12
src/
requirements.txt
Ahora creamos los diferentes entornos:
python3.9 -m venv venv_py39 python3.11 -m venv venv_py311
Y activamos según necesidad:
venv_py39\Scripts\activate # Para testing con Python 3.9 venv_py11\Scripts\activate # Para testing con Python 3.9
Recuerda que si usamos Linux sería:
source venv_py39/bin/activate source venv_py11/bin/activate
O incluso podemos hacer entornos separados para producción y desarrollo, todo eso ya según las necesidades que tengamos, pero si es la primera vez que trabajas con entornos y/o es para un proyecto simple e individual no te compliques, llámalo venv o .venv e inclúyelo dentro del directorio de tu proyecto.
Lo ideal es así:
Y el flujo de trabajo una vez más seria… ¿lo recuerdas? 🤭
Para trabajar en el blog:
cd proyecto_blog/ source venv/bin/actívate # Linux venv\Scripts\activate # Windows python main.py
Para trabajar en la tienda:
deactivate # Recuerda salir del entorno anterior cd ../proyecto_tienda/ source venv/bin/actívate # Linux venv\Scripts\activate # Windows python app.py
También, déjame comentarte que, si quieres, puedes tener un directorio solo para entornos, por ejemplo:
entornos/ # Directorio centralizado
entorno_blog_django/
entorno_tienda_flask/
Y luego otro directorio con tus proyectos:
proyectos/ # Directorio de proyectos
mi_blog/
tienda_online/
Y el flujo sería:
Si estamos en Linux activar el entorno desde cualquier lugar:
source ~/entornos/blog_django/bin/activate
Ir al proyecto:
cd ~/proyectos/mi_blog/
Y trabajar en él.
Si es Windows «igual»:
C:\entornos\blog_django\Scripts\activate
Ir al proyecto:
cd C:\proyectos\mi_blog\
Y más de lo mismo, trabajar en él.
¿Queremos cambiar a otro proyecto?
Pues hacemos exactamente lo mismo, pero siempre, desactivamos primero el entorno actual mediante el comando deactivate y repetimos el proceso anterior.
Algunos tips
Dado que puede ser un poco pesado hacer lo mismo una y otra vez… podemos aprovechar las ventajas de Linux y crear un archivo .bash para facilitar el proceso.
Siguiendo con el ejemplo, podemos hacer:
alias blog="source ~/entornos/blog_django/bin/activate && cd ~/proyectos/mi_blog" alias tienda="source ~/entornos/tienda_flask/bin/activate && cd ~/proyectos/tienda_online"
Así solo escribes blog y automáticamente activas el entorno y vas al proyecto.
¡Ojo! que si trabajas en Windows como es mi caso, también tiene sus ventajas eh!
Para ello podemos crear un archivo bat para el blog:
# blog.bat @echo off call C:\entornos\blog_django\Scripts\activate cd C:\proyectos\mi_blog\
Solo tendrías que ejecutar blog.bat y ya está.
Ahora si… ¡Hasta aquí llegamos!
Conclusión
Recuerda que los entornos virtuales en Python son imprescindibles para cualquier desarrollador de Python. Nos ofrecen la ventaja de mantener nuestros proyectos organizados y evitar el caos de las dependencias.
Recuerda siempre seguir el flujo de trabajo y muy importante también, de crear el archivo requirements.txt.
¿Respecto a las ubicaciones y nombres?
No te comas el coco, intenta siempre seguir las mejores convenciones y hacerlo fácil no solo para ti, sino para todo el mundo.
Como principiante, puede que te resulte una herramienta innecesaria al principio, pero créeme que cuando te encuentres con tu primer conflicto de dependencias, entenderás porque son fundamentales los entornos. Piensa que, si no los usas, tarde o temprano tendrás problemas con las dependencias y versiones que te harán perder mucho tiempo, así que… ¡ya estas tardando!
Aunque tu proyecto sea simple o pequeño, usa entornos virtuales, en el futuro de puede ahorrar muchos dolores de cabeza.
Para finalizar y como siempre digo, espero que te haya resultado útil el articulo y corre, ¡no esperes más! Cualquier cosa ya sabes dónde encontrarme 😉
Sobre el autor
Publicaciones relacionadas:
Este artículo está publicado bajo una licencia Creative Commons Atribución-CompartirIgual 4.0 Internacional . Puedes compartirlo y adaptarlo, incluso con fines comerciales, siempre que cites al autor y mantengas esta misma licencia.
