---
title: Pipenv: gestor de entornos virtuales de Python
url: https://jarroba.com/pipenv-gestor-de-entornos-virtuales-de-python/
author: Ramón Invarato
date: 2020-09-18
modified: 2026-10-23
language: es
license: CC BY-NC-SA 3.0 (https://creativecommons.org/licenses/by-nc-sa/3.0/) — attribution: "Pipenv: gestor de entornos virtuales de Python", Ramón Invarato, jarroba.com
categories: Lenguajes de Programación
tags: entorno virtual, pip, pipenv, pipfile, python, virtualenv
series: Entornos de Python (part 3 of 3)
---

# Pipenv: gestor de entornos virtuales de Python

> Pipenv es un gestor de entornos virtuales de Python, para que gestione por nosotros los entornos para cada uno de nuestros proyectos Python.

Si queremos tener un gestor que nos **unifique y gestione tanto Virtualenv como Pip** podemos **utilizar Pipenv**. Pipenv funciona en Windows, Linux y Mac; y en todos los sistemas operativos funciona exactamente igual (cambiando la ruta donde se guardan las cosas). La mayor cualidad de **Pipenv** es que crea (y **gestiona**) **entornos virtuales exclusivos en una carpeta separada** del proyecto **y nos facilita los ficheros de requisitos**.

 

Antes de empezar con Pipenv, recomiendo encarecidamente tener unas nociones básicas sobre «entornos virtuales de Python» sobre todo los exclusivos por proyecto. Para ello puedes echar un ojo [al artículo que hemos creado sobre Entornos virtuales de Python: común y Anaconda](https://jarroba.com/entornos-virtuales-de-python-comun-y-anaconda/) (aunque se puede leer por separado perfectamente, este artículo está diseñado como continuación de este otro).

 

**Nota sobre Pipenv y Anaconda**: No recomiendo utilizar Pipenv con Anaconda, ya que Anaconda hace más o menos lo mismo que “Pipenv” salvo por alguna excepción (se puede usar Pipenv con Anaconda, pero es tener un “gestor de entornos virtuales” dentro de un “gestor de entornos virtuales” cada uno gestionando entornos virtuales por su lado y a su modo). Recomiendo Pipenv si se trabaja sobre “Python común”. Pipenv se instala con PIP en la carpeta “Lib” del “Python global” (si no tienes instalado Virtualenv lo instalará automáticamente como dependencia pues lo necesita). Cuando lo instalemos Pipenv tendremos unas cuantas variables de entorno de Python en el sistema operativo (que podremos usar en la consola) que enumero para tenerlas claras: python, pip, virtualenv, pipenv. Usaremos la nueva “pipenv” para gestionar los entornos virtuales (así que nos olvidamos de utilizar “virtualenv” y sus comandos; aunque pipenv utiliza comandos semejantes). Pipenv creará los entornos virtuales (usa por debajo Virtualenv) en una carpeta que gestiona llamada “virtualenvs” y si le pasamos paquetes en la creación podremos instalarlos (usa por debajo PIP).

 

![Diagrama de Pipenv: crea con virtualenv un entorno aislado por proyecto (A y B) en la carpeta virtualenvs al ejecutar pipenv install](https://jarroba.com/wp-content/uploads/2020/09/Pipenv-gestionando-entornos-virtuales-con-proyectos-www.Jarroba.com_-817x1024.png)

 

Pipenv creará un entorno virtual por proyecto en la carpeta “virtualenvs” que llamará con el mismo nombre que el proyecto seguido de un identificador. Y dentro del proyecto creará un fichero de requisitos llamado “Pipfile” (y “Pipfile.lock”; ambos los veremos más adelante) que nos servirá para recrear el entorno virtual (con la misma versión de Python y mismos paquetes con las mismas versiones) en otro lado u otra máquina diferente (sin tener que copiar la carpeta entera del entorno virtual, que no es una buena práctica).

 

 

## Instalar Pipenv

 

**“Pipenv” se instala**con el comando (no viene incorporado):

 

```bash
pip install pipenv
```

 

 

## Usar Pipenv

 

Desde la consola del sistema entra dentro de un proyecto que tengas o crea uno nuevo como se sugiere en el siguiente cuadro.

 

### **Ejemplo que usaré a continuación**

 

Para ver su uso claramente vamos a suponer que tenemos una carpeta que he llamado “mi_proyecto” (si estás empezando crea una carpeta vacía, o una que tengas que sea tu proyecto con tus scripts de Python) y accede dentro de esta carpeta.

 

Para el ejemplo podemos crear un directorio vacío con (funciona en cualquier sistema operativo):

 

```bash
mkdir mi_proyecto
```

 

Y entramos dentro (para, en el siguiente punto, crear el entorno virtual exclusivo para esta carpeta y su contenido):

 

```bash
cd mi_proyecto
```

 

 

### Crear un entorno virtual

 

**Crear un entorno virtual exclusivo para un proyecto** (ir a la carpeta principal del proyecto y ejecutar) con:

 

```bash
pipenv install
```

 

En **Linux/Mac** verás algo así:

 

![Captura de la terminal en Linux/Mac al ejecutar pipenv install, con la ruta del entorno virtual creado resaltada](https://jarroba.com/wp-content/uploads/2020/09/Ejemplo-de-crear-un-entorno-virtual-de-Python-con-Pipenv-www.Jarroba.com_-1024x293.png)

 

En **Windows** funciona exactamente igual:

 

![Captura de la consola de Windows al ejecutar pipenv install, con la ubicación del entorno virtual resaltada](https://jarroba.com/wp-content/uploads/2020/09/Ejemplo-de-crear-un-entorno-virtual-de-Python-con-Pipenv-en-Windows-www.Jarroba.com_-1024x291.png)

 

Cuando se cree el entorno virtual, automáticamente **se nombrará con el nombre de la carpeta raíz seguido de un identificador y se guardará en** (en la imagen he marcado con un recuadro dorado la ruta donde se te habrá creado el entorno virtual):

 
- En **Linux/Mac**: /home/<USUARIO>/.local/share/virtualenvs/
- En **Windows**: C:\Users\<USUARIO>\.virtualenvs\

 

### ****Consultar todos los entornos virtuales creados con Pipenv****

 

Podremos listar todos los entornos virtuales creados con:

 

```bash
pipenv --venv
```

 

**Esto liberará nuestro proyecto de código y de ficheros que no se deben compartir/distribuir**; en su lugar creará dos ficheros con los “requisitos del entorno virtual exclusivo” dentro de nuestro proyecto que **sí se deben compartir/distribuir: “Pipfile.lock” y “Pipfile”**.

 

Estos dos **ficheros “Pipfile.lock” y “Pipfile” son los requisitos de nuestro proyecto con la configuración del entorno virtual exclusivo**; que los creó Pipenv al crear el entorno virtual, en un futuro los completará cuando instalemos dependencias (añadirá un par de líneas con la información del paquete que instalemos, como su nombre y la versión), los podremos modificar para cambiar la configuración a mano (como cambiar la versión de Python), y en última instancia podremos regenerar desde ellos el entorno virtual (tanto si algo falla del entorno virtual para poder recrearlo, así como para copiar/mover nuestro proyecto a otra máquina para crear el entorno virtual con exactamente la configuración necesaria para que nuestro proyecto funcione). Aunque explicaré estos dos ficheros con detalle más adelante, para que se vea como guarda los paquetes que deseemos instalar, sugiero que los abras y les eches un vistazo rápido.

 

 

### Activar un entorno virtual

 

Para **activar el entorno virtual** (estando en la misma raíz del proyecto a donde creamos el entorno virtual; es decir, en la misma ruta donde están los dos ficheros de requisitos “Pipfile.lock” y “Pipfile”):

 

```bash
pipenv shell
```

 

Para mi caso al activar el entorno virtual me aparecerá delante de la ruta “(mi_proyecto)” para indicar que se ha activado correctamente (si te fijas, Pipenv ha llamado automáticamente al “activate” de Virtualenv; es decir, lo mismo que hicimos antes, pero gestionado con Pipenv):

 

![Captura de la terminal con pipenv shell; el prompt muestra (mi_proyecto), indicando que el entorno está activado](https://jarroba.com/wp-content/uploads/2020/09/Activar-entorno-virtual-de-Python-exclusivo-con-Pipenv-www.Jarroba.com_.png)

 

 

### Instalar dependencias (paquetes) en un entorno virtual

 

Para **instalar paquetes de Python desde el repositorio de PIP** ([PyPI · The Python Package Index](https://pypi.org/); en el siguiente ejemplo instalaré el paquete sorted-in-disk, instala el que quieras para probar, parecido a como hice en [el artículo Entornos virtuales de Python: común y Anaconda](https://jarroba.com/entornos-virtuales-de-python-comun-y-anaconda/)):

 

```bash
pip install sorted-in-disk
```

 

**Nota para agilizar la instalación de un entorno virtual con uno o varios paquetes:** La ventaja de utilizar el comando de la instalación del entorno virtual es que se puede aprovechar a instalar algún paquete con PIP a la que creamos el entorno virtual (este comando crea el entorno virtual si no existe y luego los paquetes desde el repositorio de PIP):

 

```bash
pipenv install <PAQUETE1> <PAQUETE2> <PAQUETEN>
```

 

Para mi ejemplo los paquetes se instalarán dentro de la carpeta “lib” que está dentro del entorno virtual exclusivo de mi proyecto:

 
- **Linux/Mac:** /home/<USUARIO>/.local/share/virtualenvs/mi_proyecto-OFFUWq_4/lib/python3.8/
- **Windows:**c:\users\<USUARIO>\.virtualenvs\mi_proyecto-jr0nmums\lib\site-packages\

 

**Para ver todos los paquetes** (con sus dependencias) instaladas por PIP los podemos listar con:

 

```bash
pip list --local
```

 

O también con:

 

```bash
pipenv graph
```

 

En la siguiente imagen muestro un ejemplo de ambos:

 

![Captura de pip list --local y pipenv graph mostrando los paquetes instalados, con sorted-in-disk resaltado](https://jarroba.com/wp-content/uploads/2020/09/Ver-los-paquetes-instalados-en-el-entorno-virtual-de-Python-exclusivo-con-Pipenv-www.Jarroba.com_.png)

 

Aquí como podremos utilizar Python aislado en este entorno virtual:

 

```bash
python
```

 

Y probar a escribir código para ver que funciona, probar los paquetes instalados, escribir ficheros y ejecutarlos, etc. Vamos lo normal en Python 😉

 

En la siguiente imagen pruebo el mismo código Python que usé en [el artículo Entornos virtuales de Python: común y Anaconda](https://jarroba.com/entornos-virtuales-de-python-comun-y-anaconda/) bajo este entorno virtual gestionado por Pipenv:

 

![Captura de Python en el entorno de Pipenv ejecutando código que importa sorted_in_disk y ordena una lista](https://jarroba.com/wp-content/uploads/2020/09/Ejemplo-de-codigo-ejecutado-en-Python-con-el-entorno-virtual-creado-con-Pipenv-www.Jarroba.com_.png)

 

 

### Desactivar un entorno virtual

 

Y para **desactivar el entorno virtual** simplemente escribimos:

 

```bash
exit
```

 

**Nota sobre el comando “deactivate”:** a fecha de creación de este artículo el comando “deactivate” no funcionaba correctamente, desactivando parcialmente el entorno virtual (parece que desactiva la parte de Virtualenv, pero no la gestionada por Pipenv; así que para que se entere Pipenv usa mejor “exit” y que sea quien gestione la desactivación del entorno virtual).

 

 

### Eliminar un entorno virtual

 

Para **eliminar el entorno virtual** (solo elimina la carpeta con el entorno virtual en la carpeta “virtualenvs”; no elimina los ficheros de requerimientos “Pipfile.lock” y “Pipfile”):

 

```bash
pipenv --rm
```

 

**Nota sobre los ficheros “Pipfile.lock” y “Pipfile”:** quedan sin eliminar para futuras reinstalaciones y porque es parte de la información del proyecto. Si quieres eliminarlos puedes hacerlo a mano con:

 

```bash
rm Pipfile Pipfile.lock
```

 

 

## **Ficheros de requisitos “Pipfile.lock” y “Pipfile”**

 

Los ficheros **“Pipfile.lock” y “Pipfile”** son los ficheros de requisitos **donde se guarda la configuración completa del entorno virtual de Python** (Virtualenv) **gestionado por Pipenv**.

 

Estos **serán muy útiles si en un futuro copiamos/distribuimos la carpeta de nuestro proyecto que contenga estos dos ficheros a cualquier otra máquina** (otro ordenador u otro servidor), y si volvemos a ejecutar el comando en esa otra máquina:

 

```bash
pipenv install
```

 

Se regenerará el entorno virtual de Python exclusivo para este proyecto con dichos requisitos (con los paquetes instalados, con la versión de Python necesaria, etc.) y para esa otra máquina (si la máquina tiene alguna peculiaridad, se usará el Python global previamente configurado y funcionando en esa máquina, por lo que nos aseguramos de que funcionará); de este modo, nuestro proyecto funcionará perfectamente en esa otra máquina.

 

“**Pipfile**” contiene información general (explico los que vienen por defecto):

 
- **[source]**: desde donde se conecta PIP para descargar los paquetes (se podría configurar para que descargue los paquetes de un repositorio privado de una empresa, por ejemplo).
- **[dev-packages]**: los paquetes que sean exclusivos para el desarrollo (como los paquetes para realizar test, para comprobar rendimiento, de recogida de logs, etc.). Estos paquetes se pueden excluir para cuando tengamos una versión de nuestro proyecto para ser lanzada (release).
- **[packages]**: los paquetes que queremos utilizar en nuestro proyecto y que serán incluidos en la versión lanzada (release).
- **[requires]**: nos permitirá cambiar la versión de Python si lo deseamos cambiando el número de versión en “python_version” (siempre y cuando tengamos el Python global con la versión deseada; es decir, por defecto toma la última versión instalada que en mi caso es Python 3.8, si queremos que nos funcione con Python 2 pues debemos tener instalado como global Python 2).

 

```ini
[[source]]
name = "pypi"
url = "https://pypi.org/simple"
verify_ssl = true

[dev-packages]

[packages]
sorted-in-disk = "*"

[requires]
python_version = "3.8"
```

 

Podemos modificar a mano cualquier cosa, por ejemplo, la versión de Python, guardaríamos el fichero y es importante eliminar el entorno virtual (si no lo hacemos nos mostrará un mensaje de advertencia) con:

 

```bash
pipenv --rm
```

 

Y lo volvemos a crear con:

 

```bash
pipenv install
```

 

El fichero de requisitos más importante es “Pipfile”, con este fichero Pipenv generará el entorno virtual (al ejecutar “pipenv install” si no existe uno previo generará un fichero “Pipfile” por defecto; si existe, lo leerá y aplicará dicha configuración) y creará el fichero “Pipfile.lock” (lo mismo, si no existe se creará y si existe se leerá). El fichero “Pipfile.lock” es también importante para nuestro proyecto ya que definirá las versiones concretas con las que funcionará nuestro proyecto; es decir, nos asegurará una configuración en concreto (“bloqueará una configuración”, por eso lo de “lock”), para que no se cambien las versiones (principalmente para que no se actualicen las versiones de paquetes o Python) si copiamos/distribuimos nuestro proyecto y por ello nos aseguramos que funcione correctamente en cualquier máquina.

 

“**Pipfile.lock**” no debería ser modificado a mano, mejor regenerarlo desde “Pipfile”, contiene información parecida a la siguiente en formato JSON:

 

```json
{
    "_meta": {
        "hash": {
            "sha256": " 0123456789abcdf0123456789abcdf0123456789abcdf0123456789abcdf0123"
        },
        "pipfile-spec": 6,
        "requires": {
            "python_version": "3.8"
        },
        "sources": [
            {
                "name": "pypi",
                "url": "https://pypi.org/simple",
                "verify_ssl": true
            }
        ]
    },
    "default": {
        "easy-binary-file": {
            "hashes": [
                "sha256: 0123456789abcdf0123456789abcdf0123456789abcdf0123456789abcdf0123",
                "sha256: 0123456789abcdf0123456789abcdf0123456789abcdf0123456789abcdf0123"
            ],
            "markers": "python_version >= '3.0'",
            "version": "==1.0.4"
        },
        "quick-queue": {
            "hashes": [
                "sha256: 0123456789abcdf0123456789abcdf0123456789abcdf0123456789abcdf0123",
                "sha256: 0123456789abcdf0123456789abcdf0123456789abcdf0123456789abcdf0123"
            ],
            "markers": "python_version >= '3.0'",
            "version": "==1.0.5"
        },
        "sorted-in-disk": {
            "hashes": [
                "sha256: 0123456789abcdf0123456789abcdf0123456789abcdf0123456789abcdf0123",
                "sha256: 0123456789abcdf0123456789abcdf0123456789abcdf0123456789abcdf0123"
            ],
            "index": "pypi",
            "version": "==1.0.3"
        }
    },
    "develop": {}
}
```

 

Si echas un vistazo rápido a este fichero verás el paquete que he instalado (en este caso encontrarás “sorted-in-disk”), sus dependencias (si las tiene) y lo más importante, la versión concreta (para “sorted-in-disk” se lee *“version”: “==1.0.3”*), entre otra información como hashes, etc. Como indiqué antes y aunque tiente cambiar aquí las versiones, todo este JSON creado por “Pipfile.lock” no deberíamos tocarlo (pero sí guardarlo); si quieres modificar algo mejor tocar “Pipfile” y recrear este fichero “Pipfile.lock” con el comando “pipenv install”.

 

Tanto **“Pipfile.lock” como “Pipfile” son parte imprescindible del proyecto por lo que deberían ser incluidos en un control de versiones** (un repositorio como Git).

 

 

## Bibliografía

 

- [pipenv: Python Development Workflow for Humans (PyPI)](https://pypi.org/project/pipenv/)
- [github.com/pypa/pipenv](https://github.com/pypa/pipenv)
- [Pipenv: Python Dev Workflow for Humans (pipenv docs)](https://docs.pipenv.org/)
- [stackoverflow.com/questions/41573587/what-is-the-difference-between-venv-pyvenv-pyenv-virtualenv-virtualenvwrappe?rq=1](https://stackoverflow.com/questions/41573587/what-is-the-difference-between-venv-pyvenv-pyenv-virtualenv-virtualenvwrappe?rq=1)

## Serie: Entornos de Python

1. [Entornos de Python: común y Anaconda (base)](https://jarroba.com/entornos-de-python-anaconda-y-comun.md)
2. [Entornos virtuales de Python: común y Anaconda](https://jarroba.com/entornos-virtuales-de-python-comun-y-anaconda.md)
3. [Pipenv: gestor de entornos virtuales de Python](https://jarroba.com/pipenv-gestor-de-entornos-virtuales-de-python.md)