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?

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.

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.

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.

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

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`

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.

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.

Ces deux commandes devraient fonctionner correctement.

virtualenv -p python2 myenv (Pour python2)

virtualenv -p python3 myenv (Pour python3)

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.

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

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.

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>

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

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

[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] 
>>>

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

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é).

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$ 

Ça a marché pour moi

sudo apt-get install python3-minimal

virtualenv --no-site-packages --distribute -p /usr/bin/python3 ~/.virtualenvs/py3

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

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.

virtualenv -p python3 myenv

Lien vers la création de virtualenv

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.

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

pip install --upgrade virtualenv

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

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.

Vous pouvez le faire en faisant ceci:

virtualenv -p python3 .

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

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).

8. 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.
9. Ajoutez le fichier test.py avec une impression d'instruction ("Hello World").
10. Exécutez ce programme.
11. Dans le terminal Visual Studio Code -
    (project_env) d: \ Code_Python_VE> python -m pip install --upgrade
    J'espère que cela aide.

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