Ich habe ein Debian-System, das derzeit mit Python 2.5.4 ausgeführt wird. Ich habe virtualenv richtig installiert, alles funktioniert gut. Gibt es eine Möglichkeit, dass ich eine virtuelle Umgebung mit einer anderen Version von Python verwenden kann?

Ich habe Python 2.6.2 kompiliert und möchte es mit einigen virtuellen Umgebungen verwenden. Reicht es aus, die Binärdatei zu überschreiben? Oder muss ich etwas an den Bibliotheken ändern?

Verwenden Sie beim Erstellen Ihrer virtualenv-Instanz einfach die Option --python(oder kurz -p), um die ausführbare Python-Datei anzugeben, die Sie verwenden möchten, z.

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

NB Informationen zu Python 3.3 oder höher finden Sie in der Antwort von The Aelfinn unten.

Seit Python 3 schlagen die Python-Dokumente vor , die virtuelle Umgebung mit dem folgenden Befehl zu erstellen:

python3 -m venv <myenvname>

Bitte beachten Sie, dass venvdas Erstellen virtueller Umgebungen mit anderen Python-Versionen nicht möglich ist. Installieren und verwenden Sie dazu das virtualenv Paket .

Veraltete Informationen

Mit dem pyvenv Skript kann eine virtuelle Umgebung erstellt werden

pyvenv /path/to/new/virtual/environment

aber es ist seit Python 3.6 veraltet.

Dies sind die Schritte, die Sie ausführen können, wenn Sie sich in einer gemeinsam genutzten Hosting-Umgebung befinden und Python aus dem Quellcode installieren und kompilieren und dann venvaus Ihrer Python-Version erstellen müssen . Für Python 2.7.9. Sie würden etwas in diese Richtung tun:

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

virtuelle Umgebung

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   

Dies kann natürlich auf jede Situation angewendet werden, in der Sie die genaue Umgebung replizieren möchten, in der Sie arbeiten und die Sie bereitstellen.

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

Es gibt einen einfacheren Weg,

virtualenv venv --python=python2.7

Dank eines Kommentars funktioniert dies nur, wenn Sie Python2.7 auf Systemebene installiert haben (z. B. /usr/bin/python2.7).

Wenn Sie Homebrew verwenden, können Sie den Pfad verwenden, um das zu erhalten, was Sie möchten.

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

Sie finden den Pfad zu Ihrer Python-Installation mit

which python

Dies funktioniert auch mit Python 3.

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

Letztendlich verdichtet zu:

virtualenv venv -p `which python`
virtualenv venv -p `which python3`

Unter Windows funktioniert das für mich:

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

Ohne das python.exehabe WindowsError: [Error 5] Access is denied ich Python2.7.1 mit virtualenv 1.6.1 installiert und wollte Python 2.5.2.

Mac OSX 10.6.8 (Schneeleopard):

1) Wenn Sie dies tun pip install virtualenv, wird der Befehl pip einer Ihrer Python-Versionen zugeordnet und virtualenvin dieser Python-Version installiert. Du kannst tun

 $ which pip   

um zu sehen, welche Version von Python das ist. Wenn Sie so etwas sehen wie:

 $ which pip
 /usr/local/bin/pip

dann mach:

$ 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

Sie können die Python-Version in der Ausgabe sehen.

Standardmäßig ist dies die Version von Python, die für jede neue Umgebung verwendet wird, die Sie erstellen. Sie können jedoch jede auf Ihrem Computer installierte Python-Version angeben, die in einer neuen Umgebung verwendet werden soll -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 erstellt einen Ordner im aktuellen Verzeichnis, der die ausführbaren Python-Dateien enthält, sowie eine Kopie des Befehls pip [Befehl], mit dem Sie andere Pakete installieren können.

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

virtualenv Kopiert Python einfach von einem Speicherort auf Ihrem Computer in das neu erstellte Verzeichnis my_env / bin /.

2) Das System Python ist in /usr/bin, während die verschiedenen Python-Versionen, die ich installiert habe, standardmäßig installiert wurden in:

 /usr/local/bin

3) Die verschiedenen Pythons, die ich installiert habe, haben Namen wie python2.7oder python3.2, und ich kann diese Namen anstelle vollständiger Pfade verwenden.

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

1) Ich hatte einige Probleme damit, virtualenvwrapper zum Laufen zu bringen. Das habe ich letztendlich eingefügt ~/.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) Das -p optionfunktioniert anders mit virtualenvwrapper: Ich muss den vollständigen Pfad zum Python-Interpreter angeben, der in der neuen Umgebung verwendet werden soll (wenn ich die Standard-Python-Version nicht verwenden möchte):

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

Im Gegensatz zu virtualenv erstellt virtualenvwrapper die Umgebung an dem durch die Umgebungsvariable $ WORKON_HOME angegebenen Speicherort. So bleiben alle Ihre Umgebungen an einem Ort.

Diese beiden Befehle sollten gut funktionieren.

virtualenv -p python2 myenv (Für Python2)

virtualenv -p python3 myenv (Für Python3)

Angenommen, Sie haben derzeit Python 2.7 in Ihrer virtuellen Umgebung installiert. Aber nutzen wollen python3.2, müssten Sie dies aktualisieren mit:

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

Aktivieren Sie dann Ihre virtuelle Umgebung durch:

$ source activate name_of_your_virtualenv

und dann: python --versionin der Shell, um zu überprüfen, ob Ihre Version jetzt aktualisiert ist.

Sie können virtualenvmit der gewünschten Python-Version aufrufen . Zum Beispiel:

python3 -m virtualenv venv

Oder zeigen Sie alternativ direkt auf Ihren virtuellen Pfad. zB für Windows:

c:\Python34\Scripts\virtualenv.exe venv

Und durch Laufen:

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

Sie können die in der virtuellen Umgebung installierte Python-Version sehen

Der -pAnsatz funktioniert gut, aber Sie müssen daran denken, ihn jedes Mal zu verwenden. Wenn Sie generell auf eine neuere Version von Python umsteigen möchten, ist dies ein Problem und kann auch zu Fehlern führen.

Sie können auch eine Umgebungsvariable festlegen, die dasselbe tut wie -p. Stellen Sie dies über Ihre ~/.bashrcDatei oder überall dort ein, wo Sie Umgebungsvariablen für Ihre Anmeldesitzungen verwalten:

export VIRTUALENV_PYTHON=/path/to/desired/version

Dann virtualenvwird dies jedes Mal verwendet, wenn Sie es nicht -pin der Befehlszeile angeben .

Noch einfacher, indem Sie die Befehlssubstitution verwenden, um python2 für Sie zu finden:

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

Oder wenn Sie virtualenvwrapper verwenden:

mkvirtualenv -p $(which python2) <env_name>

Installieren Sie für Mac (High Sierra) die virtuelle Umgebung auf Python3 und erstellen Sie eine virtuelle Umgebung für Python2:

 $ python3 -m pip install virtualenv
 $ python3 -m virtualenv --python=python2 vp27
 $ source vp27/bin/activate
 (vp27)$ python --version
 Python 2.7.14

Auf dem Mac verwende ich pyenv und virtualenvwrapper. Ich musste eine neue virtuelle Umgebung erstellen. Sie benötigen Homebrew, das Sie vermutlich installiert haben, wenn Sie auf einem Mac arbeiten, aber nur zum Spaß:

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}

Ich habe auch zuerst meine Anforderungen eingefroren, damit ich die neue virtuelle Umgebung einfach neu installieren kann mit:

pip install -r requirements.txt

[November 2019] Ich musste eine Python 3.7-Umgebung (env) auf meinem Python 3.8-basierten Arch Linux-System installieren. Python 3.7 war nicht mehr auf dem System, daher konnte ich Python nicht herunterstufen, um ein Paket zu installieren, das ich brauchte.

Außerdem wollte ich dieses Paket / Python 3.7 in einer virtuellen Umgebung (venv) verwenden. So habe ich es gemacht.

Quelldateien der Python-Version herunterladen:

Ich habe die Python 3.7.4-Quelldateien von heruntergeladen

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

zu

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

Ich habe dann dieses Archiv (Quelldateien) extrahiert

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

Installation:

[Hinweis: In meinem System env kein 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

Untersuchen Sie die installierten Python-Versionen:

$ 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

So erstellen Sie ein Venv für eine bestimmte Python-Version:

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

12.2. VIRTUELLE UMGEBUNG ERSTELLEN

Das Modul zum Erstellen und Verwalten virtueller Umgebungen wird aufgerufen venv. venvInstalliert normalerweise die neueste Version von Python, die Sie zur Verfügung haben. Wenn Sie mehrere Python-Versionen auf Ihrem System haben, können Sie eine bestimmte Python-Version auswählen, indem Sie python3 oder eine beliebige Version ausführen.

Um eine virtuelle Umgebung zu erstellen, wählen Sie ein Verzeichnis aus, in dem Sie es ablegen möchten, und führen Sie das venv-Modul als Skript mit dem Verzeichnispfad aus:

python3 -m venv tutorial-env

Dadurch wird das tutorial-envVerzeichnis erstellt, falls es nicht vorhanden ist, und es werden Verzeichnisse darin erstellt, die eine Kopie des Python-Interpreters, die Standardbibliothek und verschiedene unterstützende Dateien enthalten. ...

Erstellen Sie Python 3.7 venv [auf einem Python 3.8-Betriebssystem]:

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)

Hinzugefügt zu ~/.bashrc:

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

Testen Sie 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] 
>>>

Im Windows-Subsystem für Linux:

1. Erstellen Sie eine Umgebung für Python3:

   virtualenv --python=/usr/bin/python3 env

2. Aktiviere es:

   source env/bin/activate

Unter Windows:

py -3.4x32 -m venv venv34

oder

py -2.6.2 -m venv venv26

Dies verwendet den pyLauncher, der die richtige ausführbare Python-Datei für Sie findet (vorausgesetzt, Sie haben sie installiert).

Ja , die obigen Antworten sind korrekt und funktionieren auf Unix-basierten Systemen wie Linux und MAC OS X. .

Ich habe versucht, virtualenv für Python2 und Python3 mit den folgenden Befehlen zu erstellen .

Hier habe ich verwendet venv2 & venv3 als ihre Namen für Python2 & Python3 sind.

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$ 

Überprüfen der Python-Installationsorte

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$ 

Es hat bei mir funktioniert

sudo apt-get install python3-minimal

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

Ich verwende pyenv , um meine Python-Version zu verwalten.

pyenv install 3.7.3
pyenv local 3.7.3

Überprüfen Sie Ihre Python-Version:

$ python --version
Python 3.7.3

Erstellen Sie die virtuelle Umgebung mit venv :

python -m venv .

Aktivieren Sie dann die virtuelle Umgebung:

source bin/activate

Überprüfen Sie Ihre Python-Version:

$ python --version
Python 3.7.3

Möglicherweise müssen Sie die vorherige virtuelle Umgebung entfernen

rm -rf bin

Diese scheinen für Windows etwas überkompliziert zu sein. Wenn Sie unter Windows mit Python 3.3 oder höher arbeiten, können Sie den Python Launcher verwenden py, um dies viel einfacher zu tun. Installieren Sie einfach die andere Python-Version und führen Sie dann Folgendes aus:

py -[my version] -m venv env

Dadurch wird envmithilfe von Python eine virtuelle Umgebung erstellt, die in Ihrem aktuellen Verzeichnis aufgerufen wird [my version]. Als Beispiel:

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

Dadurch wird eine virtuelle Umgebung namens envpython3.7 erstellt und aktiviert. Keine Pfade oder andere komplexe Dinge erforderlich.

virtualenv -p python3 myenv

Link zum Erstellen von virtualenv

Für Debian (debian 9) -Systeme im Jahr 2019 habe ich eine einfache Lösung gefunden, die das Problem in der virtuellen Umgebung lösen kann.

Angenommen, die virtuelle Umgebung wurde erstellt über:

python3.7 -m venv myenv

hat aber nur versionen von python2undpython2.7 , und Sie benötigen die neuesten Funktionen von Python3.7.

Führen Sie dann einfach den Befehl aus:

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

fügt python3.7-Pakete hinzu, wenn diese bereits auf Ihrem System verfügbar sind.

Dies war ein Fehler bei virtualenv. Nur ein Upgrade Ihres Pip sollte das Problem sein.

pip install --upgrade virtualenv

Wie bereits in mehreren Antworten erwähnt, ist die Verwendung von virtualenv eine saubere Lösung. Eine kleine Gefahr, die jeder beachten sollte, ist jedoch, dass ein Alias ​​für Python in bash_aliases wie folgt festgelegt ist :

python=python3.6

Dieser Alias ​​wird auch in der virtuellen Umgebung verwendet. In diesem Szenario wird die Ausführung python -Vin der virtuellen 3.6Umgebung immer ausgegeben, unabhängig davon, welcher Interpreter zum Erstellen der Umgebung verwendet wird:

virtualenv venv --python=pythonX.X

Es funktionierte für mich unter Windows mit Python 2-Installation:

1. Schritt 1: Installieren Sie die Python 3-Version.
2. Schritt 2: Erstellen Sie einen env-Ordner für die virtuelle Umgebung.
3. Schritt 3: c: \ Python37 \ python -m venv c: \ path \ to \ env.

Auf diese Weise habe ich eine virtuelle Python 3-Umgebung in meiner vorhandenen Python 2-Installation erstellt.

Sie können dies folgendermaßen tun:

virtualenv -p python3 .

Ja, Sie müssen nur die andere Version von Python installieren und den Speicherort Ihrer anderen Version von Python in Ihrem Befehl wie folgt definieren:

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

Hier ist der Schritt zum Erstellen der virtuellen Umgebung im Visual Studio Code-Ordner: Ich habe Powershell (Administratormodus) verwendet:
1. Ich erstelle einen VSCode-Ordner - "D: \ Code_Python_VE", in dem ich eine virtuelle Umgebung erstellen möchte.
2. Als nächstes gebe ich den Befehl "pip3 install virtualenv" ein. (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 - Dies listet eine neue Liste auf Verzeichnis "project_env".
6. D: \ Code_Python_VE> Code. Dadurch wird Visual Studio Code gestartet. Stellen Sie sicher, dass der Befehl (Code) lautet.
7. Erstellen Sie launch.jason mit folgendem Inhalt:

{
    // 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"
        }
    ]
}

(Bitte suchen Sie, wie Sie zum Debug-Fenster gehen und neue Konfiguration in VS-Code hinzufügen).

8. Drücken Sie F1 in Visual Studio-Code und die Befehlspalette wird geöffnet. - Wählen Sie Python Interpreter und wählen Sie die virtuelle Umgebung project_env aus.
9. Fügen Sie die Datei test.py mit einem Anweisungsdruck hinzu ("Hello World").
10. Führen Sie dieses Programm aus.
11. In Visual Studio Code Terminal -
    (project_env) d: \ Code_Python_VE> python -m pip install --upgrade
    Ich hoffe, das hilft.

UBUNTU 19.04 / Global Python 3.7.

Dies funktionierte für mich und ermöglichte eine Python 3.8-Umgebung mit dem empfohlenen venv für die Python 3-Entwicklung.

Installieren Sie das venv-Modul 3.8 und 3.8

$ sudo apt install python3.8 python3.8-venv ## plus alle anderen Module, die Sie benötigen

Erstellen Sie Ihre virtuelle Umgebung mit der Python-Version, die Sie in dieser Umgebung haben möchten

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

Wechseln Sie in Ihre virtuelle Umgebung

$ source python38-env / bin / enabled

Python -V = Python 3.8