Por qué debería usar pyenv + Pipenv para sus proyectos de Python

La guía que falta para configurar un excelente flujo de trabajo de desarrollo local para sus proyectos de Python.

Esta es una forma obstinada de desarrollar con Python localmente. Probablemente haya descubierto que es una molestia administrar diferentes proyectos con dependencias dirigidas a diferentes versiones de Python en su máquina local.

Para complicar las cosas, también hay varias formas de instalar Python:

• Preinstalación por el SO 😔
• Usando un administrador de paquetes como brew o apt 😕
• Usando los binarios de 😫
• Usando : una forma fácil de instalar y administrar las instalaciones de Python 😎

Esta guía usa para administrar las instalaciones de Python y para administrar las dependencias del proyecto (en lugar de pip sin procesar).

Instalando pyenv

Instalemos a través de brew :

$ brew instalar pyenv

Si no está en Mac, consulte las de pyenv .

Agregue lo siguiente a su ~/.bash_profile , o ~/.bashrc (dependiendo de su shell) para inicializar automáticamente pyenv cuando se carga su terminal:

eval "$(iniciar pyenv -)"

¿Cómo funciona pyenv?

Ver todas las versiones de Python disponibles:

 $ pyenv install --list

Instalemos Python 3.6.6

$ pyenv instalar 3.6.6

Python-3.6.6 instalado en /Users/dvf/.pyenv/versions/3.6.6 pyenv no cambiará su intérprete global a menos que se lo indique:

$ python --versión

Pitón 2.7.14

$pyenv global 3.6.6

Pitón 3.6.6

pyenv le permite instalar diferentes versiones de Python localmente en un directorio. Vamos a crear un proyecto dirigido a Python 3.7.0:

$ pyenv instalar 3.7.0

Python-3.7.0 instalado en /Users/dvf/.pyenv/versions/3.7.0

$ mkdir mi_proyecto && cd mi_proyecto$ python --version

Pitón 3.6.6

$ pyenv local 3.7.0$ python --versión

Pitón 3.7.0

Ahora, cada vez que te encuentres en my_project , usarás automáticamente el intérprete de Python 3.7.0.

🤚 ¿Eso tuvo sentido? Si no, deténgase aquí y tómese un tiempo para jugar con pyenv; funciona instalando todos los intérpretes de Python en ~/.pyenv y ajustando dinámicamente su $PATH según su directorio actual.

¿Qué es Pipenv y cómo funciona?

es la forma recomendada oficialmente de administrar las dependencias del proyecto. En lugar de tener un archivo requirements.txt en su proyecto y administrar entornos virtuales, ahora tendrá un Pipfile en su proyecto que hace todo esto automáticamente.

Comience por instalarlo a través de pip , es un proyecto que evoluciona rápidamente, así que asegúrese de tener la última versión (2018.10.13 en el momento de escribir este artículo):

$ instalación pip -U pipenv

Usando Pipenv por primera vez

Configuremos Pipenv en su proyecto:

$ cd mi_proyecto $ pipenv instalar

Creando un virtualenv para este proyecto... Pipfile: /Usuarios/dvf/mi_proyecto/Pipfile Usando /Users/dvf/.pyenv/versions/3.7.0/bin/python3.7 (3.7.0) para crear virtualenv...

Encontrará dos archivos nuevos en su proyecto: Pipfile y Pipfile.lock .

Si está instalando en un proyecto preexistente, Pipenv convertirá sus requirements.txt anteriores.txt en un Pipfile . ¿Cuan genial es eso?

Así es como debería verse tu Pipfile para un proyecto nuevo:

[[fuente]]url = "//pypi.org/simple"verify_ssl = truename = "pypi" [paquetes] [paquetes de desarrollo]

[requiere] python_version = "3.7"

Tenga en cuenta que no activamos ningún entorno virtual aquí , Pipenv se encarga de los entornos virtuales por nosotros. Entonces, instalar nuevas dependencias es simple:

$ pipenv instalar django

Instalando django...

Instalación de paquetes recopilados: pytz, django Django-2.1.2 instalado con éxito pytz-2018.5

Agregar django a los [paquetes] de Pipfile... Pipfile.lock (4f9dd2) desactualizado, actualizar a (a65489)... Bloquear dependencias de [paquetes de desarrollo]... Bloquear dependencias de [paquetes]... ¡Pipfile.lock actualizado (4f9dd2)! Instalando dependencias desde Pipfile.lock (4f9dd2)… 🐍 ▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉ 2/2 — 00:00:01

Para activar virtualenv de este proyecto, ejecute pipenv shell. Alternativamente, ejecute un comando dentro de virtualenv con pipenv run.

Si inspecciona su Pipfile , notará que ahora contiene django = "*" como una dependencia.

Si quisiéramos instalar dependencias de desarrollo para usar durante el desarrollo, por ejemplo, , agregaría --dev al paso de instalación:

$ instalación de pipenv --dev yapf

¿Qué es **Pipfile.lock** ?

Pipfile.lock es muy importante porque hace dos cosas:

1. Proporciona buena seguridad al mantener un hash de cada paquete instalado.
2. Fija las versiones de todas las dependencias y subdependencias, brindándole entornos replicables.

Veamos cómo se ve actualmente:

{"_meta": {"hash": {"sha256": "627ef89...64f9dd2"},"pipfile-spec": 6,"requiere": {"python_version": "3.7"},"fuentes": [{"nombre": "pypi","url": " ","verify_ssl": true}]},"predeterminado": {"django": {"hashes": [ "sha256:acdcc1...ab5bb3","sha256:efbcad...d16b45"],"index": "pypi","version": "==2.1.2"},"pytz": {"hashes" : ["sha256:a061aa...669053","sha256:ffb9ef...2bf277"],"versión": "==2018.5"}},"desarrollar": {}}

Observe que las versiones de cada dependencia están ancladas. Sin una muy buena razón, siempre querrá que este archivo se confirme en su control de código fuente.

Índices personalizados

Hasta Pipenv, era difícil usar repositorios privados de Python, por ejemplo, si desea alojar bibliotecas privadas de Python dentro de su organización. Ahora todo lo que necesita hacer es definirlos como fuentes adicionales en el Pipfile :

 [[source]]url = "//pypi.org/simple"verify_ssl = truename = "pypi"[[source]]url = "//www.example.com"verify_ssl = truename = "some-repo-name"[packages]django = "*"my-private-app = {version="*", index="some-repo-name"}[dev-packages][requires]python_version = "3.7"

Tenga en cuenta que le dijimos a my-private-app que use el repositorio privado. Si se omite, Pipenv recorrerá los índices hasta que encuentre el paquete.

💡Pipenv también consumirá cualquier variable de entorno en valores , lo cual es útil si tiene credenciales confidenciales que no quiere sentarse en el control de fuente (esta fue mi contribución _</humblebrag>_ )

Desplegando

Al implementar, es importante que su implementación falle si hay una discrepancia entre las dependencias instaladas y el Pipfile.lock . Por lo tanto, debe agregar --deploy a su paso de instalación que hace precisamente eso:

 $ pipenv install --deploy

También puede verificar qué dependencias no coinciden:

 $ pipenv check

Y vea qué subdependencias están instaladas por paquetes:

$ gráfico pipenv --reverse

pip==18.1 pitz==2018.5

• 
  

  
  

  
  

  Django 2.1.2 [requiere: pytz]**setuptools 40.4.3** rueda==0.32.2 yapf==0.24.0

Comandos únicos, scripts y venvs de activación

Si está desarrollando activamente un proyecto, es útil activar el entorno virtual:

 $ pipenv shell Launching subshell in virtual environment…

O, si desea ejecutar un comando dentro del venv:

 $ pipenv run python manage.py runserver

También puede agregar secuencias de comandos a Pipfile similares a npm package.json :

[[fuente]]url = " "verify_ssl = truename = "pypi"

[paquetes]django = "*"

[paquetes de desarrollo] yapf = "*"

[scripts]servidor = "python manage.py runserver"

[requiere] python_version = "3.7" Ahora puedes ejecutar el script:

$ pipenv ejecutar servidor

Acabamos de tocar la punta del iceberg. Si desea obtener más información sobre Pipenv, lo animo a leer la .

Espero que esto haya sido útil para usted. ¡Y me encantaría escuchar cualquier idea o sugerencia que tengas en los comentarios!