Crear entornos virtuales en Python para desarrollar apps en Django 6, Flask o FastAPI

▶

Vamos a hablar sobre los espacios virtuales en Python; específicamente nuestro caso de interés que sería para crear aplicaciones en Django 6, Flask o FastAPI o en resumen, cualquier proyecto en Python, usualmente, creamos un entorno virtual.

Los espacios virtuales son sencillamente una herramienta utilizada para crear un entorno de Python aislado del resto del Sistema Operativo y de esta manera podemos desarrollar nuestras apps en Python con versiones específicas de un framework, Python o sus dependencias.

Al desarrollar en Python, existe un problema muy común: cada proyecto requería versiones distintas de los mismos paquetes, y aquello se volvía un caos.

La solución que descubrí fue usar entornos virtuales, una herramienta sencilla pero poderosa que te permite mantener cada proyecto completamente aislado.

En Python, los ambientes virtuales son entornos de desarrollo aislados al sistema operativo, por lo tanto, los paquetes que instalemos no serán instalados en el sistema operativo si no en el ambiente virtual; podemos crear tantos ambientes virtuales como queramos, usualmente tenemos un ambiente virtual por proyecto y con esto, se manejan de manera independiente todos los paquetes y dependencias necesarios para un proyecto en Python en general.

Específicamente se emplean al momento del desarrollo de software con Python; es muy común querer emplear varias versiones de un mismo paquete en diferentes proyectos; y para evitar estar instalando y desinstalando (ya que no podemos instalar dos veces un paquete en nuestro SO o venv), podemos crear un ambiente con el objetivo específico de aislar estas múltiples versiones de este o varios paquetes; por tal motivo en este espacio se encontraran solamente los paquetes que vas a emplear para desarrollar tus aplicaciones en Python, ya sea nativo o con algún framework como Django 6 o Flask.

En definitiva, con los entornos virtuales podemos instalar una versión específica de ese paquete que necesitamos para un proyecto o proyectos en particular, así como el resto de las dependencias que tenga un proyecto.

El Problema de las Dependencias y el Ambiente Global

Cuando instalamos Django, vas a ver que tenemos un montón de dependencias. Es decir, la instalación no solo incluye Django, sino también otros paquetes relacionados. Si ya has trabajado un poco con el ecosistema de Python, sabes a qué me refiero.

Por ejemplo, al instalar Django 5, tendremos tres o cuatro paquetes adicionales. Esto sucede porque Django, a diferencia de los micro-frameworks (como Flask), ya trae muchas cosas desarrolladas (templates, autenticación, etc.). En Flask, por ser un micro-framework (que trae lo mínimo necesario), ni siquiera traía inicialmente el manejador de templates (Jinja2), y había que instalarlo como una dependencia adicional.

La idea principal es esta: instalamos Django y se instalan tres o cuatro paquetes más.

El problema es que, en el mundo real, vas a tener muchos proyectos. 

Si tuviéramos que instalar Django de manera global (como ocurre con Python, un navegador o VS Code), solo podrías tener una sola versión de Django instalada en tu sistema operativo, a menos que hagas configuraciones complejas.

Qué es un entorno virtual en Python y para qué sirve

Qué es un entorno virtual en Python y para qué sirve

Un entorno virtual (o virtual environment) es, básicamente, un espacio aislado dentro de tu sistema operativo donde puedes instalar paquetes de Python sin afectar al resto del sistema.
Esto significa que puedes tener varios proyectos con distintas versiones de Django o de cualquier librería sin que interfieran entre sí.

En mi caso, suelo crear un entorno nuevo para cada proyecto, especialmente cuando trabajo con frameworks como Django o Flask, porque así evito conflictos de dependencias y puedo actualizar o probar versiones sin riesgo.

En Resumen

En lugar de instalar los paquetes de manera global al sistema operativo, se crea una especie de "cajita" (un ambiente virtual) y todo lo instalamos justamente ahí.

• Sistema Operativo Global: Si solo usamos el sistema operativo, solo podemos tener una sola instalación de una versión.
• Ambientes Virtuales: Si empleamos ambientes virtuales, podemos tener "n" ambientes virtuales para todos nuestros proyectos.

Esto aplica a todo lo que quieras trabajar con Python (Django, FastAPI, Tkinter, Flask, etc.). Todos esos frameworks tienen dependencias que pueden chocar entre sí, y por eso no podemos instalarlas de manera global al sistema operativo. Si lo hiciéramos, tendríamos problemas (algo que veremos en una comparación cuando empecemos a instalar Django).

Ventajas de usar entornos virtuales en Django

• Aíslan tus dependencias por proyecto.
• Evitan conflictos entre versiones de paquetes.
• Te permiten compartir fácilmente tus requerimientos con otros desarrolladores.
• Facilitan la instalación de entornos iguales en distintos equipos.

Diferencia entre venv y virtualenv

• venv: viene integrado con Python 3, así que no necesitas instalar nada extra.
• virtualenv: es un paquete externo que ofrece más flexibilidad, sobre todo si usas varias versiones de Python.
• Yo utilizo venv la mayoría de las veces, pero todavía recurro a virtualenv cuando quiero mayor control sobre versiones.

¿Cómo Instalar un entorno virtual?

Nosotros podemos hacernos con la herramienta que nos permite crear venv o entornos virtuales en nuestro equipo; que como puedes ver, es solamente un paquete que lo podemos hacer mediante la pip que recuerda que ya contamos con la misma en versiones recientes de Python:

pip3 install virtualenv

Requisitos previos antes de crear tu entorno

Antes de empezar, asegúrate de tener Python y pip instalados correctamente en tu sistema.

Verificar instalación de Python y pip

Abre tu terminal (o CMD en Windows) y escribe:

$ python --version
$ pip --version

Si obtienes un número de versión, todo está en orden.

Si no, puedes descargar Python desde python.org/downloads

Instalar la herramienta virtualenv

Si prefieres usar virtualenv en lugar de venv, instala el paquete así:

$ pip install virtualenv

Este comando descargará e instalará la herramienta necesaria para crear entornos virtuales.

Crear un entorno virtual en Python paso a paso

Ya con esto podemos crear los espacios virtuales; para eso el siguiente comando:

$ virtualenv <myproject>

En donde <myproject> es el nombre de tu espacio virtual; ahora bien; con el comando anterior se creó una carpeta con el nombre del venv que definistes en el comando anterior, y es esa carpeta tu espacio virtual ya listo para emplear.

Ahora, para emplear el espacio virtual anterior simplemente tenemos que movernos mediante nuestra CMD o terminal hacia dentro de la carpeta llamada Script; que es donde se encuentran nuestros Script para poder gestionar el espacio virtual mediante los archivos binarios contenidos en la misma; para activar o desactivar el ambiente virtual.

O

$ python3 -m venv <myproject>

Estructura de carpetas generada

Una vez creado el entorno, verás algo como esto:

myproject/
│
├── Scripts/ (en Windows)
├── bin/ (en Linux/macOS)
├── Lib/
└── pyvenv.cfg

Activar y desactivar el entorno virtual

Estando en la ubicación comentada anteriormente, verás que tenemos varios archivos para trabajar con nuestro entorno o espacio virtual en Python, algunos llamados activate / deactivate que nos permiten activar o desactivar el espacio virtual.

Lo primero que quisiéramos hacer sería activar nuestro ambiente virtual:

En Windows

$ myproject\Scripts\activate

Notarás que el nombre del entorno aparece al inicio de tu línea de comandos, por ejemplo:

(myproject) C:\Users\andre\Escritorio>

En Linux y macOS

source myproject/bin/activate

O si queremos desactivar el entorno virtual:

deactivate

Este sería nuestro estado inicial antes de ejecutar el comando de activate dentro de la carpeta Script:

C:\Users\andre\OneDrive\Escritorio\myproject\Scripts>

Ahora, vamos a desactivar el espacio virtual con el comando de:

activate

Recordemos qué son los ambientes virtuales

Los ambientes virtuales son, por decirlo de alguna manera, una cajita aislada del sistema operativo.
Dentro de esta cajita tenemos todos los paquetes y dependencias necesarios para un proyecto específico.

Independientemente de la jerga que usemos —ya sea en Django o en otro framework—, cada proyecto o aplicación (por ejemplo, una tienda en línea) suele estar vinculado a un único ambiente virtual.

Por qué crear un ambiente virtual por proyecto

Si deseas crear otro proyecto en Django, lo ideal es crear un nuevo ambiente virtual.
Esto se debe a que, muy probablemente, esos proyectos trabajarán con paquetes o versiones diferentes.

Por ejemplo, además de Django, solemos instalar otros complementos aprovechando el ecosistema de Python.
Cada proyecto puede requerir librerías distintas, por lo que mantener los ambientes separados garantiza que las dependencias sean exclusivas y evita mezclar configuraciones entre proyectos.

Creando el archivo de requerimientos

Una vez que tienes tu ambiente virtual configurado, es buena idea crear el archivo requirements.txt, donde se listarán todos los paquetes necesarios para tu proyecto.
Este archivo te permitirá replicar fácilmente tu entorno en otro equipo o servidor, asegurando que todos los componentes sean exactamente los mismos.

Ejercicio

Por ejemplo si ejecutamos el siguiente comando:

$ python3 -m venv vtasks

El cual generará el espacio virtual, que no es más que una carpeta con varios archivos y carpetas; para activar el mismo, desde la carpeta del espacio virtual:

$ cd vtasks

Ejecutamos en MacOS o Linux:

$ source vtasks/bin/activate

En Windows el comando sería como:

$ vtasks\Scripts\activate

Esta carpeta llamada "tasks" (no la de vtasks, que corresponde al ambiente virtual) es la que te recomiendo que abras en Visual Studio Code (o el editor de tu preferencia); desde la terminal de VSC recuerda activar el ambiente virtual:

Para poder empezar a trabajar con FastApi, necesitamos instalar dos paquetes que veremos a continuación.

Opcional VSC: Crear el Ambiente Virtual mediante VSC

Esta es la opción que te recomiendo que utilices. Crea el ambiente virtual directamente desde una instancia de VS Code.

• Abrir Carpeta: Abre una instancia limpia de VS Code (Ctrl + Shift + N). Arrastra o abre la carpeta de tu proyecto (la que yo llamé first_step).
• Crear Ambiente: Presiona Ctrl + Shift + P.
• Busca: Python: Create Environment.
• Selecciona el proveedor: Venv (o Virtualenv).
• Selecciona tu Python: El Python que tienes instalado a nivel del sistema operativo.

VS Code lo hará todo por ti. La gran ventaja es que no tenemos que lidiar con la selección del intérprete (el método manual) ni con problemas de que a veces lo reconoce y a veces no.

Una vez instalado, abre la terminal en VS Code. Verás que te aparece el nombre del ambiente virtual entre paréntesis, lo que indica que está activo. Si ejecutas pip freeze, de nuevo, verás que no aparece absolutamente nada.

Instalar Django, Flask, FastAPI dentro del entorno virtual

Y ahora nuestra terminal luce de la siguiente manera:

Y con esto podemos realizar todo lo que queramos; por ejemplo, podemos crear un proyecto específico en Flask o Django o simplemente el último en el mercado

$ pip install django

Flask:

$ pip install flask

FastAPI:

$ pip install fastapi uvicorn

Unicorn es un servidor web HTTP de tipo ASGI (Asynchronous Server Gateway Interface) que podemos usar en múltiples frameworks webs en Python de tipo asíncronos como lo son Django, Flask y por supuesto FastApi y para instalar el servidor lo podemos hacer como si fuera un paquete más para Python con:

$ pip install uvicorn

O podemos instalar los dos con un solo comando:

$ pip install fastapi uvicorn

Y esto es todo, ya tenemos Django (o el framework que hayas seleccionado) instalado en nuestro espacio virtual; pero, solo instalamos un paquete, y no tenemos un proyecto; pero, con este paquete podemos crear proyectos en Django:

Si hacemos un:

$ pip freeze

Verás todos los paquetes que componen el paquete que instalamos anteriormente; algo como:

asgiref==3.11.0
Django==6.0
sqlparse==0.5.4
tzdata==2025.2

Como comentamos antes, es muy común qué al instalar paquetes vía la pip, estos paquetes también necesitan de otros paquetes para poder funcionar, y con esto, también son instaladas las mismas, y a estos, se les conoce como dependencias.

En el ejemplo anterior, los paquetes de asgiref, sqlparse, tzdata son dependencias del paquete Django.

Importante notar que, seguramente tu tendrás algunas versiones un poco más recientes y no exactamente las mismas listadas aquí (la versión de cada paquete se encuentra luego del ==).

Como puedes ver, el comando anterior, indica todos los paquetes instalados a nivel del espacio virtual (si el mismo está activo) o del sistema operativo (si el espacio virtual está desactivado o simplemente no lo estás empleando).

Guardar y restaurar dependencias del proyecto

Una de las prácticas que siempre aplico es guardar las dependencias exactas que uso en cada proyecto.
Para hacerlo, ejecuto:

appdirs==1.4.3
asgiref==3.2.4
astroid==2.3.3
certifi==2020.4.5.1
***
tablib==1.1.0
unicodecsv==0.14.1
urllib3==1.25.9
virtualenv==20.0.17
wrapt==1.11.2
xlrd==1.2.0
xlwt==1.3.0

Puedes obtener todos los paquetes instalados en tu SO o ambiente virtual con el comando de:

pip freeze

Y puedes guardarlo en un archivo para que puedas especificar específicamente cuales son las versiones específicas de tu proyecto:

pip freeze > requirements.txt

Que luego puedes instalar fácilmente mediante:

pip install -r requirements.txt

Por lo tanto, fácilmente puedes crear un ambiente para un proyecto en particular o simplemente para el proyecto que estás llevando a cabo empleando los ambientes virtuales; cómo ves la enorme ventaja que tenemos es que podemos instalar versiones específicas de nuestros paquetes.

Ya en este punto estamos listos y podemos empezar a desarrollar nuestras aplicaciones en Flask o empezar a desarrollar nuestras aplicaciones en Django.

Tambien, puedes  instalar versiones especificas con el == por ejemplo:

$ pip install Django==6.0

Consejos finales para mantener tu entorno limpio y estable

Crea un entorno virtual por cada proyecto.

Evita instalar paquetes globalmente.

Usa requirements.txt para controlar versiones.

Si un entorno se corrompe o da errores, elimínalo y créalo de nuevo: ¡es rápido y seguro!

Mantén Python y pip actualizados para evitar incompatibilidades.

En mi experiencia, usar entornos virtuales te evita dolores de cabeza y te da control total sobre tus proyectos Django.

Preguntas frecuentes sobre entornos virtuales y Django

• ¿Qué es un entorno virtual en Python?
  Es un espacio aislado donde puedes instalar dependencias sin afectar al sistema principal.
• ¿Por qué usar un entorno virtual con Django?
  Porque Django depende de muchas librerías que pueden variar de versión entre proyectos.
• ¿Qué diferencia hay entre venv y virtualenv?
  venv viene con Python 3; virtualenv es una herramienta externa más antigua pero aún útil.
• ¿Cómo activo mi entorno virtual?
  En Windows: myenv\Scripts\activate
  En Linux/macOS: source myenv/bin/activate
• ¿Cómo guardo mis dependencias?
  Con pip freeze > requirements.txt puedes exportarlas y reinstalarlas fácilmente.

Opcional  Seleccionar intérprete mediante Visual Studio Code

La mayoría de las veces VSC no reconocerá el intérprete de Python que se configura al momento de instalar un ambiente virtual si no, tomará (el instalado a nivel global del SO) el del sistema, esto trae el inconveniente de que aparecen estas advertencias en las importaciones de la aplicación:

Y por lo tanto, no es posible acceder al detalle de los módulos importados; para solucionar esto, debemos de indicarle a VSC que el intérprete que debe usar es el del ambiente virtual que es donde tenemos instalado todo el ecosistema del proyecto de Django y no el del Sistema Operativo.

Presione la combinación de teclas: Command/Control + Shift + P y buscas por "Seleccionar intérprete":

Y seleccionar el de tu ambiente virtual desde la opción de "+ Escriba la ruta de acceso del intérprete":

En caso de que, con el hecho de seleccionar el intérprete, aún siga mostrando la advertencia de:

***No se ha podido resolver la importación "X"

Puedes probar crear un proyecto desde cero mediante VSC; para ello, abre una instancia limpia de VSC, luego, Command/Control + Shift + P y buscas por "Crear ambiente":

Sigues los pasos que te indica el editor, que sería que selecciones el entorno, colocamos "Venv":

Luego, puede que te indique que coloques el área de trabajo:

Y vuelves al paso 1, que sería Command/Control + Shift + P y buscas por "Crear ambiente"; en esta oportunidad, debería de preguntarte por el intérprete que quieras emplear para crear el área de trabajo:

Y con esto debería de reconocerse los paquetes instalados a nivel del ambiente virtual.

Conclusión

Crear un entorno virtual en Python para Django no es complicado, y una vez que entiendes su propósito, se vuelve parte natural de tu flujo de trabajo.

En mi caso, fue un antes y un después en la organización de mis proyectos.

Te animo a que lo pruebes tú mismo: en pocos minutos tendrás tu propio entorno listo para crear cualquier aplicación en Django, Flask o FastAPI.

El siguiente paso, es conocer sobre el qué es Django framework.