Categorías
Python

Programación funcional en Python

 

Tabla de Contenidos

  • Versiones entendimiento Python y acoplable
  • Usando DockerInstalling DockerRunning ContainersBuilding sus propias imágenes Uso de Dockerfiles
  • Instalación acoplable
  • Operando Contenedores
  • construcción de su propio de imágenes mediante Dockerfiles
  • Operando Python en un estibador ContainerPlaying Con la REPLSetting hasta las secuencias de comandos de Python EnvironmentRunning Python usando DockerRunning el último Juego de Alfa
  • Con el REPL
  • Configuración del pitón Medio Ambiente
  • ejecutar secuencias de comandos Python usando acoplable
  • ejecutando la última Alfa
  • Conclusión
  • lectura adicional
  • Instalación acoplable
  • Ejecución de contenedores
  • construcción de su propio de imágenes mediante Dockerfiles
  • jugar con el REPL
  • Configuración del Medio Ambiente Python
  • ejecutar secuencias de comandos Python usando acoplable
  • la Ejecución de la prueba Alfa

Siempre hay una nueva versión de Python en fase de desarrollo. Sin embargo, puede ser engorroso para compilar Python sí mismo para probar una nueva versión! A medida que trabaja a través de este tutorial, verás cómo ejecutar diferentes versiones de Python usando acoplable , incluyendo cómo se puede tener la última alpha abierta en su ordenador en cuestión de minutos.

En este tutorial, aprenderá: versiones

  • cuál de Python están disponibles
  • ¿Cómo empezar con acoplable
  • Cómo ejecutar diferentes versiones de Python en acoplable contenedores
  • Cómo utilizar recipientes Docker como Python get entornos

Vamos a empezar! Bono

gratuito: Haga clic aquí para obtener acceso a un capítulo de trucos Python: El libro que te muestra las mejores prácticas de Python con ejemplos sencillos puede aplicar instantáneamente a escribir código más bonito + Pythonic.

Conocimiento de las versiones de Python y acoplable

El largo viaje de pasar de 2 a Python Python 3 está llegando a su fin. Aún así, es importante que en el futuro, usted sabe sobre las diferentes versiones de Python y cómo probarlos. En general, hay tres tipos diferentes de versiones se debe tener en cuenta: las versiones

Lanzamiento: Por lo general, se le ejecuta algo así como Python 3.6, 3.7, o 3.8. Cada una de estas versiones añade nuevas características, por lo que es bueno ser consciente de qué versión se está ejecutando. Por ejemplo, se introdujeron f-cadenas en Python 3.6 y no funcionará en versiones anteriores de Python. Del mismo modo, las expresiones de asignación no estuvieron disponibles en Python 3.8. versiones

de desarrollo: La comunidad Python está trabajando constantemente en nuevas versiones de Python. En el momento de escribir estas líneas, Python 3.9 está en desarrollo. Para previsualizar y probar nuevas características, los usuarios tienen acceso a las versiones de desarrollo etiquetados alfa , beta y versión candidata .

Implementaciones: Python es un lenguaje que tiene varias implementaciones. Una implementación de Python contiene un intérprete y la correspondiente bibliotecas . CPython es la implementación de referencia de Python y el que se utiliza más comúnmente. Sin embargo, existen otras implementaciones como PyPy, IronPython, Jython, MicroPython y CircuitPython que los casos de uso específicos cubierta.

Por lo general, se ve la versión de Python que está utilizando cuando se inicia un REPL. También puede inspeccionar sys.implementation para más información:

>>> import sys
>>> sys.implementation.name
'cpython'

>>> sys.implementation.version
sys.version_info(major=3, minor=9, micro=0, releaselevel='alpha', serial=1)

Se puede ver que este código se ejecuta la primera versión alfa de CPython 3.9.

Tradicionalmente, tendrá que utilizar herramientas como pyenv y Conda para gestionar diferentes versiones de Python. Acoplable puede sustituir a éstos en la mayoría de los casos, y es a menudo más fácil de usar. En el resto de este tutorial, verás cómo empezar.

Usando acoplable

acoplable es una plataforma para el funcionamiento de los contenedores con las aplicaciones de envasados ​​previamente. Es un sistema muy potente que es particularmente popular para el envasado y el despliegue de aplicaciones y microservicios. En esta sección, verá los conceptos fundamentales que necesita saber para usar acoplable .

Instalación acoplable

acoplable está disponible en todos los principales sistemas operativos: Windows, MacOS y Linux. Ver la guía oficial para obtener instrucciones sobre cómo instalar acoplable en su sistema. A menos que tenga necesidades especiales, puede utilizar la ventana acoplable motor – versión Comunidad.

Ejecución de contenedores

acoplable utiliza los conceptos de imagen s y contenedor s. Una imagen es un paquete autónomo que puede ser ejecutado por el estibador. A recipiente es un funcionamiento imagen con un cierto estado. Hay varios depósitos que contienen la imagen del estibador pre-construidos s. Acoplable Hub es el repositorio predeterminado que se va a utilizar en este tutorial. Para un primer ejemplo, ejecute el hola-mundo de la imagen :

$ docker run hello-world
Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
1b930d010525: Pull complete
Digest: sha256:451ce787d12369c5df2a32c85e5a03d52cbcef6eb3586dd03075f3...
Status: Downloaded newer image for hello-world:latest

Hello from Docker!
This message shows that your installation appears to be working correctly.
[ ... Full output clipped ... ]

Las primeras líneas muestran que acoplable descargado hola-mundo desde acoplable concentradores. Cuando se ejecuta esta imagen, el contenedor resultante produce un «Hola desde acoplable!» mensaje que imprime a su terminal.

construcción de su propio de imágenes mediante Dockerfiles

Usted puede crear sus propias imágenes utilizando Dockerfiles , que es un archivo de texto plano que describe cómo una imagen del estibador se debe crear. El siguiente es un ejemplo de un Dockerfile:

1 FROM ubuntu
2 RUN apt update && apt install -y cowsay
3 CMD ["/usr/games/cowsay", "Dockerfiles are cool!"]

A Dockerfile consiste en una lista de comandos acoplables. En el ejemplo anterior, hay tres pasos:

  • Línea 1 bases de la imagen en una imagen existente llamado ubuntu. Usted puede hacer esto con independencia de qué sistema se está ejecutando en la ventana acoplable.
  • Línea 2 se instala un programa llamado cowsay.
  • Línea 3 prepara un comando que se ejecuta cuando se ejecuta cowsay la imagen.

Para utilizar este Dockerfile, guardarlo en un archivo de texto denominado Dockerfile, sin extensión de archivo.

Nota: Puede generar y ejecutar imágenes de Linux en cualquier plataforma, así como imágenes de Ubuntu son ideales para la creación de aplicaciones que deben estar disponibles multiplataforma.

Por el contrario, una imagen de Windows sólo se ejecutará en Windows y una imagen de macOS sólo se ejecutará en MacOS.

A continuación, construir una imagen de su Dockerfile:

$ docker build -t cowsay .

El comando dará un montón de salida como es la construcción de la imagen. cowsay -t etiquetará su imagen con el nombre cowsay. Puede utilizar etiquetas para realizar un seguimiento de sus imágenes. El punto final en el comando especifica el directorio actual como el contexto de construcción para su imagen. Este directorio debe ser el que contiene Dockerfile.

Ahora puede ejecutar su propia imagen acoplable:

$ docker run --rm cowsay
_______________________
< Dockerfiles are cool! >
-----------------------
\ ^__^
\ (oo)\_______
(__)\ )\/\
||----w |
|| ||

El –rm opción va a limpiar el contenedor después de su uso. Es un buen hábito de usar –rm para evitar llenar su sistema con contenedores de Docker rancios.

Nota: acoplable tiene varios comandos para la gestión de sus imágenes y contenedores. Se pueden listar sus imágenes y contenedores utilizando imágenes ventana acoplable y -a ventana acoplable ps, respectivamente.

Tanto las imágenes como los contenedores se les asigna un ID de 12 caracteres que se pueden encontrar en estos listados. Para eliminar una imagen o un contenedor, utilice uno ventana acoplable RMI o ventana acoplable rm con el ID correcto.

La línea de comandos ventana acoplable es muy potente. Uso –help cargador de muelle y la documentación oficial para más información.

Ejecución de Python en un estibador de contenedores

la ventana acoplable comunicados de la comunidad y mantiene Dockerfiles para todas las versiones nuevas de Python, que se puede utilizar para probar nuevas funciones Python. Además, los desarrolladores del núcleo de Python mantener una imagen acoplable con todas las versiones actualmente disponibles de Python. En esta sección, usted aprenderá cómo ejecutar diferentes versiones de Python en estibador.

jugar con el REPL

Cuando se ejecuta una imagen Pitón de estibador de concentradores, el intérprete está configurado para que pueda jugar con el REPL directamente. Para iniciar el REPL en un contenedor de Python, ejecute el siguiente comando:

$ docker run -it --rm python:rc
Python 3.8.0rc1 (default, Oct 2 2019, 23:30:03)
[GCC 8.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

Este comando descargará el pitón: Imagen del rc del estibador de concentradores, iniciar un contenedor, y correr pitón dentro de ese contenedor. Las opciones -it son necesarios para ejecutar el contenedor de forma interactiva. La etiqueta rc es la abreviatura de liberación candidato y apunta a la última versión de desarrollo de Python. En este caso, es la última versión candidata de Python 3.8:

>>> import sys
>>> f"{sys.version_info[:] = }"
"sys.version_info[:] = (3, 8, 0, 'candidate', 1)"

La primera vez que se ejecuta un contenedor, que puede tomar algún tiempo para descargar. invocaciones posteriores serán esencialmente inmediata. Puede salir del REPL como de costumbre, por ejemplo, por la salida de escribir (). Esto también sale del recipiente.

Nota: las imágenes la ventana acoplable Hub Python se mantienen razonablemente bien hasta a la fecha. Como las nuevas versiones maduran, sus versiones alfa y beta se ponen a disposición en la etiqueta rc.

Sin embargo, si quieres poner a prueba los absolutos últimas versiones de Python, a continuación, la imagen de los desarrolladores del núcleo podría ser una mejor apuesta:

$ docker run -it --rm quay.io/python-devs/ci-image:master

Verás unos cuantos ejemplos del uso de esta imagen posterior.

Puede encontrar una lista de todas las imágenes de Python disponibles en acoplable concentradores. Python: últimas siempre le dará la última versión estable de Python, mientras que Python: rc le proporcionará la versión más reciente desarrollo. También puede solicitar versiones específicas como Python: 3.6.3 o Python: 3.8.0b4, la cuarta versión beta de Python 3.8. Usted puede incluso funcionar PyPy usando una etiqueta como PyPy: últimas.

Configuración del contenedor de Python Medio Ambiente

Un estibador es un aislado ambiente . Por lo tanto, por lo general, no es necesario añadir un entorno virtual de el interior del contenedor. En su lugar, puede ejecutar directamente pip para instalar los paquetes necesarios. Para modificar el contenedor para incluir los paquetes adicionales, se utiliza un Dockerfile. El siguiente ejemplo añade analizar y realpython-lector a un contenedor de Python 3.7.5:

1 FROM python:3.7.5-slim
2 RUN python -m pip install \
3 parse \
4 realpython-reader

Guardar este archivo con el nombre Dockerfile. La etiqueta -Slim en la línea 1 apunta a una Dockerfile basa en una instalación mínima Debian. Esta etiqueta da una imagen de Docker significativamente más delgada, pero el inconveniente es que puede que tenga que instalar más herramientas adicionales a sí mismo.

Otras designaciones incluyen -alpine y -windowsservercore. Puede encontrar más información acerca de estas variantes de imagen en acoplable concentradores.

Nota: Si desea utilizar un entorno virtual dentro de un contenedor del estibador, entonces no es una advertencia que debe tener en cuenta. Cada orden de marcha se ejecuta en un proceso separado, lo que significa que la activación típico de un entorno virtual no funcionarán dentro de un Dockerfile.

su lugar, se debe activar manualmente el entorno virtual mediante el establecimiento de las variables de entorno PATH y VIRTUAL_ENV:

FROM python:3.7.5-slim

# Set up and activate virtual environment
ENV VIRTUAL_ENV "/venv"
RUN python -m venv $VIRTUAL_ENV
ENV PATH "$VIRTUAL_ENV/bin:$PATH"

# Python commands run inside the virtual environment
RUN python -m pip install \
parse \
realpython-reader

Ver Elegantemente la activación de un virtualenv en un Dockerfile para más información.

Para crear y ejecutar el Dockerfile, utilice los siguientes comandos:

$ docker build -t rp .
[ ... Output clipped ... ]

$ docker run -it --rm rp

A medida que construye la imagen, se etiqueta con el nombre RP. Este nombre se utiliza cuando se ejecuta la imagen, iniciar una nueva sesión REPL. Puede confirmar que de análisis se ha instalado en el contenedor:

>>> import parse
>>> parse.__version__
'1.12.1'

También puede iniciar recipientes que los comandos de ejecución personalizados:

$ docker run --rm rp realpython
The latest tutorials from Real Python (https://realpython.com/)
0 Run Python Versions in Docker: How to Try the Latest Python Release
[ ... Full output clipped ... ]

En lugar de comenzar un REPL, esto se ejecuta el comando realpython el interior del contenedor rp, que las listas publicadas los últimos tutoriales en real Python. Para obtener más información sobre el paquete realpython-lector, echa un vistazo a Cómo publicar un paquete de Python de código abierto a PyPI.

ejecutar secuencias de comandos Python usando acoplable

En esta sección, verá cómo ejecutar secuencias de comandos en el interior del estibador. En primer lugar, excepto el ejemplo siguiente secuencia de comandos a un archivo llamado headlines.py en su equipo:

# headlines.py

import parse
from reader import feed

tutorial = feed.get_article(0)
headlines = [
r.named["header"]
for r in parse.findall("\n## {header}\n", tutorial)
]
print("\n".join(headlines))

el guión primeras descargas desde el último tutorial real Python. A continuación, utiliza análisis sintáctico para encontrar todos los titulares en el tutorial y los imprime en la consola.

Hay dos formas generales para ejecutar secuencias de comandos como este en su contenedor acoplable:

La primera opción es especialmente útil durante las pruebas, ya que no es necesario para reconstruir su imagen acoplable cuando se realizan cambios en la secuencia de comandos. Para montar el directorio como un volumen, utilice la opción -v:

$ docker run --rm -v /home/realpython/code:/app rp python /app/headlines.py
Understanding Python Versions and Docker
Using Docker
Running Python in a Docker Container
Conclusion
Further Reading

La opción -v / home / realpython / código: / app dice que el directorio / home / realpython / código local debe ser montada como / aplicación dentro del contenedor . A continuación, puede ejecutar el script con el comando python /app/headlines.py.

Usted querrá copiar la secuencia de comandos en el contenedor si se va a desplegar su guión a otra máquina. Para ello, la adición de unos pasos a su Dockerfile:

FROM python:3.7.5-slim
WORKDIR /usr/src/app
RUN python -m pip install \
parse \
realpython-reader
COPY headlines.py .
CMD ["python", "headlines.py"]

Se establece un directorio de trabajo dentro de su contenedor a control donde se ejecutan los comandos. A continuación, puede copiar headlines.py a ese directorio de trabajo en el interior del contenedor, y cambiar el comando predeterminado para funcionar con headlines.py pitón. Reconstruir su imagen como de costumbre, y ejecutar el contenedor:

$ docker build -t rp .
[ ... Output clipped ... ]

$ docker run --rm rp
Understanding Python Versions and Docker
Using Docker
Running Python in a Docker Container
Conclusion
Further Reading

Tenga en cuenta que el script se ejecuta cuando se ejecuta el contenedor porque ha especificado el comando CMD en el Dockerfile.

Véase la descripción de la imagen Python en acoplable concentrador para obtener más información sobre la construcción de sus propios Dockerfiles.

ejecutando la última Alfa

Hasta ahora, usted ha estado tirando de las imágenes de estibador de concentradores, pero hay muchos depósitos de imágenes disponibles. Por ejemplo, muchos proveedores de nube como AWS, BPC y digitalocean ofrecen registros de contenedores dedicados. imagen Pitón

Los principales desarrolladores está disponible en Quay.io. Para utilizar imágenes de los repositorios no por defecto, se utiliza el nombre completamente calificado. Por ejemplo, puede ejecutar la imagen de los desarrolladores principales de la siguiente forma:

$ docker run -it --rm quay.io/python-devs/ci-image:master

Por defecto, esta se inicia una sesión de shell en el interior del contenedor. Desde la sesión de shell, puede ejecutar de forma explícita Python:

$ python3.9 -c "import sys; print(sys.version_info)"
sys.version_info(major=3, minor=9, micro=0, releaselevel='alpha', serial=1)

Se puede ver todas las versiones disponibles de Python mirando dentro de / usr / local / bin:

$ ls /usr/local/bin/
2to3 get-pythons.sh pydoc3.5 python3.7m
2to3-3.4 idle pydoc3.6 python3.7m-config
2to3-3.5 idle3.4 pydoc3.7 python3.8
2to3-3.6 idle3.5 pydoc3.8 python3.8-config
2to3-3.7 idle3.6 pydoc3.9 python3.9
2to3-3.8 idle3.7 python2.7 python3.9-config
2to3-3.9 idle3.8 python2.7-config pyvenv-3.4
codecov idle3.9 python3.4 pyvenv-3.5
coverage mypy python3.4m pyvenv-3.6
coverage-3.6 mypyc python3.4m-config pyvenv-3.7
coverage3 pip3.5 python3.5 smtpd.py
dmypy pip3.6 python3.5m stubgen
easy_install-3.5 pip3.7 python3.5m-config tox
easy_install-3.6 pip3.8 python3.6 tox-quickstart
easy_install-3.7 pip3.9 python3.6m virtualenv
easy_install-3.8 pydoc python3.6m-config
easy_install-3.9 pydoc3.4 python3.7

Esta imagen es especialmente útil si desea probar su código en varias Python versiones. La imagen acoplable se actualiza frecuentemente e incluye las últimas versiones de desarrollo de Python. Si usted está interesado en probar las últimas características de Python, incluso antes de que se lancen oficialmente, a continuación, esta imagen es una gran elección.

Conclusión

En este tutorial, usted ha visto una rápida introducción a trabajar con diferentes versiones de Python utilizando estibador. Esta es una gran manera de probar y ver que su código es compatible con las nuevas versiones de Python. Sólo se tarda unos pocos minutos para envolver la secuencia de comandos de Python en un recipiente acoplable, por lo que puede probar la última alfa, tan pronto como salga al mercado!

Ahora puede:

  • Iniciar una REPL Python a través del estibador
  • configurar el entorno de Python una imagen de estibador en el interior guiones
  • se ejecutan dentro de contenedores de Docker

A medida que prueban nuevas versiones de Python en estibador, estás proporcionar una ayuda inestimable para la comunidad Python. Si tienes alguna pregunta o comentario, por favor, dejarlos en la sección de comentarios.

Lectura adicional

Para obtener más información acerca del estibador, y en especial los flujos de trabajo para proyectos más grandes, echa un vistazo a Estibador en Acción – ajustador, más feliz y productiva.

También puede leer sobre otros ejemplos de trabajo con Python y estibador en los siguientes tutoriales:

  • Cómo hacer un Twitter Bot en Python Con Tweepy
  • Simplificando Desconectado Python implementaciones con acoplable
  • Django Desarrollo con acoplable Componer y máquina
  • desarrollo y despliegue de cookiecutter-Django través del estibador

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *