Gestion de plusieurs versions de Python avec pyenv – Real Python

Avez-vous déjà voulu contribuer à un projet prenant en charge plusieurs versions de Python, mais vous ne savez pas comment tester facilement toutes les versions? Êtes-vous déjà curieux de connaître les dernières et meilleures versions de Python? Vous voudrez peut-être essayer ces nouvelles fonctionnalités, mais vous ne voulez pas vous inquiéter de perdre votre environnement de développement. Heureusement, gérer plusieurs versions de Python ne doit pas être déroutant si vous utilisez Pyenv.

Cet article vous donnera un bon aperçu de la façon d'optimiser votre temps de travail sur les projets et de minimiser le temps passé dans les maux de tête à essayer d'utiliser la bonne version de Python.

Dans cet article, vous apprendrez comment:

1. Installer plusieurs versions de Python
2. Installez la dernière version de développement de Python
3. Basculer entre les versions installées
4. Utiliser des environnements virtuels avec Pyenv
5. Activer automatiquement différentes versions de Python et environnements virtuels

Pourquoi utiliser Pyenv?

Pyenv est un outil formidable pour gérer plusieurs versions de Python. Même si Python est déjà installé sur votre système, cela vaut la peine d’avoir Pyenv installé de sorte que vous puissiez facilement essayer de nouvelles fonctionnalités de langage ou contribuer à un projet se trouvant sur une version différente de Python.

Pourquoi ne pas utiliser le système Python?

«System Python» est le Python fourni avec votre système d'exploitation. Si vous êtes sur Mac ou Linux, par défaut, lorsque vous tapez python dans votre terminal, vous obtenez un beau REPL Python.

Alors, pourquoi ne pas l'utiliser? Une façon de voir est que ce Python vraiment fait parti au système d'exploitation. Après tout, il est venu installé avec le système d'exploitation. C’est même reflété quand vous courez lequel:

$ quel python
/ usr / bin / python

Ici, python est disponible pour tous les utilisateurs, comme en témoigne son emplacement / usr / bin / python. Il est fort probable que ce ne soit pas la version de Python que vous souhaitez:

$ python -V
Pyhton 2.7.12

Pour installer un paquet dans votre système Python, vous devez exécuter sudo pip installer. C’est parce que vous installez le paquet Python globalement, ce qui pose un réel problème si un autre utilisateur souhaite installer une version légèrement plus ancienne du paquet.

Les problèmes avec plusieurs versions du même paquet ont tendance à vous envahir et à vous mordre lorsque vous vous y attendez le moins. Une façon courante que ce problème se présente est un paquet populaire et stable se comportant soudainement mal sur votre système. Après des heures de dépannage et de recherche sur Google, vous constaterez peut-être que vous avez installé la mauvaise version d’une dépendance et que cela a gâché votre journée.

Même si votre version de Python est installée dans / usr / local / bin / python3, vous n'êtes toujours pas en sécurité. Vous rencontrerez les mêmes problèmes de permissions et de flexibilité que ceux décrits ci-dessus.

De plus, vous n’avez pas beaucoup de contrôle sur la version de Python livrée installée sur votre système d’exploitation. Si vous souhaitez utiliser les dernières fonctionnalités de Python, et que vous êtes sur Ubuntu par exemple, vous n’êtes peut-être pas chanceux. Les versions par défaut sont peut-être trop anciennes, ce qui signifie que vous devrez simplement attendre la sortie d’un nouveau système d’exploitation.

Enfin, certains systèmes d'exploitation utilisent réellement le Python empaqueté pour fonctionner. Prendre Miam par exemple, qui utilise beaucoup Python pour faire son travail. Si vous installez une nouvelle version de Python sans faire attention à l’installer dans votre espace utilisateur, vous pourriez sérieusement compromettre votre capacité à utiliser votre système d’exploitation.

Qu'en est-il d'un gestionnaire de paquets?

Le prochain endroit logique à regarder est les gestionnaires de paquets. Des programmes tels que apte, Miam, brasser, ou Port sont des options typiques suivantes. Après tout, c’est ainsi que vous installez la plupart des packages sur votre système. Malheureusement, vous rencontrerez les mêmes problèmes en utilisant un gestionnaire de paquets.

Par défaut, les gestionnaires de packages ont tendance à installer leurs packages dans l’espace système global plutôt que dans l’espace utilisateur. Encore une fois, ces packages au niveau du système polluent votre environnement de développement et rendent difficile le partage d'un espace de travail avec d'autres.

Encore une fois, vous n’avez toujours pas le contrôle sur la version de Python que vous pouvez installer. Il est vrai que certains référentiels vous offrent une plus grande sélection, mais par défaut, vous regardez quelle que soit la version de Python utilisée par votre fournisseur pour un jour donné.

Même si vous installez Python à partir d’un gestionnaire de paquets, réfléchissez à ce qui se passerait si vous écrivez un paquet et que vous souhaitez prendre en charge et tester Python 3.4 – 3.7.

Que se passerait-il sur votre système lorsque vous tapez python3? Comment basculeriez-vous rapidement entre les différentes versions? Vous pouvez certainement le faire, mais c'est fastidieux et sujet aux erreurs. Peu importe le fait que si vous voulez PyPy, Jython ou Miniconda, vous n’avez probablement pas de chance avec votre gestionnaire de paquets.

En gardant ces contraintes à l’esprit, récapitulons les critères permettant d’installer et de gérer les versions de Python de manière simple et flexible:

1. Installez Python dans votre espace utilisateur
2. Installer plusieurs versions de Python
3. Spécifiez la version exacte de Python que vous voulez
4. Basculer entre les versions installées

Pyenv vous permet de faire toutes ces choses et plus.

L'installation Pyenv

Avant d'installer Pyenv vous aurez besoin de dépendances spécifiques à un système d’exploitation. Ces dépendances sont principalement des utilitaires de développement écrits en C et sont nécessaires car Pyenv installe Python en construisant à partir des sources. Pour une ventilation plus détaillée et une explication des dépendances de construction, vous pouvez consulter la documentation officielle. Dans ce tutoriel, vous verrez les moyens les plus courants d’installer ces dépendances.

Construire des dépendances

Pyenv compile Python à partir des sources, ce qui signifie que vous aurez besoin de dépendances de construction pour pouvoir utiliser Pyenv. Les dépendances de construction varient selon la plate-forme. Si vous êtes sur Ubuntu / Debian et souhaitez installer les dépendances de construction, vous pouvez utiliser les éléments suivants:

$ sudo apt-get install -y rend la construction essentielle de libssl-dev zlib1g-dev 
libbz2-dev libreadline-dev libsqlite3-dev wget curl llvm libncurses5-dev 
libncursesw5-dev xz-utils tk-dev libffi-dev liblzma-dev python-openssl

Cela utilise Apt pour installer toutes les dépendances de construction. Laissez cela fonctionner et vous serez prêt à utiliser les systèmes Debian.

Si tu utilises Fedora / CentOS / RHEL, vous pourriez utiliser Miam pour installer vos dépendances de construction:

$ sudo yum installer zlib-devel bzip2 bzip2-devel readline-devel sqlite 
sqlite-devel openssl-devel xz xz-devel libffi-devel

Cette commande installera toutes les dépendances de construction pour Python en utilisant Miam.

macOS les utilisateurs peuvent utiliser la commande suivante:

$ brasser installer readline xz

Cette commande s'appuie sur Homebrew et installe les quelques dépendances pour les utilisateurs de macOS.

Si vous utilisez plutôt openSUSE alors vous courriez le suivant:

$ zypper dans zlib-devel bzip2 libbz2-devel libffi-devel 
libopenssl-devel readline-devel sqlite3 sqlite3-devel xz xz-devel

Une fois encore, cette commande installe toutes les dépendances de construction Python pour votre système.

Enfin, pour Alpin utilisateurs, vous pouvez utiliser ceci:

$ apk ajouter libffi-dev ncurses-dev openssl-dev readline-dev 
tk-dev xz-dev zlib-dev

Cette commande utilise apk en tant que gestionnaire de paquets et installera toutes les dépendances de construction de Python sur Alpine.

Utilisation de pyenv-installer

Après avoir installé les dépendances de construction, vous êtes prêt à installer Pyenv lui-même. Je recommande d'utiliser le projet pyenv-installer:

$ curl https://pyenv.run | frapper

Cela installera Pyenv avec quelques plugins utiles:

1. Pyenv: L'actuel Pyenv application
2. pyenv-virtualenv: Plugin pour Pyenv et environnements virtuels
3. pyenv-update: Plugin pour la mise à jour Pyenv
4. pyenv-docteur: Plugin pour vérifier que Pyenv et les dépendances de construction sont installées
5. pyenv-which-ext: Plugin pour rechercher automatiquement les commandes système

À la fin de la course, vous devriez voir quelque chose comme ceci:

ATTENTION: il semble que vous n’ayez toujours pas ajouté «pyenv» au chemin de chargement.

# Chargez pyenv automatiquement en ajoutant
# les éléments suivants à ~ / .bashrc:

export PATH = "$ HOME / .pyenv / bin: $ PATH"
eval "$ (pyenv init -)"
eval "$ (pyenv virtualenv-init -)"

La sortie sera basée sur votre shell. Mais vous devriez suivre les instructions pour ajouter Pyenv sur votre chemin et pour initialiser Pyenv/pyenv-virtualenv achèvement automatique. Une fois que vous avez terminé, vous devez recharger votre shell:

$ exec "$ SHELL" # Ou redémarrez simplement votre terminal

C'est tout. Vous avez maintenant Pyenv et quatre plugins utiles installés.

En utilisant Pyenv installer Python

Maintenant que vous avez Pyenv installé, l’installation de Python est la prochaine étape. Vous avez le choix entre plusieurs versions de Python. Si vous souhaitez voir tous les CPython 3.6 à 3.8 disponibles, procédez comme suit:

$ pyenv install --list | grep "3 .[678]"
        3.6.0
        3.6-dev
        3.6.1
        3.6.2
        3.6.3
        3.6.4
        3.6.5
        3.6.6
        3.6.7
        3.6.8
        3.7.0
        3,7-dev
        3.7.1
        3.7.2
        3.8-dev

Ce qui précède montre toutes les versions de Python Pyenv sait à propos de cette correspondance avec l'expression régulière. Dans ce cas, toutes les versions de CPython disponibles sont 3.6 à 3.8. De même, si vous voulez voir toutes les versions de Jython, vous pouvez le faire:

$ pyenv install --list | grep "jython"
        jython-dev
        Jython-2.5.0
        jython-2.5-dev
        Jython-2.5.1
        jython-2.5.2
        Jython-2.5.3
        jython-2.5.4-rc1
        jython-2.7.0
        Jython-2.7.1

Encore une fois, vous pouvez voir toutes les versions de Jython Pyenv a à offrir. Si vous souhaitez voir toutes les versions, vous pouvez procéder comme suit:

$ pyenv install --list
...
# Il y a beaucoup

Une fois que vous avez trouvé la version souhaitée, vous pouvez l’installer avec une seule commande:

$ pyenv installe -v 3.7.2
/tmp/python-build.20190208022403.30568 ~
Téléchargement de Python-3.7.2.tar.xz ...
-> https://www.python.org/ftp/python/3.7.2/Python-3.7.2.tar.xz
Installation de Python-3.7.2 ...
/tmp/python-build.20190208022403.30568/Python-3.7.2 /tmp/python-build.20190208022403.30568 ~
[...]
Installation des paquets collectés: setuptools, pip
Pip-18.1 setuptools-40.6.2 installé avec succès
Installation de Python-3.7.2 sur /home/realpython/.pyenv/versions/3.7.2

Cela prendra du temps car Pyenv construit Python à partir des sources, mais une fois que cela est fait, vous aurez Python 3.7.2 disponible sur votre ordinateur local. Si vous ne voulez pas voir tout le résultat, supprimez simplement le -v drapeau. Même les versions de développement de CPython peuvent être installées:

Pour le reste du didacticiel, les exemples supposent que vous avez installé 3.6.8 et 2.7.15mais vous êtes libre de substituer ces valeurs aux versions de Python que vous avez réellement installées. Notez également que la version du système Python dans les exemples est 2.7.12.

Emplacement d'installation

Comme indiqué précédemment, Pyenv fonctionne en construisant Python à partir des sources. Chaque version que vous avez installée se trouve bien dans votre Pyenv répertoire racine:

$ ls ~ / .pyenv / versions /
2.7.15 3.6.8 3.8-dev

Toutes vos versions seront situées ici. C'est pratique car la suppression de ces versions est triviale:

$ rm -rf ~ / .pyenv / versions / 2.7.15

Bien sûr Pyenv fournit également une commande pour désinstaller une version particulière de Python:

Utiliser votre nouveau python

Maintenant que vous avez installé plusieurs versions de Python, voyons quelques notions de base sur leur utilisation. Tout d’abord, vérifiez quelles versions de Python sont disponibles:

$ versions pyenv
* system (défini par /home/realpython/.pyenv/version)
        2.7.15
        3.6.8
        3.8-dev

le * indique que le système La version Python est active actuellement. Vous remarquerez également que ceci est défini par un fichier dans votre racine Pyenv annuaire. Cela signifie que, par défaut, vous utilisez toujours votre système Python:

$ python -V
Python 2.7.12

Si vous essayez de le confirmer en utilisant lequel, vous verrez ceci:

$ quel python
/home/realpython/.pyenv/shims/python

Cela peut paraître surprenant, mais c’est ainsi que Pyenv travaux. Pyenv s'insère dans votre CHEMIN et du point de vue de votre OS est l'exécutable qui est appelé. Si vous voulez voir le chemin réel, vous pouvez exécuter ce qui suit:

$ pyenv quel python
/ usr / bin / python

Si, par exemple, vous voulez utiliser la version 2.7.15, vous pouvez utiliser le global commander:

$ pyenv global 2.7.15
$ python -V
Python 2.7.15

$ versions pyenv
  système
* 2.7.15 (défini par /home/realpython/.pyenv/version)
        3.6.8
        3.8-dev

$ pyenv global 3.8-dev
$ python -m tester

Si vous souhaitez revenir à la version système de Python par défaut, vous pouvez exécuter ceci:

$ système mondial pyenv
$ python -V
Python 2.7.12

Vous pouvez maintenant basculer facilement entre les différentes versions de Python. Ce n'est que le début. Si vous souhaitez basculer entre plusieurs versions, il est fastidieux de saisir systématiquement ces commandes. Cette section passe en revue les bases, mais un meilleur flux de travail est décrit lorsque vous travaillez avec plusieurs environnements.

Explorant Pyenv Les commandes

Pyenv offre de nombreuses commandes. Vous pouvez voir une liste complète de toutes les commandes disponibles avec ceci:

$ commandes pyenv
Activer
commandes
finitions
désactiver
...
virtualenvs
d'où
lequel

Ceci affiche tous les noms de commande. Chaque commande a un --Aidez-moi drapeau qui vous donnera des informations plus détaillées. Par exemple, si vous souhaitez voir plus d’informations sur le cales vous pouvez exécuter la commande suivante:

$ pyenv shims --help
Utilisation: cales pyenv [--short]

Liste des cales de pyenv existantes

Le message d'aide décrit l'utilisation de la commande et les options que vous pouvez utiliser conjointement avec la commande. Dans les sections suivantes, vous trouverez un aperçu rapide et détaillé des commandes les plus utilisées.

installer

Vous avez déjà vu le installer commande ci-dessus. Cette commande peut être utilisée pour installer une version spécifique de Python. Par exemple, si vous vouliez installer 3.6.8 vous utiliseriez ceci:

La sortie nous montre Pyenv télécharger et installer Python. Certains des indicateurs communs que vous pouvez utiliser sont les suivants:

les versions

le les versions Cette commande affiche toutes les versions actuellement installées de Python:

$ versions pyenv
* system (défini par /home/realpython/.pyenv/version)
        2.7.15
        3.6.8
        3.8-dev

Cette sortie montre non seulement que 2.7.15, 3.6.8, 3.8-dev, et ton système Python sont installés, mais vous montre également que le système Python est actif. Si vous ne vous souciez que de la version active en cours, vous pouvez utiliser la commande suivante:

$ version pyenv
système (défini par /home/realpython/.pyenv/version)

Cette commande est similaire à les versions mais ne vous montre que la version active de Python.

lequel

le lequel Cette commande est utile pour déterminer le chemin d'accès complet à un exécutable système. Parce que Pyenv fonctionne à l'aide de shims, cette commande vous permet de voir le chemin complet de l'exécutable Pyenv est en cours d'exécution. Par exemple, si vous vouliez voir où pépin est installé, vous pouvez lancer ceci:

$ pyenv qui pip
/home/realpython/.pyenv/versions/3.6.8/bin/pip

La sortie affiche le chemin complet du système pour pépin. Cela peut être utile lorsque vous avez installé des applications de ligne de commande.

global

le global La commande définit la version globale de Python. Cela peut être remplacé par d'autres commandes, mais est utile pour garantir que vous utilisez une version Python particulière par défaut. Si vous vouliez utiliser 3.6.8 Par défaut, vous pouvez lancer ceci:

Cette commande définit le ~ / .pyenv / version à 3.6.8. Pour plus d'informations, voir la section sur la spécification de votre version de Python.

local

le local Cette commande est souvent utilisée pour définir une version Python spécifique à l’application. Vous pouvez l’utiliser pour définir la version 2.7.15:

Cette commande crée un .python-version fichier dans votre répertoire courant. Si tu as Pyenv actif dans votre environnement, ce fichier activera automatiquement cette version pour vous.

coquille

le coquille Cette commande permet de définir une version Python spécifique à l’environnement. Par exemple, si vous souhaitez tester le 3.8-dev version de Python, vous pouvez faire ceci:

Cette commande active la version spécifiée en définissant la PYENV_VERSION variable d'environnement. Cette commande écrase toutes les applications ou les paramètres globaux que vous pourriez avoir. Si vous souhaitez désactiver la version, vous pouvez utiliser le --unset drapeau.

Spécification de votre version Python

Une des parties les plus confuses de Pyenv est comment exactement le python La commande est résolue et quelles commandes peuvent être utilisées pour la modifier. Comme indiqué dans les commandes, il existe 3 façons de modifier quelle version de python vous utilisez. Alors, comment toutes ces commandes interagissent-elles les unes avec les autres? L'ordre de résolution ressemble un peu à ceci:

Cette pyramide est destinée à être lue de haut en bas. La première de ces options Pyenv peut trouver est l'option qu'il utilisera. Voyons un exemple rapide:

$ versions pyenv
* system (défini par /home/realpython/.pyenv/version)
        2.7.15
        3.6.8
        3.8-dev

Ici, votre système Python est utilisé comme indiqué par le *. Pour exercer le prochain paramètre le plus global, vous utilisez global:

$ pyenv global 3.6.8
$ versions pyenv
  système
        2.7.15
* 3.6.8 (défini par /home/realpython/.pyenv/version)
        3.8-dev

Vous pouvez voir ça maintenant Pyenv veut utiliser 3.6.8 comme notre version Python. Il indique même l'emplacement du fichier trouvé. Ce fichier existe bel et bien et vous pouvez lister son contenu:

$ cat ~ / .pyenv / version
3.6.8

Maintenant, créons un .python-version déposer avec local:

$ Pyenv local 2.7.15
$ versions pyenv
  système
* 2.7.15 (défini par /home/realpython/.python-version)
        3.6.8
        3.8-dev
$ ls -a
. .. .python-version
$ cat .python-version
2.7.15

Encore ici, Pyenv indique comment cela résoudrait notre python commander. Cette fois ça vient de ~ / .python-version. Notez que la recherche de .python-version est récursif:

$ mkdir sous-répertoire
$ CD sous-répertoire
$ ls -la # Remarquez qu'aucun fichier .python-version
. ..
$ versions pyenv
  système
* 2.7.15 (défini par /home/realpython/.python-version)
        3.6.8
        3.8-dev

Même s'il n'y a pas de .python-version dans sous-répertoire, la version est toujours configurée pour 2.7.15 parce que .python-version existe dans un répertoire parent.

Enfin, vous pouvez définir la version Python avec coquille:

$ coquille de pyenv 3.8-dev
$ versions pyenv
  système
        2.7.15
        3.6.8
* 3.8-dev (défini par la variable d'environnement PYENV_VERSION)

Tout cela n'a été réglé $ PYENV_VERSION variable d'environnement:

$ écho $ PYENV_VERSION
3.8-dev

Si vous vous sentez dépassé par les options, la section consacrée à la gestion de plusieurs environnements décrit un processus de gestion de fichiers basé sur des opinions, principalement à l'aide de local.

Environnements virtuels et Pyenv

Les environnements virtuels jouent un rôle important dans la gestion des installations et des applications Python. Si vous n’avez jamais entendu parler d’environnements virtuels, vous pouvez consulter Pimeron Virtual Environments: A Primer.

Environnements virtuels et Pyenv sont un match fait au paradis. Pyenv a un merveilleux plugin appelé pyenv-virtualenv cela permet de travailler avec plusieurs versions de Python et plusieurs environnements virtuels un jeu d'enfant. Si vous vous demandez quelle est la différence entre Pyenv, pyenv-virtualenvet des outils comme virtualenv ou venv, alors ne vous inquiétez pas. Tu n'es pas seul.

Voici ce que vous devez savoir:

• Pyenv gère plusieurs versions de Python lui-même.
• virtualenv / venv gère les environnements virtuels pour une version spécifique de Python.
• pyenv-virtualenv gère les environnements virtuels pour différentes versions de Python.

Si vous êtes un dur virtualenv ou venv utilisateur, ne vous inquiétez pas: Pyenv joue bien avec soit. En fait, vous pouvez conserver le même flux de travail que si vous préférez, même si je pense pyenv-virtualenv Cela facilite l'expérience lorsque vous basculez entre plusieurs environnements nécessitant différentes versions de Python.

La bonne nouvelle est que puisque vous avez utilisé le pyenv-installer script à installer Pyenv, tu as déjà pyenv-virtualenv installé et prêt à partir.

Création d'environnements virtuels

La création d'un environnement virtuel est une commande unique:

$ pyenv virtualenv  

Techniquement, le est facultatif, mais vous devriez toujours le spécifier afin que vous soyez certain de la version de Python que vous utilisez.

le est juste un nom pour vous aider à garder vos environnements séparés. Une bonne pratique consiste à attribuer à vos environnements le même nom que votre projet. Par exemple, si vous travailliez sur mon projet et voulait développer contre Python 3.6.8, vous courriez ceci:

$ pyenv virtualenv 3.6.8 mon projet

La sortie inclut des messages indiquant quelques paquets supplémentaires à installer, à savoir: roue, pépin, et setuptools. Ceci est strictement pour plus de commodité et configure simplement un environnement plus complet pour chacun de vos environnements virtuels.

Activer vos versions

Maintenant que vous avez créé votre environnement virtuel, son utilisation est la prochaine étape. Normalement, vous devez activer vos environnements en lançant:

Vous avez vu le pyenv local commande avant, mais cette fois, au lieu de spécifier une version Python, vous spécifiez un environnement. Cela crée un .python-version fichier dans votre répertoire de travail actuel et parce que vous avez exécuté eval "$ (pyenv virtualenv-init -)" dans votre environnement, celui-ci sera automatiquement activé.

Vous pouvez le vérifier en lançant:

$ pyenv quel python
/home/realpython/.pyenv/versions/myproject/bin/python

Vous pouvez voir qu'une nouvelle version a été créée appelée mon projet et le python l'exécutable pointe vers cette version. Si vous regardez n'importe quel exécutable fourni par cet environnement, vous verrez la même chose. Prends pour exemple, pépin:

$ pyenv qui pip
/home/realpython/.pyenv/versions/myproject/bin/pip

Si vous n'avez pas configuré eval "$ (pyenv virtualenv-init -)" pour fonctionner dans votre shell, vous pouvez activer / désactiver manuellement vos versions de Python avec ceci:

$ pyenv activer 
$ pyenv désactiver

Ce qui précède est ce que pyenv-virtualenv fait quand il entre ou sort d'un répertoire avec un .python-version déposer dedans.

Travailler avec plusieurs environnements

En regroupant tout ce que vous avez appris, vous pouvez travailler efficacement dans plusieurs environnements. Supposons que les versions suivantes sont installées:

$ versions pyenv
* system (défini par /home/realpython/.pyenv/version)
        2.7.15
        3.6.8
        3.8-dev

Maintenant, vous voulez travailler sur deux projets différents, bien nommés:

1. projet 1 prend en charge Python 2.7 et 3.6.
2. projet2 supporte Python 3.6 et expérimente avec 3.8-dev.

Vous pouvez voir que, par défaut, vous utilisez le système Python, indiqué par le * dans le versions pyenv sortie. Tout d’abord, créez un environnement virtuel pour le premier projet:

$ CD projet 1/
$ pyenv quel python
/ usr / bin / python
$ pyenv virtualenv 3.6.8 projet1
...
$ Pyenv local projet 1
$ python -V
/home/realpython/.pyenv/versions/project1/bin/python

Enfin, remarquez que lorsque vous CD hors du répertoire, vous revenez par défaut au système Python:

$ CD $ HOME
$ pyenv quel python
/ usr / bin / python

Vous pouvez suivre les étapes ci-dessus et créer un environnement virtuel pour project2:

$ CD projet2 /
$ pyenv quel python
/ usr / bin / python
$ pyenv virtualenv 3.8-dev project2
...
$ Pyenv local 3.8-dev
$ pyenv quel python
/home/realpython/.pyenv/versions/3.8-dev/bin/python

Ce sont des étapes ponctuelles pour vos projets. Maintenant, comme vous CD entre les projets, vos environnements activeront automatiquement:

$ CD projet2 /
$ python -V
Python 3.8.0a0
$ CD ../projet 1
$ python -V
Python 3.6.8

Plus besoin de vous rappeler d’activer des environnements: vous pouvez basculer entre tous vos projets et Pyenv se chargera d'activer automatiquement les bonnes versions de Python et les environnements virtuels corrects.

Activer plusieurs versions simultanément

Comme décrit dans l'exemple ci-dessus, projet2 utilise des fonctionnalités expérimentales en 3.8. Supposons que vous vouliez vous assurer que votre code fonctionne toujours sous Python 3.6. Si vous essayez de courir python3.6, vous obtiendrez ceci:

$ CD projet2 /
$ python3.6 -V
pyenv: python3.6: commande introuvable

La commande `python3.6 'existe dans ces versions de Python:
        3.6.8
        3.6.8 / envs / project1
        projet 1

Pyenv vous informe que, bien que Python 3.6 ne soit pas disponible dans l'environnement actif actuel, il est disponible dans d'autres environnements. Pyenv vous permet d'activer plusieurs environnements à la fois à l'aide d'une commande familière:

$ Pyenv local projet2 3.6.8

Cela indique à Pyenv que vous souhaitez utiliser l'environnement virtuel projet2 comme première option. Donc, si une commande, par exemple python, peut être résolu dans les deux environnements, il faudra choisir projet2 avant 3.6.8. Voyons ce qui se passe si vous lancez ceci:

$ python3.6 -V
Python 3.6.8

Ici, Pyenv tente de trouver le python3.6 commande, et parce qu’elle le trouve dans un environnement actif, elle permet à la commande de s’exécuter. Ceci est extrêmement utile pour des outils comme Tox qui nécessitent plusieurs versions de Python pour être disponibles sur votre ordinateur. CHEMIN afin d'exécuter.

Supposons que, dans l'exemple ci-dessus, vous rencontriez un problème de compatibilité avec votre bibliothèque et souhaitez effectuer des tests locaux. Le test nécessite que vous installiez toutes les dépendances. Suivez les étapes pour créer un nouvel environnement:

$ pyenv virtualenv 3.6.8 project2-tmp
$ Pyenv local project2-tmp

Une fois que vous êtes satisfait de vos tests locaux, vous pouvez facilement revenir à votre environnement par défaut:

$ Pyenv local projet2 3.6.8

Conclusion

Vous pouvez désormais contribuer plus facilement à un projet qui souhaite prendre en charge plusieurs environnements. Vous pouvez également tester plus facilement les versions les plus récentes et les plus performantes de Python sans avoir à vous soucier de tout gâcher sur votre machine de développement, le tout avec un outil formidable: Pyenv.

Vous avez vu comment Pyenv peut vous aider:

• Installer plusieurs versions de Python
• Basculer entre les versions installées
• Utiliser des environnements virtuels avec Pyenv
• Activer automatiquement différentes versions de Python et environnements virtuels

Si vous avez encore des questions, n'hésitez pas à contacter la section commentaires ou Twitter. De plus, la documentation de pyenv est une excellente ressource.

Bonus: affichage du nom de votre environnement dans votre invite de commande

Si vous êtes comme moi et que vous basculez constamment entre divers environnements virtuels et versions Python, il est facile de ne pas savoir quelle version est actuellement active. J'utilise oh-my-zsh et le thème agnoster, qui par défaut donne à mon invite l'apparence suivante:

En un coup d’œil, je ne sais pas quelle version de Python est active. Pour le comprendre, je devrais courir python -V ou version pyenv. Pour réduire le temps passé à découvrir mon environnement Python actif, j’ajoute le Pyenv environnement virtuel que j’utilise à mon invite:

Ma version Python dans ce cas est project1-venv et s'affiche immédiatement au début de l'invite. Cela me permet de voir rapidement quelle version de Python j’utilise tout de suite. Si vous souhaitez utiliser cela aussi, vous pouvez utiliser mon thème agnoster-pyenv.