Mam obecnie system Debian z Pythonem 2.5.4. Mam wirtualnie zainstalowaną poprawnie, wszystko działa dobrze. Czy istnieje możliwość, że mogę użyć virtualenv z inną wersją Pythona?

Skompilowałem Python 2.6.2 i chciałbym go używać z niektórymi virtualenv. Czy wystarczy zastąpić plik binarny? Czy muszę coś zmienić w stosunku do bibliotek?

Wystarczy użyć opcji --python(lub krótkiej -p) podczas tworzenia instancji virtualenv, aby określić plik wykonywalny Pythona, którego chcesz użyć, np .:

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

NB W przypadku Python 3.3 lub nowszego, patrz odpowiedź Aelfinn poniżej.

Od wersji Python 3 Dokumenty Python sugerują utworzenie środowiska wirtualnego za pomocą następującego polecenia:

python3 -m venv <myenvname>

Pamiętaj, że venvnie zezwala na tworzenie środowisk wirtualnych z innymi wersjami Pythona. W tym celu zainstaluj i użyj virtualenv pakietu .

Nieaktualne informacje

pyvenv Skrypt może być wykorzystywane do tworzenia wirtualnego środowiska

pyvenv /path/to/new/virtual/environment

ale jest przestarzałe od Pythona 3.6.

Są to kroki, które możesz wykonać, gdy jesteś we współdzielonym środowisku hostingowym i musisz zainstalować i skompilować Pythona ze źródła, a następnie utworzyć venvze swojej wersji Pythona. Dla Python 2.7.9. zrobiłbyś coś w ten sposób:

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

wirtualna środowisko

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   

Oczywiście może to mieć zastosowanie w każdej sytuacji, w której chcesz replikować dokładne środowisko, w którym pracujesz i wdrażasz.

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

Jest łatwiejszy sposób,

virtualenv venv --python=python2.7

Dzięki komentarzowi działa to tylko wtedy, gdy masz Python2.7 zainstalowany na poziomie systemu (np. /Usr/bin/python2.7).

W przeciwnym razie, jeśli używasz homebrew, możesz użyć ścieżki, aby dać ci to, czego chcesz.

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

Możesz znaleźć ścieżkę do instalacji Pythona za pomocą

which python

Będzie to również działać z Pythonem 3.

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

Ostatecznie kondensuje się do:

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

W systemie Windows działa to dla mnie:

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

bez python.exemam WindowsError: [Error 5] Access is denied Mam Python2.7.1 zainstalowany z virtualenv 1.6.1 i chciałem Python 2.5.2.

Mac OSX 10.6.8 (Snow Leopard):

1) Gdy to zrobisz pip install virtualenv, polecenie pip jest powiązane z jedną z wersji Pythona i virtualenvinstalowane w tej wersji Pythona. Możesz to zrobić

 $ which pip   

aby zobaczyć, która to wersja Pythona. Jeśli widzisz coś takiego:

 $ which pip
 /usr/local/bin/pip

następnie wykonaj:

$ 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

Możesz zobaczyć wersję python na wyjściu.

Domyślnie będzie to wersja Pythona używana w każdym nowym środowisku, które utworzysz. Możesz jednak określić dowolną wersję Pythona zainstalowaną na twoim komputerze, aby używać jej w nowym środowisku za pomocą -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 utworzy folder w bieżącym katalogu, który będzie zawierał pliki wykonywalne Pythona oraz kopię pip [polecenia], której możesz użyć do zainstalowania innych pakietów.

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

virtualenv po prostu kopiuje pytona z lokalizacji na twoim komputerze do nowo utworzonego katalogu my_env / bin /.

2) Python systemowy jest włączony /usr/bin, podczas gdy różne wersje Pythona, które zainstalowałem, były domyślnie zainstalowane w:

 /usr/local/bin

3) Różne pytony, które zainstalowałem, mają nazwy takie jak python2.7i python3.2, i mogę używać tych nazw zamiast pełnych ścieżek.

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

1) Miałem pewne problemy z uruchomieniem programu virtualenvwrapper. Właśnie to skończyłem wprowadzając ~/.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 optionDziała inaczej z virtualenvwrapper: Muszę podać pełną ścieżkę do interpretera Pythona, który będzie używany w nowym środowisku (kiedy nie chcę używać domyślnej wersji Pythona):

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

W przeciwieństwie do virtualenv, virtualenvwrapper utworzy środowisko w miejscu określonym przez zmienną środowiskową $ WORKON_HOME. Dzięki temu wszystkie środowiska są w jednym miejscu.

Te dwa polecenia powinny działać poprawnie.

virtualenv -p python2 myenv (Dla python2)

virtualenv -p python3 myenv (Dla python3)

Załóżmy, że masz obecnie zainstalowanego Pythona 2.7 w virtualenv. Ale chcesz z tego skorzystać python3.2, musiałbyś zaktualizować to o:

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

Następnie aktywuj virtualenv przez:

$ source activate name_of_your_virtualenv

a następnie wykonaj: python --versionw powłoce, aby sprawdzić, czy Twoja wersja jest teraz zaktualizowana.

Możesz dzwonić virtualenvz dowolną wersją Pythona. Na przykład:

python3 -m virtualenv venv

Lub alternatywnie bezpośrednio wskaż ścieżkę virtualenv. np. dla systemu Windows:

c:\Python34\Scripts\virtualenv.exe venv

I uruchamiając:

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

możesz zobaczyć wersję Pythona zainstalowaną w środowisku wirtualnym

The -pPodejście działa dobrze, ale trzeba pamiętać, aby używać go za każdym razem. Jeśli Twoim celem jest ogólnie przejście na nowszą wersję Pythona, jest to uciążliwe i może również prowadzić do błędów.

Inną opcją jest ustawienie zmiennej środowiskowej, która robi to samo co -p. Ustaw to za pomocą ~/.bashrcpliku lub wszędzie tam, gdzie zarządzasz zmiennymi środowiskowymi dla sesji logowania:

export VIRTUALENV_PYTHON=/path/to/desired/version

Następnie virtualenvużyje tego za każdym razem, gdy nie określisz -pgo w wierszu poleceń.

Jeszcze łatwiejsze, używając podstawiania poleceń, aby znaleźć dla Ciebie python2:

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

Lub podczas korzystania z virtualenvwrapper:

mkvirtualenv -p $(which python2) <env_name>

W systemie Mac (High Sierra) zainstaluj virtualenv na python3 i utwórz virtualenv dla python2:

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

Na Macu używam pyenv i virtualenvwrapper. Musiałem stworzyć nowy virtualenv. Potrzebujesz homebrew, który założę, że zainstalowałeś, jeśli używasz komputera Mac, ale dla zabawy:

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}

Najpierw zamroziłem również moje wymagania, aby móc po prostu zainstalować ponownie w nowej wersji virtualenv za pomocą:

pip install -r requirements.txt

[Listopad 2019] Musiałem zainstalować środowisko Python 3.7 (env) w moim systemie Arch Linux opartym na Python 3.8. Python 3.7 nie był już w systemie, więc nie mogłem obniżyć wersji Pythona, aby zainstalować pakiet, którego potrzebowałem.

Ponadto chciałem użyć tego pakietu / Pythona 3.7 w środowisku wirtualnym (venv). Tak to zrobiłem.

Pobierz pliki źródłowe wersji Python:

Pobrałem pliki źródłowe Python 3.7.4

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

do

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

Następnie wyodrębniłem to archiwum (pliki źródłowe) do

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

Instalacja:

[Uwaga: w moim systemie env, a nie 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

Sprawdź zainstalowane wersje Pythona:

$ 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

Jak utworzyć venv dla określonej wersji Pythona:

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

12.2 TWORZENIE ŚRODOWISKA WIRTUALNEGO

Moduł używany do tworzenia środowisk wirtualnych i zarządzania nimi jest nazywany venv.venvzwykle instaluje najnowszą dostępną wersję Pythona. Jeśli masz wiele wersji Pythona w swoim systemie, możesz wybrać konkretną wersję Pythona, uruchamiając Python3 lub dowolną inną wersję.

Aby utworzyć środowisko wirtualne, wybierz katalog, w którym chcesz go umieścić, i uruchom moduł venv jako skrypt ze ścieżką do katalogu:

python3 -m venv tutorial-env

Spowoduje to utworzenie tutorial-envkatalogu, jeśli nie istnieje, a także utworzenie w nim katalogów zawierających kopię interpretera Pythona, bibliotekę standardową i różne pliki pomocnicze. ...

Utwórz Venv Python 3.7 [na env / systemie operacyjnym 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)

Dodano do ~/.bashrc:

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

Test Venv Python 3.7:

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

W podsystemie Windows dla systemu Linux:

1. Utwórz środowisko dla python3:

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

2. Aktywuj to:

   source env/bin/activate

W systemie Windows:

py -3.4x32 -m venv venv34

lub

py -2.6.2 -m venv venv26

To używa programu pyuruchamiającego, który znajdzie odpowiedni plik wykonywalny Pythona dla ciebie (zakładając, że masz go zainstalowany).

Tak , powyższe odpowiedzi są prawidłowe i działa poprawnie na systemach Unix, takich jak Linux i MAC OS X .

Próbowałem utworzyć virtualenv dla Python2 i Python3 za pomocą następujących poleceń.

Tutaj użyłem venv2 i venv3 jako nazwy odpowiednio dla Python2 i Python3 .

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$ 

Sprawdzanie lokalizacji instalacji 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$ 

To zadziałało dla mnie

sudo apt-get install python3-minimal

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

Używam pyenv do zarządzania moją wersją Pythona.

pyenv install 3.7.3
pyenv local 3.7.3

Sprawdź swoją wersję Pythona:

$ python --version
Python 3.7.3

Utwórz wirtualne środowisko za pomocą venv :

python -m venv .

Następnie aktywuj środowisko wirtualne:

source bin/activate

Sprawdź swoją wersję Pythona:

$ python --version
Python 3.7.3

Może być konieczne usunięcie poprzedniego środowiska wirtualnego

rm -rf bin

Te wydają się nieco skomplikowane w przypadku systemu Windows. Jeśli korzystasz z systemu Windows w Pythonie 3.3 lub nowszym, możesz użyć programu uruchamiającego Python, pyaby to zrobić o wiele łatwiej. Po prostu zainstaluj inną wersję Pythona, a następnie uruchom:

py -[my version] -m venv env

Spowoduje to utworzenie środowiska wirtualnego o nazwie envw bieżącym katalogu przy użyciu języka Python [my version]. Jako przykład:

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

Tworzy to środowisko wirtualne o nazwie envprzy użyciu python3.7 i aktywuje je. Nie wymaga ścieżek ani innych skomplikowanych rzeczy.

virtualenv -p python3 myenv

Link do tworzenia virtualenv

Dla systemów Debian (debian 9) w 2019 roku odkryłem proste rozwiązanie, które może rozwiązać problem z poziomu środowiska wirtualnego.

Załóżmy, że środowisko wirtualne zostało utworzone za pomocą:

python3.7 -m venv myenv

ale ma tylko wersje python2ipython2.7 potrzebujesz najnowszych funkcji python3.7.

Następnie wystarczy uruchomić polecenie:

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

doda pakiety python3.7, jeśli są już dostępne w twoim systemie.

To był błąd z virtualenv. Po prostu aktualizacja twojego pipa powinna być poprawką.

pip install --upgrade virtualenv

Jak już wspomniano w wielu odpowiedziach, użycie virtualenv jest czystym rozwiązaniem. Jednak małą pułapką, o której wszyscy powinni wiedzieć, jest to, że jeśli w bash_aliases ustawiony jest alias dla Pythona, taki jak:

python=python3.6

ten alias będzie również używany w środowisku wirtualnym. Tak więc w tym scenariuszu działanie python -Vw wirtualnej env będzie zawsze generowane 3.6niezależnie od tego, jakiego interpretera używa się do stworzenia środowiska:

virtualenv venv --python=pythonX.X

Działa dla mnie w systemie Windows z instalacją Pythona 2:

1. Krok 1: Zainstaluj wersję Python 3.
2. Krok 2: Utwórz folder env dla środowiska wirtualnego.
3. Krok 3: c: \ Python37 \ python -m venv c: \ ścieżka \ do \ env.

W ten sposób stworzyłem środowisko wirtualne Python 3 w mojej istniejącej instalacji Python 2.

Możesz to zrobić, wykonując następujące czynności:

virtualenv -p python3 .

Tak, wystarczy zainstalować inną wersję Pythona i zdefiniować lokalizację swojej innej wersji Pythona w swoim poleceniu, np .:

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

Oto krok po kroku, jak utworzyć środowisko wirtualne w folderze Visual Studio Code: Użyłem programu PowerShell (tryb administratora):
1. Tworzę folder VSCode - „D: \ Code_Python_VE”, w którym chcę utworzyć środowisko wirtualne.
2. Następnie wpisuję polecenie - „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
\ Activ.bat 5. D: \ Code_Python_VE> ls - Spowoduje to wyświetlenie nowego katalog „project_env”.
6. D: \ Code_Python_VE> kod. Spowoduje to uruchomienie programu Visual Studio Code. Upewnij się, że polecenie to (kod.).
7. Utwórz launch.jason z następującą zawartością:

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

(Wyszukaj, jak przejść do okna debugowania i dodaj nową konfigurację w kodzie VS).

8. Naciśnij F1 w kodzie Visual Studio, a paleta poleceń otworzy się - Wybierz Python Interpreter i wybierz środowisko wirtualne project_env.
9. Dodaj plik test.py z wydrukowanym jednym wyciągiem („Hello World”).
10. Uruchom ten program.
11. W Visual Studio Code terminal -
    (project_env) d: \ Code_Python_VE> python -m pip install - upgrade
    Mam nadzieję, że to pomoże.

UBUNTU 19.04 / Global Python 3.7.

To działało dla mnie, umożliwiając środowisko Python 3.8 przy użyciu zalecanego venv dla rozwoju Python 3.

Zainstaluj moduł Venv 3.8 i 3.8

$ sudo apt install python3.8 python3.8-venv ## oraz wszelkie inne potrzebne moduły

Utwórz wirtualne środowisko przy użyciu wersji python, którą chcesz w tej środowisku

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

przejdź do wirtualnego środowiska

$ source python38-env / bin / aktywuj

python -V = python 3.8