• Vamos a presentar algunas ideas básicas de los entonos virtuales en Python.
• Veremos por qué son necesarias y cuál es su función.
• Veremos la forma de crearlos y utilizarlos.

 

 

 

Un PC con Python

 

 

Si empiezas a usar cualquier lenguaje de programación para desarrollar proyectos, no necesariamente muy complejos, te habrás dado cuenta de que a medida que pasa el tiempo cuando vuelves a revisarlo, como norma general ya no te acuerdas de nada y no entiendes un M… de por qué hiciste las cosas de tal o cual manera.

Además, otro problema típico es que usaste unas librerías para cualquier cosa, de la digamos versión 2.13 y ahora en un alarde de laboriosidad han sacado la nueva versión 3.11 que resuelve un montón de problemas, que no tienes pero que consigue que tu programa al que tanto tiempo dedicaste no rule porque da un mensaje incomprensible de que tal o cual función ya no existe o es incompatible con alguno de los argumentos que le pasas o recibes y ponte a averiguar a qué demonios se debe

El resultado es el mismo: estas jodido y tu programa por el que cobraste una pasta (jajajaj) no funciona y tienes a un cliente muy mosqueado. Como no somos los primeros con este problema y el mundo está llena de gente lista, han desarrollado una serie de sistemas para evitar este marrón que se llaman entornos virtuales y de los que vamos a hablar desde Python para que veamos en qué consisten y como usarlos.

Y por si alguien cree que estos entornos, no son lo suficientemente complicados, vamos a subir la nota usándolos con Python (Como ya dije) y usando el Visual Studio Code (VSC en adelante) que es el mejor editor de programación disponible y que a partir de ahora usaremos para todo.

Por eso te recomiendo que te instales la última versión de Python para tu sistema operativo, y que instales VSC en tu PC desde

He estado pensando en hacer una pequeña introducción a la instalación de Python y al VSC, pero qué demonios. Tenéis montones de videos en YouTube hablando de ello y en el caso de VSC, un tutorial seria motivo de toda una serie propia, por lo que os recomiendo que busquéis uno de esas bonitas charlas de YouTube para instalarlo y dar los primeros pasos y así yo puedo irme a tomar unas cañas que se me está haciendo tarde. 

 

 

 

Básicamente, Un entorno virtual en Python es un espacio aislado que contiene sus propias dependencias (Bibliotecas y módulos) y configuración. Es como tener una (o varias) instalación(es) independiente de Python dentro de tu sistema operativo. ¿Y para qué queremos eso?. Bien veamos:

1. Aislamiento:

• Te permite instalar diferentes versiones de la misma biblioteca sin afectar a otras aplicaciones o proyectos.
• Evita conflictos entre dependencias de diferentes proyectos.
• Facilita la colaboración con otros desarrolladores, ya que cada uno puede tener su propio entorno virtual con las dependencias específicas del proyecto.

2. Reproducibilidad:

• Garantiza que tu proyecto se ejecutará de la misma manera en diferentes máquinas, siempre que tengan las mismas dependencias instaladas en el entorno virtual.
• Facilita la depuración de errores, ya que puedes aislar el problema a un entorno virtual específico.

3. Organización:

• Te permite agrupar las dependencias de un proyecto específico en un solo lugar.
• Facilita la gestión de las dependencias, ya que puedes instalar, actualizar y eliminar dependencias sin afectar a otras aplicaciones o proyectos.

4. Portabilidad:

• Puedes copiar o mover un entorno virtual a otra máquina sin necesidad de instalar las dependencias de nuevo.
• Facilita la distribución de tu proyecto a otros desarrolladores.

 

En cierto modo, mucha gente ve esto como una especie de máquinas virtuales, donde instalas lo necesario en cada una, para que se ejecuten adecuadamente tus proyectos y olvidarte de los problemas de cambios de versiones. Pero no son máquinas virtuales, son mucho más sencillas de manejar que estas y ocupan muchos menos recursos

En resumen, los entornos virtuales son una herramienta esencial para el desarrollo de software en Python. Te permiten trabajar de forma organizada, reproducible y portable, y te ayudan a evitar conflictos entre dependencias.

Había pensado en hacer estas cosas con C++, pero resulta que no existen entornos virtuales en C++ directamente y tendríamos que usar contenedores o máquinas virtuales y me daba cantidad de pereza y además me apetecía volver a Python que hacía mucho tiempo que no tocábamos.

 

 

Vamos a empezar creando un directorio para nuestro proyecto que, en un despliegue de imaginación sin precedentes, voy a llamar Proyectos. Basta con crear una carpeta así donde nos guste con el VSC o desde el administrador de archivos y abrirla en el VSC.

Veríamos algo así:

Vamos a crear una nueva carpeta dentro de proyectos pinchando con el botón derecho del ratón sobre la carpeta de Proyectos, elegimos New Folder:

Y escribimos Test1 en el nombre del fichero. El resultado será algo así:

En esta carpeta guardaremos todos los ficheros correspondientes al proyecto Test1. Podemos crear un sencillo programa dentro de Test1 que nos salude. De nuevo botón derecho apuntando a Test1 y seleccionamos new file y escribimos Test1.py (Es importante no olvidarte de escribir el .py para que VSC sepa que quieres un programa Python)

Si pinchas en el fichero Test1.py que acabas de crear, a la derecha puedes escribir un pequeño programita, como:

print("Hola a todos")

y si lo ejecutas con [CTRL] F5, en la ventana del terminal verás:

Lo que es una prueba irrefutable de que no os engaño.

 

 

Una vez que tenemos creada la carpeta Proyectos y otra carpeta dentro llamada Test1, podemos movernos a ese punto desde el propio terminal de VSC:

Fíjate que aquí, desde el terminal, podemos usar los comandos de Linux para crear carpetas (mkdir) o listar el contenido de una (ls)

Ahora vamos por fin a crear un entorno virtual propio, con el comando:

py -m venv .\ Test_1

VSC nos pide conformidad para asignar el proyecto actual a ese entorno. Si cambiamos a Test_1 y hacemos ls:

Mode                 LastWriteTime         Length Name
----                 -------------         ------ ----
d-----        17/03/2024     11:42                Include
d-----        17/03/2024     11:42                Lib
d-----        17/03/2024     11:42                Scripts
-a----        17/03/2024     11:42            119 pyvenv.cfg

Python ha creado una serie de carpetas que puedan albergar lo necesario. Aunque el entorno ya está creado, todavía tenemos que activarlo y para ello desde la carpeta en cuestión:

C:\Users\info\OneDrive\Documentos\Proyectos\Test_1>

Hay que ejecutar:

.\Scripts\activate

Lo que en condiciones normales nos dará un error por parte de Windows como este:

PS C:\Users\info\OneDrive\Desktop\Proyectos\Test1> .\Scripts\activate
.\Scripts\activate : No se puede cargar el archivo C:\Users\info\OneDrive\Desktop\Proyectos\Test1\Scripts\Activate.ps1 porque la ejecución de
scripts está deshabilitada en este sistema. Para obtener más información, consulta el tema about_Execution_Policies en
https:/go.microsoft.com/fwlink/?LinkID=135170.
En línea: 1 Carácter: 1
+ .\Scripts\activate
+ ~~~~~~~~~~~~~~~~~~
+ CategoryInfo          : SecurityError: (:) [], PSSecurityException
+ FullyQualifiedErrorId : UnauthorizedAccess

Esto se debe a las políticas de seguridad de Windows que por defecto vienen establecidas para impedir la ejecución de scripts no autorizados y por lo visto la orden  activate que queremos usar entra en esa categoría.

No tengo mucha idea de todas estas cosas y seguro que algún experto en seguridad me podrá cerrar la boca diciendo que estoy corriendo algún riesgo al usar este comando que lo arregla (Y que espero que no me preguntéis que hace). Para ello pulsa [win]+ X y abre una ventana de Powershell en modo administrador:

Y ahora escribe (O copia y pega):

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope LocalMachine

Te pedirá confirmación (Escribe s +[intro] y listo:

Si ahora volvemos a la terminal de VSC donde nos daba el error al tratar de activar el entorno virtual y escribes Y ahora escribes:

.\Scripts\activate

El resultado será:

Fíjate que ahora la ruta del intérprete de comandos viene precedida por (Test1) que es el entorno que hemos activado, y que es diferente del que teníamos previamente. Esto seguirá así hasta que lo desactivemos. Vamos a ver que tenemos instalado en este entorno:

Pip list

No mucho, como puedes ver, pero instalemos algo… por ejemplo Numpy:

Pip install numpy

Si ahora comprobamos de nuevo que paquetes tenemos instalados:

No debería sorprendernos que numpy, efectivamente se ha instalado. Pero recuerda, que en principio lo hemos instalado dentro del entorno virtual Test1 que era el activo al pedirle que lo instale. Hagamos una cosa. Si me voy a proyectos y creo otra carpeta como Test2:

Observa que, aunque hemos cambiado a otra carpeta al principio del path se sigue viendo en verde (Test1), lo que indica simplemente que el entorno virtual Test1 sigue activo (Aunque estemos en otra carpeta). El entorno no está asociado a un directorio sino un estado del sistema Python general.

Si queremos desactivar el entorno Test1 basta con hacer:

deactivate

Donde puedes ver que el path ya es directo y el Test1 ha desaparecido. Si ejecutamos

Pip list

El Numpy que teníamos instalado para el entorno Test1, no aparece ya que no está disponible al salir del entorno virtual. Si quisieras usar la configuración del entorno virtual es tan sencillo como entrar en él de nuevo:

En fin, no quiero ponerme pesado, pero la idea es que cuando activas un entorno virtual tienes disponibles las librerías y versiones correspondientes asociadas a ese entorno. Para ello es habitual crear un directorio con el nombre del entorno y poner allí todos los programas que requiere ese entorno que pueden ser solo uno o varios si tienen las mismas dependencias.

Es en ese directorio donde se instalan las librerías que instalemos desde dentro del entorno, pero es necesario comprender que el entorno no se limita a ese directorio sin al entorno que se crea cuando se activa y desactiva dicho entorno virtual

Naturalmente, puedes montar un lio del carajo si no manejas esto con un minino de cabeza, pero eso ya es un problema propio de cada uno.

 

 

Vale, hasta aquí todo bien, pero… habíamos dicho que además de poder crear entornos aislados de programación para ciertos proyectos con necesidades especiales de ciertos paquetes de librerías en ciertas versiones, podíamos replicar ese entorno en otros PCs, nuestros o de colegas programadores con los que compartimos el desarrollo y hasta ahora de eso nada.

Bien es el momento de que hablemos de como podemos replicar uno de nuestros internos virtuales en otro PC. Por ejemplo, tengo listo los programas necesarios que he desarrollado en mi PC de escritorio y ahora quiero llevarlo al cliente en mi portátil para hacer las primeras pruebas en real o simplemente quiero instalar el proyecto en un equipo del cliente para que lo vaya probando. ¿Cómo lo hacemos?

Vamos a nuestro proyecto Test1 y como no tenemos muchas librerías instaladas vamos a añadir alguna otra, como django y pygame:

PS C:\Users\info\OneDrive\Desktop\Proyectos\Test1> .\Scripts\activate
(Test1) PS C:\Users\info\OneDrive\Desktop\Proyectos\Test1> pip list

Ahora instalamos Django y pygame (Por poner algo):

pip install django
pip install pygame
pip list

Ya tenemos instaladas unas cuantas cosas y podríamos poner todo lo que quieras a mayores, pero lo mantendré así para evitar complicaciones innecesarias. Ahora necesitamos generar una lista de dependencias de todo lo instalado en el entorno Test1, y para ello usamos este comando:

pip freeze

¿Cuál es la diferencia entre “pip list” y “pip freeze”? Estooo…  ¡Que buena pregunta…! Err…. No tengo ni idea, pero el manual y Google Gemini recomiendan usar la opción freeze para los requerimientos así que yo no voy a llevarlos la contraria. Además, queremos generar un fichero de texto que contenga ese texto para futuros usos, por lo que hacemos:

pip freeze >requirements.txt
ls

Como puedes ver hemos creado el fichero de requerimientos, y si ahora lpodemos ver su contenido con:

cat .\requirements.txt

Puedes ver que contiene los requerimientos de las librerías instaladas junto con sus versiones. Si ahora vamos a otro PC de la empresa ACME y queremos replicar el proyecto en él, bastará con que creemos un entono virtual allí e instalemos los requerimientos.

Como no tengo a tiro otro PC, más que mi portátil pero sería un asco para grabar los pantallazos allí y andar pasándolos, voy a crear un segundo entorno virtual llamado ACME en una carpeta distinta. Lo primero es desactivar en entorno Test1 y luego crear una nueva carpeta de proyecto llamada ACME

deactivate
cd ..
mkdir ACME
py -m venv .\ACME\
cd .\ACME\
.\Scripts\activate

Vale ya tenemos creado el nuevo entorno ACME en una segunda carpeta de mi PC, pero sería lo mismo si estuviésemos en otro PC o portátil. Comprobemos que hay instalado:

cls
pip list

Como era de esperar no hay nada de nada, ya que es un entorno recién nacido. Ahora deberíamos copiar la carpeta de SRC del antiguo entorno Test1, ya que se supone que es ahí donde están todos nuestros preciosos programas para este cliente y además está el fichero de requerimientos que creamos hace muy poco:

cd ..
cd Test1
cp .\requirements.txt ..\ACME\
cd ..\ACME\
ls

Ahora para que podamos replicar el entorno de Test1 en nuestro nuevo proyecto ACME, hacemos:

pip install -r .\requirements.txt
pip list

 

Como podéis ver, un sencillo comando a partir del fichero de requerimientos nos ha instalado Dajango, Numpy y pygame de un tirón con sus respectivas versiones (Que son la fuente de múltiples errores y problemas de ejecución)

¿Y puedo instalar distintas versiones con Python en diferentes entornos? Pues no. Para nada. Hoy por hoy no se puede. En caso de que necesites tener disponibles diferentes versiones activas de Python en tu PC hay que usar herramientas diferentes a los entornos virtuales. Si ese es tu problema, consulta pyenv, anaconda y miniconda

1. pyenv:

Es una herramienta que te permite instalar y administrar diferentes versiones de Python en tu sistema. Puedes crear un entorno virtual para cada versión de Python que instales, y luego instalar las bibliotecas y dependencias que necesitas para cada proyecto.

2. Anaconda:

Es una distribución de Python que incluye muchas bibliotecas científicas y de análisis de datos preinstaladas. También te permite crear entornos virtuales con diferentes versiones de Python y bibliotecas.

3. Miniconda:

Es una versión minimalista de Anaconda que solo incluye las herramientas básicas de Python. Te permite instalar diferentes versiones de Python y crear entornos virtuales con las bibliotecas que necesitas.

Por último, aquí te dejo algunos recursos que te pueden ser útiles:

Administrar múltiples versiones de Python y entornos  virtuales

Uso de varias versiones de Python + Entornos Virtuales (Kali Linux – Debian)

pyenv: instalar y administrar diferentes versiones de Python

Espero que esta información te sea útil.