Comment essayer la dernière version de Python – Real Python – Formation Python, php, javascript et référencement web

Expert Python

Il y a toujours une nouvelle version de Python en cours de développement. Cependant, il peut être fastidieux de compiler Python vous-même pour essayer une nouvelle version! Au cours de ce didacticiel, vous verrez comment exécuter différentes versions de Python à l'aide de Docker, y compris la façon dont vous pouvez exécuter la dernière version alpha sur votre ordinateur en quelques minutes.

Dans ce didacticiel, vous apprendrez:

Lequel versions de Python sont disponibles
Comment débuter avec Docker
Comment exécuter différentes versions de Python dans Docker conteneurs
Comment utiliser les conteneurs Docker en Python environnements

Commençons!

Comprendre les versions Python et Docker

Le long voyage pour passer de Python 2 à Python 3 touche à sa fin. Pourtant, il est important qu'à l'avenir, vous connaissiez les différentes versions de Python et comment les essayer. En général, vous devez connaître trois types de versions différents:

Versions publiées: En règle générale, vous exécuterez quelque chose comme Python 3.6, 3.7 ou 3.8. Chacune de ces versions ajoute de nouvelles fonctionnalités, il est donc bon de savoir quelle version vous utilisez. Par exemple, les chaînes f ont été introduites dans Python 3.6 et ne fonctionneront pas dans les anciennes versions de Python. De même, les expressions d'affectation ne sont devenues disponibles que dans Python 3.8.
Versions de développement: La communauté Python travaille en permanence sur de nouvelles versions de Python. Au moment d'écrire ces lignes, Python 3.9 est en cours de développement. Pour prévisualiser et tester de nouvelles fonctionnalités, les utilisateurs ont accès aux versions de développement étiquetées alpha, bêta, et libérer le candidat.
Implémentations: Python est un langage qui a plusieurs implémentations. Une implémentation de Python contient un interprète et correspondant bibliothèques. CPython est l'implémentation de référence de Python et celle qui est la plus utilisée. Cependant, il existe d'autres implémentations comme PyPy, IronPython, Jython, MicroPython et CircuitPython qui couvrent des cas d'utilisation spécifiques.

Vous verrez généralement la version de Python que vous utilisez lorsque vous démarrez un REPL. Vous pouvez également inspecter sys.implementation pour plus d'informations:

>>>

>>> importation sys
>>> sys.la mise en oeuvre.prénom
'cpython'

>>> sys.la mise en oeuvre.version
sys.version_info (majeur = 3, mineur = 9, micro = 0, releaselevel = 'alpha', serial = 1)

Vous pouvez voir que ce code exécute la première version alpha de CPython 3.9.

Traditionnellement, vous utilisiez des outils comme pyenv et conda pour gérer différentes versions de Python. Docker peut les remplacer dans la plupart des cas, et il est souvent plus simple à utiliser. Dans la suite de ce didacticiel, vous verrez comment commencer.

Utilisation de Docker

Docker est une plate-forme pour exécuter des conteneurs avec des applications préemballées. Il s’agit d’un système très puissant particulièrement apprécié pour l’empaquetage et le déploiement d’applications et de microservices. Dans cette section, vous verrez les concepts fondamentaux que vous devrez connaître pour utiliser Docker.

Installation de Docker

Docker est disponible sur tous les principaux systèmes d'exploitation: Windows, macOS et Linux. Consultez le guide officiel pour savoir comment installer Docker sur votre système. Sauf si vous avez des besoins particuliers, vous pouvez utiliser la version Docker Engine – Community.

Exécution de conteneurs

Docker utilise les concepts d'images et de conteneurs. Un image est un package autonome qui peut être exécuté par Docker. UNE récipient est une image en cours d'exécution avec un certain état. Il existe plusieurs référentiels contenant des images Docker prédéfinies. Docker Hub est le référentiel par défaut que vous utiliserez dans ce didacticiel. Pour un premier exemple, exécutez le Bonjour le monde image:

$ docker run hello-world
Impossible de trouver l'image 'hello-world: latest' localement
dernier: Extraire de la bibliothèque / hello-world
1b930d010525: traction complète
Résumé: sha256: 451ce787d12369c5df2a32c85e5a03d52cbcef6eb3586dd03075f3 ...
Statut: Image plus récente téléchargée pour hello-world: dernière

Bonjour de Docker!
Ce message indique que votre installation semble fonctionner correctement.
[ ... Full output clipped ... ]

Les premières lignes montrent que Docker a téléchargé Bonjour le monde depuis Docker Hub. Lorsqu'il exécute cette image, le conteneur résultant produit un "Bonjour de Docker!" message qui s'imprime sur votre terminal.

Création de vos propres images à l'aide de Dockerfiles

Vous pouvez créer vos propres images en utilisant Dockerfiles, qui est un fichier en texte brut qui décrit comment une image Docker doit être configurée. Voici un exemple de Dockerfile:

    1 DE    Ubuntu
    2 COURIR mise à jour apt && installer apt -y cowsay
 3 CMD [[[["/ usr / games / cowsay", "Les Dockerfiles sont cool!"]

Un Dockerfile se compose d'une liste de commandes Docker. Dans l'exemple ci-dessus, il y a trois étapes:

Ligne 1 base l'image sur une image existante appelée Ubuntu. Vous pouvez le faire indépendamment du système sur lequel vous exécutez Docker.
Ligne 2 installe un programme nommé vache.
Ligne 3 prépare une commande qui s'exécute vache lorsque l'image est exécutée.

Pour utiliser ce Dockerfile, enregistrez-le dans un fichier texte nommé Dockerfile, sans aucune extension de fichier.

Remarque: Vous pouvez créer et exécuter des images Linux sur n'importe quelle plate-forme, donc des images comme Ubuntu sont parfaits pour créer des applications qui devraient être disponibles sur plusieurs plates-formes.

En revanche, une image Windows ne fonctionnera que sur Windows et une image macOS ne fonctionnera que sur macOS.

Ensuite, créez une image à partir de votre Dockerfile:

$ docker build -t cowsay.

La commande donnera beaucoup de sortie lors de la construction de l'image. -t cowsay marquera votre image avec le nom vache. Vous pouvez utiliser des balises pour garder une trace de vos images. Le dernier point de la commande spécifie le répertoire courant comme contexte de construction pour votre image. Ce répertoire doit être celui contenant Dockerfile.

Vous pouvez maintenant exécuter votre propre image Docker:

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

le --rm L'option nettoiera votre récipient après utilisation. C’est une bonne habitude d’utiliser --rm pour éviter de remplir votre système avec des conteneurs Docker périmés.

Remarque: Docker dispose de plusieurs commandes pour gérer vos images et conteneurs. Vous pouvez répertorier vos images et conteneurs à l'aide de images de docker et docker ps -a, respectivement.

Les images et les conteneurs se voient attribuer un ID à 12 caractères que vous pouvez trouver dans ces listes. Pour supprimer une image ou un conteneur, utilisez soit docker rmi ou docker rm avec l'ID correct.

le docker la ligne de commande est très puissante. Utilisation docker --help et la documentation officielle pour plus d'informations.

Exécution de Python dans un conteneur Docker

La communauté Docker publie et gère les fichiers Docker pour toutes les nouvelles versions de Python, que vous pouvez utiliser pour essayer de nouvelles fonctionnalités Python. De plus, les développeurs principaux de Python conservent une image Docker avec toutes les versions actuellement disponibles de Python. Dans cette section, vous apprendrez à exécuter différentes versions de Python dans Docker.

Jouer avec le REPL

Lorsque vous exécutez une image Python à partir de Docker Hub, l'interpréteur est configuré pour que vous puissiez jouer avec le REPL directement. Pour démarrer le REPL dans un conteneur Python, exécutez la commande suivante:

$ docker run -it --rm python: rc
Python 3.8.0rc1 (par défaut, 2 octobre 2019, 23:30:03)
[GCC 8.3.0]    sous linux
Tapez "aide", "copyright", "crédits" ou "licence" pour plus d'informations.
>>>

Cette commande va télécharger le python: rc l'image à partir de Docker Hub, démarrez un conteneur et exécutez python à l'intérieur de ce conteneur. le -il des options sont nécessaires pour exécuter le conteneur de manière interactive. le rc tag est un raccourci pour libérer le candidat et pointe vers la dernière version de développement de Python. Dans ce cas, il s'agit de la dernière version candidate de Python 3.8:

>>>

>>> importation sys
>>> F"sys.version_info[:] = "
"sys.version_info[:] = (3, 8, 0, "candidat", 1) "

La première fois que vous exécutez un conteneur, le téléchargement peut prendre un certain temps. Les invocations ultérieures seront essentiellement immédiates. Vous pouvez quitter le REPL comme d'habitude, par exemple en tapant sortie(). Cela quitte également le conteneur.

Remarque: Les images Docker Hub Python sont raisonnablement bien mises à jour. À mesure que les nouvelles versions arrivent à maturité, leurs versions alpha et bêta sont disponibles sur rc étiquette.

Cependant, si vous souhaitez tester les dernières versions absolues de Python, l'image des développeurs principaux pourrait être un meilleur pari:

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

Vous verrez plus d'exemples d'utilisation de cette image plus tard.

Vous pouvez trouver une liste de toutes les images Python disponibles sur Docker Hub. python: dernier vous donnera toujours la dernière version stable de Python, tandis que python: rc vous fournira la version de développement la plus récente. Vous pouvez également demander des versions spécifiques comme python: 3.6.3 ou python: 3.8.0b4, la quatrième version bêta de Python 3.8. Vous pouvez même exécuter PyPy en utilisant une balise comme pypy: dernier.

Configuration de votre environnement Python

Un conteneur Docker est un isolé environnement. Par conséquent, vous n'avez généralement pas besoin d'ajouter un environnement virtuel à l'intérieur du conteneur. Au lieu de cela, vous pouvez exécuter pépin directement pour installer les packages nécessaires. Pour modifier le conteneur pour inclure les packages supplémentaires, vous utilisez un Dockerfile. L'exemple suivant ajoute analyser et lecteur realpython vers un conteneur Python 3.7.5:

    1 DE    python: 3.7.5-slim
    2 COURIR installation de python -m pip 
    3         analyser 
    4         lecteur realpython

Enregistrez ce fichier sous le nom Dockerfile. le -svelte la balise de la ligne 1 pointe vers un Dockerfile basé sur une installation Debian minimale. Cette balise donne une image Docker considérablement plus mince, mais l'inconvénient est que vous devrez peut-être installer vous-même plus d'outils supplémentaires.

D'autres désignations incluent -alpin et -windowsservercore. Vous pouvez trouver plus d'informations sur ces variantes d'image sur Docker Hub.

Remarque: Si vous souhaitez utiliser un environnement virtuel à l'intérieur d'un conteneur Docker, alors vous devez être conscient d'une mise en garde. Chaque COURIR La commande s'exécute dans un processus distinct, ce qui signifie que l'activation typique d'un environnement virtuel ne fonctionnera pas à l'intérieur d'un Dockerfile.

Au lieu de cela, vous devez activer manuellement l'environnement virtuel en définissant le paramètre VIRTUAL_ENV et CHEMIN Variables d'environnement:

DE    python: 3.7.5-slim

# Configurer et activer l'environnement virtuel
ENV VIRTUAL_ENV "/ venv"
COURIR python -m venv $ VIRTUAL_ENV
ENV CHEMIN "$ VIRTUAL_ENV/poubelle:$ PATH"

# Les commandes Python s'exécutent à l'intérieur de l'environnement virtuel
COURIR installation de python -m pip 
        analyser 
        lecteur realpython

Voir Activation élégante d'un virtualenv dans un Dockerfile pour plus d'informations.

Pour créer et exécuter votre Dockerfile, utilisez les commandes suivantes:

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

$ docker run -it --rm rp

Encore une fois, cela démarrera une session REPL. Vous pouvez confirmer que analyser a été installé dans le conteneur:

>>>

>>> importation analyser
>>> analyser.__version__
«1.12.1»

Vous pouvez également démarrer des conteneurs qui exécutent des commandes personnalisées:

$ docker run --rm rp realpython
Les derniers tutoriels de Real Python (https://realpython.com/)
        0 Exécutez les versions Python dans Docker: comment essayer la dernière version Alpha
[ ... Full output clipped ... ]

Au lieu de démarrer un REPL, cela exécute le realpython commande à l'intérieur du rp conteneur, qui répertorie les derniers didacticiels publiés sur Vrai Python. Pour plus d'informations sur le lecteur realpython , consultez Comment publier un package Python Open-Source sur PyPI.

Exécution de scripts Python à l'aide de Docker

Dans cette section, vous verrez comment exécuter des scripts dans Docker. Tout d'abord, enregistrez l'exemple de script suivant dans un fichier nommé headlines.py sur ton ordinateur:

# headlines.py

importation analyser
de lecteur importation alimentation

Didacticiel = alimentation.get_article(0)
titres = [[[[
    r.nommé[[[["entête"]
    pour r dans analyser.Trouver tout(" n## entête n", Didacticiel)
]
impression(" n".joindre(titres))

Le script télécharge d'abord le dernier didacticiel depuis Vrai Python. Ensuite, il utilise analyser pour trouver tous les titres dans le didacticiel et les imprimer sur la console.

Il existe deux façons générales d'exécuter des scripts comme celui-ci dans votre conteneur Docker:

Monter un répertoire local en tant que volume dans le conteneur Docker.
Copie le script dans le conteneur Docker.

La première option est particulièrement utile pendant les tests, car vous n'avez pas besoin de reconstruire votre image Docker lorsque vous apportez des modifications à votre script. Pour monter votre répertoire en tant que volume, utilisez le -v option:

$ docker run --rm -v / home / realpython / code: / app rp python /app/headlines.py
Comprendre les versions Python et Docker
Utilisation de Docker
Exécution de Python dans un conteneur Docker
Conclusion
Lectures complémentaires

L'option -v / home / realpython / code: / app dit que le répertoire local / home / realpython / code doit être monté comme / app à l'intérieur du conteneur. Vous pouvez ensuite exécuter le script avec la commande python /app/headlines.py.

Vous voudrez copier votre script dans votre conteneur si vous allez déployer votre script sur une autre machine. Pour ce faire, ajoutez quelques étapes à votre Dockerfile:

DE    python: 3.7.5-slim
WORKDIR    / usr / src / app
COURIR installation de python -m pip 
        analyser 
        lecteur realpython
COPIE headlines.py.
CMD [[[["python", "headlines.py"]

Vous définissez un répertoire de travail à l'intérieur de votre conteneur pour contrôler où les commandes sont exécutées. Vous pouvez ensuite copier headlines.py dans ce répertoire de travail à l'intérieur du conteneur et modifiez la commande par défaut à exécuter headlines.py avec python. Reconstruisez votre image comme d'habitude et exécutez le conteneur:

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

$ docker run --rm rp
Comprendre les versions Python et Docker
Utilisation de Docker
Exécution de Python dans un conteneur Docker
Conclusion
Lectures complémentaires

Notez que votre script est exécuté lorsque vous exécutez le conteneur car vous avez spécifié le CMD dans le Dockerfile.

Voir la description de l'image Python sur Docker Hub pour plus d'informations sur la création de vos propres Dockerfiles.

Exécution de la dernière version Alpha

Jusqu'à présent, vous avez extrait des images de Docker Hub, mais de nombreux référentiels d'images sont disponibles. Par exemple, de nombreux fournisseurs de cloud comme AWS, GCP et DigitalOcean proposent des registres de conteneurs dédiés.

L'image Python des développeurs principaux est disponible sur Quay.io. Pour utiliser des images provenant de référentiels autres que ceux par défaut, vous utilisez le nom complet qualifié. Par exemple, vous pouvez exécuter l'image des développeurs principaux comme suit:

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

Par défaut, cela démarre une session shell à l'intérieur du conteneur. Depuis la session shell, vous pouvez exécuter explicitement Python:

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

Vous pouvez voir toutes les versions disponibles de Python en regardant à l'intérieur / usr / local / bin:

$ ls / usr / local / bin /
2to3 get-pythons.sh pydoc3.5 python3.7m
2to3-3.4 pydoc3.6 inactif 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
couverture mypy python3.4m pyvenv-3.6
couverture-3,6 mypyc python3.4m-config pyvenv-3.7
couverture3 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

Cette image est particulièrement utile si vous souhaitez tester votre code sur plusieurs versions de Python. L'image Docker est souvent mise à jour et inclut les dernières versions de développement de Python. Si vous souhaitez découvrir les dernières fonctionnalités de Python, avant même leur sortie officielle, cette image est un excellent choix.

Conclusion

Dans ce didacticiel, vous avez vu une introduction rapide à l'utilisation de différentes versions de Python à l'aide de Docker. C'est un excellent moyen de tester et de voir que votre code est compatible avec les nouvelles versions de Python. Il ne faut que quelques minutes pour envelopper votre script Python dans un conteneur Docker, afin que vous puissiez essayer la dernière version alpha dès sa sortie!

Maintenant vous pouvez:

Démarrez un Python REPL via Docker
Configurer votre environnement Python dans une image Docker
Exécuter des scripts dans des conteneurs Docker

Lorsque vous testez de nouvelles versions de Python dans Docker, vous apportez une aide inestimable à la communauté Python. Si vous avez des questions ou des commentaires, veuillez les laisser dans la section des commentaires ci-dessous.

Lectures complémentaires

Pour plus d'informations sur Docker, et en particulier les flux de travail pour les projets plus importants, consultez Docker en action – Plus en forme, plus heureux, plus productif.

Vous pouvez également lire d'autres exemples de travail avec Python et Docker dans les didacticiels suivants:

[ad_2]