Utiliser une version Python différente avec virtualenv

1116

J'ai un système Debian fonctionnant actuellement avec python 2.5.4. J'ai obtenu virtualenv correctement installé, tout fonctionne bien. Est-il possible d'utiliser un virtualenv avec une version différente de Python?

J'ai compilé Python 2.6.2 et je voudrais l'utiliser avec des virtualenv. Est-ce suffisant pour écraser le fichier binaire? Ou dois-je changer quelque chose par rapport aux bibliothèques?

Ulf
la source
8
Il suffit de mentionner que vous pouvez également le faire en utilisant virtualenvwrapper.
biais
13
Il convient de noter qu'en python 3, il existe un équivalent virtualenv intégré : venv .
naught101
2
N'est-il pas possible de changer de version python dans l'environnement actuel sans créer un nouvel environnement?
Charlie Parker

Réponses:

1542

Utilisez simplement l' option --python(ou courte -p) lors de la création de votre instance virtualenv pour spécifier l'exécutable Python que vous souhaitez utiliser, par exemple:

virtualenv --python=/usr/bin/python2.6 <path/to/new/virtualenv/>

NB Pour Python 3.3 ou version ultérieure, reportez-vous à la réponse d'Aelfinn ci-dessous.

Daniel Roseman
la source
160
Je pensais que je mentionnerais que cela fonctionne aussi pour virtualenvwrappers: mkvirtualenv -p python2.6 env
biais
65
Il me manque quelque chose ici - cela ne nécessite-t-il pas que 2.6 soit déjà installé sur le système? Je pensais que le point de virtualenv était que je pouvais avoir une version de python autre que la principale (dans mon cas, 2.4 sur CentOS). Je supposais que je pouvais installer virtualenv, puis installer Python 2.6 sous celui-ci pour que les packages env utilisent?
John C
42
@John oui, vous l'êtes. Ce n'est pas le but de virtualenv: le but de cela est de créer un environnement sandbox pour Python. Vous devrez d'abord installer cette version - vous pouvez toutefois l'installer localement pour votre utilisateur.
Daniel Roseman,
8
@JohnC Vous pouvez utiliser pythonbrew pour installer des pythons alternatifs.
ashwoods
54
Si vous êtes un peu paresseux:virtualenv -p `which python2.6` <path/to/new/virtualenv>
Blaze
294

Depuis Python 3, les documents Python suggèrent de créer l'environnement virtuel avec la commande suivante:

python3 -m venv <myenvname>

Veuillez noter que venvcela ne permet pas de créer des environnements virtuels avec d'autres versions de Python. Pour cela, installez et utilisez le virtualenv package .


Informations obsolètes

Le pyvenv script peut être utilisé pour créer un environnement virtuel

pyvenv /path/to/new/virtual/environment

mais il est obsolète depuis Python 3.6.

L'Aelfinn
la source
8
Heureux que vous l'ayez souligné, il a besoin de plus de promotion. Un petit bémol: ils préconisent maintenant de l'exécuter python3 -m venv <envname>pour éviter d'avoir besoin de scripts de stub pour tout.
Paul Everitt
6
En fait, le pyvenvscript est obsolète dans Python 3.6+, bien que le venvmodule sous-jacent lui-même ne le soit pas. Donc, utilisez python 3 -m venv <myenvname>comme le dit @PaulEveritt.
RichVel
5
Soyez averti pyvenvou python3 -m venv ...n'installez PAS le python-configscript. Cela signifie que même après avoir activé votre environnement Python3, l'ensemble du système python-configsera invoqué avec des conséquences déroutantes. Voir ce rapport de bogue de 2011 github.com/pypa/virtualenv/issues/169 et ma question stackoverflow.com/questions/42020937/…
Laryx Decidua
1
"Veuillez noter que venvcela ne permet pas de créer virtualenv avec d'autres versions de Python." - Tu es sûr que c'est vrai? Cela semble fonctionner très bien pour moi si je le crée avec une version spécifique de Python, par exemple python3.5 -m venv <myenvname>(à condition que cette version de Python soit disponible).
Dominick Pastore
5
Confirmer que l'observation de @ Nick fonctionne: La façon de créer un venvavec une version Python spécifique est d'utiliser cette version lors de sa configuration. Par exemple:python3.5 -m venv venv
tanius
183

Ce sont les étapes que vous pouvez suivre lorsque vous êtes dans un environnement d'hébergement partagé et que vous devez installer et compiler Python à partir de la source, puis créer à venvpartir de votre version Python. Pour Python 2.7.9. vous feriez quelque chose dans ce sens:

mkdir ~/src
wget http://www.python.org/ftp/python/2.7.9/Python-2.7.9.tgz
tar -zxvf Python-2.7.9.tgz
cd Python-2.7.9
mkdir ~/.localpython
./configure --prefix=$HOME/.localpython
make
make install

env virtuel

cd ~/src
wget https://pypi.python.org/packages/5c/79/5dae7494b9f5ed061cff9a8ab8d6e1f02db352f3facf907d9eb614fb80e9/virtualenv-15.0.2.tar.gz#md5=0ed59863994daf1292827ffdbba80a63
tar -zxvf virtualenv-15.0.2.tar.gz
cd virtualenv-15.0.2/
~/.localpython/bin/python setup.py install
virtualenv ve -p $HOME/.localpython/bin/python2.7
source ve/bin/activate   

Naturellement, cela peut être applicable à toute situation où vous souhaitez répliquer l'environnement exact sur lequel vous travaillez et déployez.

zzart
la source
2
Pourriez-vous expliquer pourquoi le faire de cette façon: Pourquoi installer python localement? Et plus important encore, pourquoi installer virtualenv en utilisant la version python que vous souhaitez utiliser avec lui ?
lajarre
15
sûr. Si vous êtes sur un environnement d'hébergement virtuel et que le serveur fournit des versions plus anciennes de python dont vous n'êtes pas satisfait - c'était mon scénario. Aussi, si vous développez des projets sur différents serveurs et que vous souhaitez répliquer ces environnements sur votre machine locale .... Virtualenv crée des liens durs vers des bibliothèques python. c'est donc très important avec la version de python que vous utilisez pour installer et créer Virtualenv à partir de.
zzart
6
Ou si vous êtes comme moi et que vous êtes sur une machine verrouillée au travail sans privilèges sudo. Copies locales de bibliothèques, bases de données SQL, langages et compilateurs à gogo! Merci!
zachd1_618
4
Sous virtualenv 1.9.1, je devais utiliser ~/.localpython/bin/virtualenvau lieu de simplement virtualenvpour que la configuration se termine sans erreurs. De plus, utilisez source ve/bin/activateau lieu de source activate.
Saul
3
Une autre raison de le faire serait d'essayer les bêtas avant qu'elles ne deviennent principales pour vous assurer que vos projets et leurs dépendances fonctionnent toujours sans risquer de casser la gestion de vos packages en encombrant quelque chose et en laissant des fichiers suspendus partout. J'aime cette réponse.
RobotHumans
103
virtualenv --python=/usr/bin/python2.6 <path/to/myvirtualenv>
iElectric
la source
2
Voir ma réponse ci-dessous pour une solution équivalente utilisant des variables d'environnement. Cette approche signifie que vous n'avez pas à vous souvenir d'utiliser -p.
Chris Johnson
5
N'y a-t-il pas de solutions qui permutent entre les versions de python sans nécessiter de créer un nouvel environnement virtuel?
Charlie Parker
3
Est-ce que cela fonctionnerait si vous souhaitez installer une version python qui n'est pas installée sur votre système? Dites que vous voulez tester python3.6mais que vous ne voulez pas toucher python3.5installé sur votre ordinateur?
alpha_989
1
@ alpha_989 trouvez-vous la solution pour ce faire?
Daniil Mashkin
97

Il existe un moyen plus simple,

virtualenv venv --python=python2.7

Grâce à un commentaire, cela ne fonctionne que si vous avez installé python2.7 au niveau du système (par exemple /usr/bin/python2.7).

Sinon, si vous utilisez homebrew, vous pouvez utiliser le chemin pour vous donner ce que vous voulez.

virtualenv venv --python=/usr/local/bin/python

Vous pouvez trouver le chemin vers votre installation python avec

which python

Cela fonctionnera également avec python 3.

which python3
>> /usr/local/bin/python3
virtualenv venv --python=/usr/local/bin/python3

Condenser finalement à:

virtualenv venv -p `which python`
virtualenv venv -p `which python3`
Daniel Lee
la source
1
Pour info, ne fonctionne que si vous avez python2.7 installé au niveau du système (par exemple /usr/bin/python2.7)
kingb12
J'ai pu le faire virtualenv venv --python=python3.6aussi
Jordan
Vous pouvez réellement supprimer le numéro de version secondaire. virtualenv env --python=python2
Anshul
C'est une bonne solution, une fois que vous avez toutes les versions, vous êtes intéressé à utiliser l'alias et non le chemin complet
user1767754
Dans Windows, cela a fonctionné comme un charme avec un petit ajustement: virtualenv venv --python=<insert_your_python_version_here><insert_your_python_version_here>était dans mon casC:\Python\Python368\python.exe
abautista
70

Sous Windows pour moi, cela fonctionne:

virtualenv --python=c:\Python25\python.exe envname

sans le python.exej'ai, WindowsError: [Error 5] Access is denied j'ai Python2.7.1 installé avec virtualenv 1.6.1, et je voulais python 2.5.2.

balazs
la source
32

Mac OSX 10.6.8 (Snow Leopard):

1) Lorsque vous le faites pip install virtualenv, la commande pip est associée à l'une de vos versions de python et virtualenvest installée dans cette version de python. Tu peux faire

 $ which pip   

pour voir de quelle version de python il s'agit. Si vous voyez quelque chose comme:

 $ which pip
 /usr/local/bin/pip

alors fais:

$ ls -al /usr/local/bin/pip
lrwxrwxr-x  1 root  admin  65 Apr 10  2015 /usr/local/bin/pip ->
../../../Library/Frameworks/Python.framework/Versions/2.7/bin/pip

Vous pouvez voir la version python dans la sortie.

Par défaut, ce sera la version de python utilisée pour tout nouvel environnement que vous créez. Cependant, vous pouvez spécifier n'importe quelle version de python installée sur votre ordinateur à utiliser dans un nouvel environnement avec -p flag:

$ virtualenv -p python3.2 my_env  
Running virtualenv with interpreter /usr/local/bin/python3.2  
New python executable in my_env/bin/python  
Installing setuptools, pip...done.  

virtualenv my_env va créer un dossier dans le répertoire courant qui contiendra les fichiers exécutables Python, et une copie de la pip [commande] que vous pouvez utiliser pour installer d'autres packages.

http://docs.python-guide.org/en/latest/dev/virtualenvs/

virtualenv copie simplement python depuis un emplacement de votre ordinateur dans le répertoire my_env / bin / nouvellement créé.

2) Le système python est dans /usr/bin, tandis que les différentes versions de python que j'ai installées étaient, par défaut, installées dans:

 /usr/local/bin

3) Les différents pythons que j'ai installés ont des noms comme python2.7ou python3.2, et je peux utiliser ces noms plutôt que des chemins complets.

======== VIRTUALENVWRAPPER =========

1) J'ai rencontré des problèmes pour faire fonctionner virtualenvwrapper. C'est ce que j'ai fini par mettre ~/.bash_profile:

export WORKON_HOME=$HOME/.virtualenvs
export PROJECT_HOME=$HOME/django_projects  #Not very important -- mkproject command uses this
#Added the following based on: 
#http://stackoverflow.com/questions/19665327/virtualenvwrapper-installation-snow-leopard-python
export VIRTUALENVWRAPPER_PYTHON=/usr/local/bin/python2.7 
#source /usr/local/bin/virtualenvwrapper.sh
source /Library/Frameworks/Python.framework/Versions/2.7/bin/virtualenvwrapper.sh

2) -p optionCela fonctionne différemment avec virtualenvwrapper: je dois spécifier le chemin complet vers l'interpréteur python à utiliser dans le nouvel environnement (quand je ne veux pas utiliser la version python par défaut):

$ mkvirtualenv -p /usr/local/bin/python3.2 my_env
Running virtualenv with interpreter /usr/local/bin/python3
New python executable in my_env/bin/python
Installing setuptools, pip...done.
Usage: source deactivate

removes the 'bin' directory of the environment activated with 'source
activate' from PATH. 

Contrairement à virtualenv, virtualenvwrapper créera l'environnement à l'emplacement spécifié par la variable d'environnement $ WORKON_HOME. Cela maintient tous vos environnements en un seul endroit.

7stud
la source
which pipne me dit pas la version de Python. Ça me donne ça- /usr/local/bin/pip.
Sankalp
@Sankalp, Si vous faites un cd sur /usr/local/binet faites $ ls -al pip, vous devriez voir quelque chose comme: pip -> ../../../Library/Frameworks/Python.framework/Versions/2.7/bin/pip
7stud
Déjà un peu noté dans la réponse, mais mkprojectc'est la commande à utiliser si vous voulez qu'il crée à la fois le répertoire du projet et un environnement virtuel d'une version python donnée. mkproject -p /usr/bin/python3.6 myNewPython36Project
Jim Factor
22

Ces deux commandes devraient fonctionner correctement.

virtualenv -p python2 myenv (Pour python2)

virtualenv -p python3 myenv (Pour python3)

Sachin Kolige
la source
1
L'indicateur -p python2 fonctionne de manière équivalente à la recherche de / usr / bin / python2. Utilisation: virtualenv -p python2.7 myenv pour 2.7 etc.
Yash Sharma
21

Supposons que python 2.7 soit actuellement installé dans votre virtualenv. Mais souhaitez utiliser python3.2, vous devez mettre à jour cela avec:

$ virtualenv --python=/usr/bin/python3.2 name_of_your_virtualenv

Activez ensuite votre virtualenv en:

$ source activate name_of_your_virtualenv

puis faites: python --versiondans le shell pour vérifier si votre version est maintenant mise à jour.

kmario23
la source
Voir ma réponse ci-dessous pour une solution équivalente utilisant des variables d'environnement. Cette approche signifie que vous n'avez pas à vous souvenir d'utiliser -p.
Chris Johnson
13

Vous pouvez appeler virtualenvavec la version python de votre choix. Par exemple:

python3 -m virtualenv venv

Ou pointez directement sur votre chemin virtualenv. par exemple pour les fenêtres:

c:\Python34\Scripts\virtualenv.exe venv

Et en exécutant:

venv/bin/python

Python 3.5.1 (v3.5.1:37a07cee5969, Dec  5 2015, 21:12:44) 
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>

vous pouvez voir la version python installée dans un environnement virtuel

Nima Soroush
la source
J'ai eu cette erreur lors de l'exécution de la première commande / usr / local / bin / python3: aucun module nommé virtualenv
tanvi
2
@tanvi: Vous devez d'abord installer virtualenv dans votre python3. Courir en pip3 install virtualenvpremier
Nima Soroush
12

L' -papproche fonctionne bien, mais vous devez vous rappeler de l'utiliser à chaque fois. Si votre objectif est de passer à une version plus récente de Python en général, c'est pénible et peut également entraîner des erreurs.

Votre autre option consiste à définir une variable d'environnement qui fait la même chose que -p. Définissez cela via votre ~/.bashrcfichier ou partout où vous gérez les variables d'environnement pour vos sessions de connexion:

export VIRTUALENV_PYTHON=/path/to/desired/version

Ensuite virtualenv, vous l'utiliserez à tout moment que vous ne spécifiez pas -psur la ligne de commande.

Chris Johnson
la source
Cela a fonctionné à merveille. Une idée pourquoi la configuration export VIRTUALENVWRAPPER_PYTHON=/path/to/desired/versionpar les documents virtualenvwrapper n'a pas fonctionné mais cette solution a fonctionné?
YPCrumble
Cette variable env contrôle ce que Python virtualenvwrapperutilise lors de son exécution, rien à voir avec les installations.
Chris Johnson
Cela a fonctionné pour moi. Plus besoin d'utiliser -p à chaque fois que je crée un nouveau virtualenv. Merci!
nedblorf
7

Encore plus facile, en utilisant la substitution de commandes pour trouver python2 pour vous:

virtualenv -p $(which python2) <path/to/new/virtualenv/>

Ou lors de l'utilisation de virtualenvwrapper:

mkvirtualenv -p $(which python2) <env_name>

Gérard
la source
7

Pour Mac (High Sierra), installez virtualenv sur python3 et créez un virtualenv pour python2:

 $ python3 -m pip install virtualenv
 $ python3 -m virtualenv --python=python2 vp27
 $ source vp27/bin/activate
 (vp27)$ python --version
 Python 2.7.14
Zihao Zhao
la source
1
Installez virtualenv sur python3 si vous n'avez pas:python3 -m pip install virtualenv
Zihao Zhao
Ça ne marche pas. Ma version python est toujours de 3.
shivendra pratap singh
6

Sur le mac, j'utilise pyenv et virtualenvwrapper. J'ai dû créer un nouveau virtualenv. Vous avez besoin d'un homebrew que je suppose avoir installé si vous êtes sur un Mac, mais juste pour le plaisir:

ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"


brew install pyenv
pyenv install 2.7.10
pyenv global 2.7.10
export PATH=/Users/{USERNAME}/.pyenv/versions/2.7.10/bin:$PATH
mkvirtualenv -p ~/.pyenv/versions/2.7.10/bin/python  {virtual_env_name}

J'ai également gelé mes exigences en premier afin que je puisse simplement réinstaller dans le nouveau virtualenv avec:

pip install -r requirements.txt
dague d'argent
la source
La commande doit être des mkvirtualenv -p ~/.pyenv/versions/2.7.10/bin/python {virtual_env_name}versions, pas une version. Si SO autorisait de courtes modifications, je l'aurais corrigé.
Martin Burch du
pyenvinclut le support virtualenv via le pyenv-virtualenvplugin, donc je trouve que je n'ai pas vraiment besoin de virtualenvwrapper. Plus de détails dans ma réponse pyenv .
RichVel
5

[Novembre 2019] J'avais besoin d'installer un environnement Python 3.7 (env) sur mon système Arch Linux basé sur Python 3.8. Python 3.7 n'était plus sur le système, donc je ne pouvais pas rétrograder Python, pour installer un paquet dont j'avais besoin.

De plus, je voulais utiliser ce package / Python 3.7 dans un environnement virtuel (venv). Voilà comment je l'ai fait.


Téléchargez les fichiers source de la version Python:

J'ai téléchargé les fichiers source de Python 3.7.4 depuis

https://www.python.org/downloads/source/

à

/mnt/Vancouver/apps/python_versions/src/Python-3.7.4.tgz

J'ai ensuite extrait cette archive (fichiers source) pour

/mnt/Vancouver/apps/python_versions/src/Python-3.7.4/


Installation:

[Remarque: dans mon système env, pas un venv.]

cd /mnt/Vancouver/apps/python_versions/src/Python-3.7.4/
time ./configure                 ## 17 sec
time make                        ## 1 min 51 sec
time sudo make install           ## 18 sec
time make clean                  ## 0.3 sec

Examinez les versions Python installées:

$ which python
/usr/bin/python

$ python --version
Python 3.8.0

$ which python3.7
/usr/local/bin/python3.7

$ python    ## Python 3.8 [system / env]
Python 3.8.0 (default, Oct 23 2019, 18:51:26) 
[GCC 9.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

$ python3.7    ## newly-installed Python 3.7 package
Python 3.7.4 (default, Nov 20 2019, 11:36:53) 
[GCC 9.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import sys
>>> print(sys.version)
3.7.4 (default, Nov 20 2019, 11:36:53) 
[GCC 9.2.0]
>>>

$ python3.7 --version                                                                                                 
Python 3.7.4

Comment créer un venv pour une version Python spécifique:

https://docs.python.org/3/tutorial/venv.html

12.2. CRÉER DES ENVIRONNEMENTS VIRTUELS

Le module utilisé pour créer et gérer des environnements virtuels est appelé venv.venvinstalle généralement la version la plus récente de Python dont vous disposez. Si vous disposez de plusieurs versions de Python sur votre système, vous pouvez sélectionner une version Python spécifique en exécutant python3 ou la version de votre choix.

Pour créer un environnement virtuel, choisissez un répertoire où vous souhaitez le placer et exécutez le module venv en tant que script avec le chemin du répertoire:

python3 -m venv tutorial-env

Cela créera le tutorial-envrépertoire s'il n'existe pas, et créera également à l'intérieur des répertoires contenant une copie de l'interpréteur Python, la bibliothèque standard et divers fichiers de prise en charge. ...


Créer Python 3.7 venv [sur un env / système d'exploitation Python 3.8]:

python3.7 -m venv ~/venv/py3.7      ## create Python 3.7-based venv
source ~/venv/py3.7/bin/activate    ## activate that venv
deactivate                          ## deactivate that venv (when done, there)

Ajouté à ~/.bashrc:

alias p37='echo "   [Python 3.7 venv (source ~/venv/py3.7/bin/activate)]" && source ~/venv/py3.7/bin/activate'

Testez Python 3.7 venv:

$ p37                                                                                                                 
[Python 3.7 venv (source ~/venv/py3.7/bin/activate)]

(py3.7)$ python --version
Python 3.7.4

(py3.7)$ python
Python 3.7.4 (default, Nov 20 2019, 11:36:53) 
[GCC 9.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import sys
>>> print(sys.version)
3.7.4 (default, Nov 20 2019, 11:36:53) 
[GCC 9.2.0] 
>>>
Victoria Stuart
la source
1
Ceci est une réponse extrêmement approfondie! :) Je rencontre ce problème chaque fois que j'ai besoin de transférer quelque chose d'Arch Linux vers un autre système (par exemple Debian-ish).
Robbie Capps
1
@Victoria Stuart, merci beaucoup. Ceci est exactement ce que je cherchais.
daddyodevil
4

Dans le sous-système Windows pour Linux:

  1. Créer un environnement pour python3:

    virtualenv --python=/usr/bin/python3 env
  2. Activez-le:

    source env/bin/activate
Marcin Rapacz
la source
3

Sur les fenêtres:

py -3.4x32 -m venv venv34

ou

py -2.6.2 -m venv venv26

Cela utilise le pylanceur qui trouvera le bon exécutable python pour vous (en supposant que vous l'ayez installé).

jnnnnn
la source
3

Oui , les réponses ci - dessus sont bien corrects et les travaux sur les systèmes Unix comme Linux et MAC OS X .

J'ai essayé de créer virtualenv pour Python2 et Python3 avec les commandes suivantes.

Ici, j'ai utilisé venv2 et venv3 comme noms pour Python2 et Python3 respectivement.

Python2 »

MacBook-Pro-2:~ admin$ virtualenv venv2 --python=`which python2`
Running virtualenv with interpreter /usr/local/bin/python2
New python executable in /Users/admin/venv2/bin/python
Installing setuptools, pip, wheel...done.
MacBook-Pro-2:~ admin$ 
MacBook-Pro-2:~ admin$ ls venv2/bin/
activate        easy_install        pip2.7          python2.7
activate.csh        easy_install-2.7    python          wheel
activate.fish       pip         python-config
activate_this.py    pip2            python2
MacBook-Pro-2:~ admin$ 

Python3 »

MacBook-Pro-2:~ admin$ virtualenv venv3 --python=`which python3`
Running virtualenv with interpreter /usr/local/bin/python3
Using base prefix '/Library/Frameworks/Python.framework/Versions/3.6'
New python executable in /Users/admin/venv3/bin/python3
Also creating executable in /Users/admin/venv3/bin/python
Installing setuptools, pip, wheel...done.
MacBook-Pro-2:~ admin$ 
MacBook-Pro-2:~ admin$ ls venv3/bin/
activate        easy_install        pip3.6          python3.6
activate.csh        easy_install-3.6    python          wheel
activate.fish       pip         python-config
activate_this.py    pip3            python3
MacBook-Pro-2:~ admin$ 

Vérification des emplacements d'installation de Python

MacBook-Pro-2:~ admin$ which python2
/usr/local/bin/python2
MacBook-Pro-2:~ admin$ 
MacBook-Pro-2:~ admin$ which python3
/usr/local/bin/python3
MacBook-Pro-2:~ admin$ 
hygull
la source
2

Ça a marché pour moi

sudo apt-get install python3-minimal

virtualenv --no-site-packages --distribute -p /usr/bin/python3 ~/.virtualenvs/py3
Dadaso Zanzane
la source
2

J'utilise pyenv pour gérer ma version python.

pyenv install 3.7.3
pyenv local 3.7.3

Vérifiez votre version python:

$ python --version
Python 3.7.3

Créez l'environnement virtuel avec venv :

python -m venv .

Activez ensuite l'environnement virtuel:

source bin/activate

Vérifiez votre version python:

$ python --version
Python 3.7.3

Vous devrez peut-être supprimer l'environnement virtuel précédent

rm -rf bin
brandonbanks
la source
2

Ceux-ci semblent un peu trop compliqués pour Windows. Si vous utilisez Windows python 3.3 ou version ultérieure, vous pouvez utiliser le lanceur python pypour le faire beaucoup plus facilement. Installez simplement les différentes versions de python, puis exécutez:

py -[my version] -m venv env

Cela créera un environnement virtuel appelé envdans votre répertoire actuel, en utilisant python [my version]. Par exemple:

py -3.7 -m venv env
./env/Scripts/activate

Cela crée un environnement virtuel appelé à l' envaide de python3.7 et l'active. Aucun chemin ni autre élément complexe requis.

Cole Smith
la source
Ne devrait-il pas en être ainsi py -3.7 -m venv env(il -mmanque)?
sinoroc
Oui, corrigé dans le message!.
Cole Smith
1

Pour les systèmes Debian (debian 9) en 2019, j'ai découvert une solution simple qui peut résoudre le problème depuis l'environnement virtuel.

Supposons que l'environnement virtuel ait été créé via:

python3.7 -m venv myenv

mais n'a que des versions de python2et python2.7, et vous avez besoin des fonctionnalités récentes de python3.7.

Ensuite, exécutez simplement la commande:

(myvenv) $ python3.7 -m venv --upgrade /home/username/path/to/myvenv/

ajoutera des packages python3.7 s'ils sont déjà disponibles sur votre système.

David Golembiowski
la source
1

C'était un bug avec virtualenv. La simple mise à niveau de votre pip devrait être la solution.

pip install --upgrade virtualenv

Mohit
la source
1

Comme déjà mentionné dans plusieurs réponses, l'utilisation de virtualenv est une solution propre. Cependant, un petit piège que tout le monde devrait savoir est que si un alias pour python est défini dans bash_aliases comme:

python=python3.6

cet alias sera également utilisé dans l'environnement virtuel. Ainsi, dans ce scénario, l'exécution python -Và l'intérieur de 3.6l'environnement virtuel sortira toujours quel que soit l'interpréteur utilisé pour créer l'environnement:

virtualenv venv --python=pythonX.X
PetarMI
la source
0

Cela a fonctionné pour moi sur Windows avec l'installation de Python 2:

  1. Étape 1: installez la version python 3.
  2. Étape 2: créez un dossier env pour l'environnement virtuel.
  3. Étape 3: c: \ Python37 \ python -m venv c: \ path \ to \ env.

C'est ainsi que j'ai créé l'environnement virtuel Python 3 sur mon installation existante de Python 2.


la source
0

Vous pouvez le faire en faisant ceci:

virtualenv -p python3 .
Krishna Kamal
la source
0

Oui, il vous suffit d'installer l'autre version de python et de définir l'emplacement de votre autre version de python dans votre commande comme:

virtualenv / home / paie / Documents / env -p / usr / bin / python3

Nitin Nath Giri
la source
0

Voici l'étape étape par étape pour créer l'environnement virtuel dans le dossier Visual Studio Code: J'ai utilisé Powershell (mode Administrateur):
1. Je crée un dossier VSCode - "D: \ Code_Python_VE" où je veux créer un environnement virtuel.
2. Ensuite, je tape la commande - "pip3 install virtualenv". (D: \ Code_Python_VE> pip3 install virtualenv) 3. D: \ Code_Python_VE> python3 -m venv project_env
4. D: \ Code_Python_VE> project_env \ Scripts \ activate.bat
5. D: \ Code_Python_VE> ls - Ceci listera un nouveau répertoire "project_env".
6. Code D: \ Code_Python_VE>. Cela démarrera Visual Studio Code. Assurez-vous que la commande est (code.).
7. Créez launch.jason avec le contenu suivant:

{
    // Use IntelliSense to learn about possible attributes.
    // Hover to view descriptions of existing attributes.
    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
        {
            "type": "python",
            "request": "launch",
            "name": "Python: Current File (Integrated Terminal 1)",
            "program": "${file}"
        },
        {
            "name": "Python: Current File (Integrated Terminal 2)",
            "type": "python",
            "request": "launch",
            "program": "${file}",
            "console": "integratedTerminal"
        }
    ]
}

(Veuillez rechercher comment accéder à la fenêtre de débogage et ajouter une nouvelle configuration dans le code VS).

  1. Appuyez sur F1 dans le code Visual studio et la palette de commandes s'ouvrira - Sélectionnez Python Interpreter et sélectionnez l'environnement virtuel project_env.
  2. Ajoutez le fichier test.py avec une impression d'instruction ("Hello World").
  3. Exécutez ce programme.
  4. Dans le terminal Visual Studio Code -
    (project_env) d: \ Code_Python_VE> python -m pip install --upgrade
    J'espère que cela aide.
TanuAD
la source
-2

UBUNTU 19.04 / Global Python 3.7.

Cela a fonctionné pour moi, permettant un environnement Python 3.8 utilisant le venv recommandé pour le développement de python 3.

Installer les modules 3.8 et 3.8 venv

$ sudo apt install python3.8 python3.8-venv ## ainsi que tous les autres modules dont vous avez besoin

Créez votre environnement virtuel en utilisant la version python que vous souhaitez dans cet environnement

$ /usr/bin/python3.8 -m venv python38-env

basculez dans votre environnement virtuel

$ source python38-env / bin / activate

python -V = python 3.8

Simon P
la source