Usa diverse versioni di Python con virtualenv


1116

Ho un sistema Debian attualmente in esecuzione con Python 2.5.4. Virtualenv è installato correttamente, tutto funziona bene. Esiste la possibilità che io possa usare un virtualenv con una versione diversa di Python?

Ho compilato Python 2.6.2 e vorrei usarlo con alcuni virtualenv. È sufficiente sovrascrivere il file binario? O devo cambiare qualcosa rispetto alle biblioteche?


8
Ho solo detto che puoi farlo anche usando virtualenvwrapper.
pregiudizio

13
Vale la pena notare che in Python 3 è disponibile un equivalente virtualenv incorporato : venv .
naught101

2
Non è possibile cambiare la versione di Python nell'ambiente attuale senza creare un nuovo ambiente?
Charlie Parker,

Risposte:


1542

Basta usare l' opzione --python(o breve -p) durante la creazione dell'istanza di virtualenv per specificare l'eseguibile Python che si desidera utilizzare, ad esempio:

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

NB Per Python 3.3 o versioni successive, consultare la risposta di The Aelfinn di seguito.


160
Ho pensato di menzionare che questo funziona anche per virtualenvwrappers: mkvirtualenv -p python2.6 env
bias

65
Mi manca qualcosa qui - questo non richiede che 2.6 sia già installato sul sistema? Pensavo che il punto di virtualenv fosse che avrei potuto avere una versione di Python diversa da quella principale (nel mio caso, 2.4 su CentOS). Supponevo di poter installare virtualenv, quindi installare Python 2.6 sotto di esso per i pacchetti in env da utilizzare?
Giovanni C

42
@Giovanni si. Non è questo il punto di virtualenv: il punto è quello di creare un ambiente sandbox per Python. Dovrai prima installare quella versione, ma puoi installarla localmente per il tuo utente.
Daniel Roseman,

8
@JohnC Puoi usare pythonbrew per installare pitoni alternativi.
Ashwoods,

54
Se sei un po 'pigro:virtualenv -p `which python2.6` <path/to/new/virtualenv>
divampare il

294

A partire da Python 3, Python Docs suggerisce di creare l'ambiente virtuale con il seguente comando:

python3 -m venv <myenvname>

Si noti che venvnon consente la creazione di ambienti virtuali con altre versioni di Python. Per questo, installa e usa il virtualenv pacchetto .


Informazioni obsolete

Lo pyvenv script può essere utilizzato per creare un ambiente virtuale

pyvenv /path/to/new/virtual/environment

ma è stato deprecato da Python 3.6.


8
Sono contento che tu l'abbia sottolineato, ha bisogno di più promozione. Un piccolo inconveniente: ora stanno sostenendo di eseguirlo python3 -m venv <envname>per evitare di aver bisogno di script stub per tutto.
Paul Everitt,

6
In effetti lo pyvenvscript è deprecato in Python 3.6+, anche se lo venvstesso modulo sottostante non lo è. Quindi usa python 3 -m venv <myenvname>come dice @PaulEveritt.
RichVel,

5
Attenzione pyvenvo python3 -m venv ...NON installare lo python-configscript. Ciò significa che anche dopo aver attivato l'ambiente Python3, l'intero sistema python-configverrà invocato con conseguenze confuse. Vedere questo bug report dal 2011 github.com/pypa/virtualenv/issues/169 e la mia domanda stackoverflow.com/questions/42020937/...
Laryx Decidua

1
"Nota che venvnon consente la creazione di virtualenv con altre versioni di Python." - Sei sicuro che sia vero? Sembra funzionare bene per me se lo creo con una versione specifica di Python, ad esempio python3.5 -m venv <myenvname>(a condizione che abbia quella versione di Python disponibile).
Dominick Pastore,

5
Confermare che l'osservazione di @ Nick funziona: il modo per crearne una venvcon una versione di Python specifica consiste nell'utilizzare quella versione durante l'impostazione. Ad esempio:python3.5 -m venv venv
tanius

183

Questi sono i passaggi che puoi seguire quando ti trovi in ​​un ambiente di hosting condiviso e devi installare e compilare Python dal sorgente e quindi creare venvdalla tua versione di Python. Per Python 2.7.9. faresti qualcosa in questo modo:

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 virtuale

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   

Naturalmente, questo può essere applicabile a qualsiasi situazione in cui si desidera replicare l'ambiente esatto in cui si lavora e si distribuisce.


2
Potresti approfondire il motivo per cui farlo in questo modo: Perché installare Python localmente? E, soprattutto, perché installare virtualenv usando la versione di Python che vuoi usare con esso ?
lajarre

15
sicuro. Se ti trovi in ​​un ambiente di hosting virtuale e il server fornisce versioni precedenti di Python di cui non sei soddisfatto, quello era il mio caso. Inoltre, se ti capita di sviluppare progetti su server diversi e vuoi replicare questi ambienti sul tuo computer locale .... Virtualenv crea collegamenti reali alle librerie Python. quindi è davvero importante con la versione di Python che stai usando per installare e creare Virtualenv.
zzart,

6
O se sei come me e sono su una macchina bloccata al lavoro senza privilegi di sudo. Copie locali di librerie, database SQL, lingue e compilatori a bizzeffe! Grazie!
zachd1_618,

4
Sotto virtualenv 1.9.1, ho dovuto usare ~/.localpython/bin/virtualenvinvece solo virtualenvper completare l'installazione senza errori. Inoltre, utilizzare source ve/bin/activateinvece di source activate.
Saul

3
Un altro motivo per farlo sarebbe provare le beta prima che diventino principali per assicurarsi che i tuoi progetti e le loro dipendenze continuino a funzionare senza rischiare di interrompere la gestione dei pacchetti bloccando qualcosa e lasciando file sospesi ovunque. Mi piace questa risposta.
RobotHumans,

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

2
Vedi la mia risposta di seguito per una soluzione equivalente che utilizza le variabili di ambiente. Questo approccio significa che non devi ricordarti di usare -p.
Chris Johnson,

5
Non esistono soluzioni che cambiano tra le versioni di Python senza la necessità di creare un nuovo ambiente virtuale?
Charlie Parker,

3
Funzionerebbe se si desidera installare una versione di Python non installata sul proprio sistema? Hai detto di voler provare python3.6ma non vuoi toccare python3.5installato sul tuo computer?
alpha_989

1
@ alpha_989 trovi la soluzione per farlo?
Daniil Mashkin,

97

C'è un modo più semplice,

virtualenv venv --python=python2.7

Grazie a un commento, questo funziona solo se hai installato python2.7 a livello di sistema (ad es. /Usr/bin/python2.7).

Altrimenti, se usi l'homebrew puoi usare il percorso per darti quello che vuoi.

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

Puoi trovare il percorso per la tua installazione di Python con

which python

Funzionerà anche con Python 3.

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

In definitiva condensando a:

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

1
Cordiali saluti, funziona solo se hai installato python2.7 a livello di sistema (ad esempio /usr/bin/python2.7)
kingb12

Sono stato in grado di fare questo con virtualenv venv --python=python3.6così
Jordan

Puoi effettivamente rilasciare il numero di versione secondario. virtualenv env --python=python2
Anshul,

Questa è una soluzione adeguata, una volta che hai tutte le versioni, sei interessato a usare semplicemente l'alias non il percorso completo
user1767754

In Windows, questo ha funzionato come un incantesimo con una piccola modifica: virtualenv venv --python=<insert_your_python_version_here>dov'era <insert_your_python_version_here>nel mio casoC:\Python\Python368\python.exe
abautista

70

Sotto Windows per me questo funziona:

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

senza il python.exemio WindowsError: [Error 5] Access is denied ho Python2.7.1 installato con virtualenv 1.6.1 e volevo python 2.5.2.


32

Mac OSX 10.6.8 (Snow Leopard):

1) Quando lo fai pip install virtualenv, il comando pip è associato a una delle tue versioni di Python e virtualenvviene installato in quella versione di Python. Tu puoi fare

 $ which pip   

per vedere quale versione di Python è. Se vedi qualcosa come:

 $ which pip
 /usr/local/bin/pip

Quindi fa:

$ 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

Puoi vedere la versione di Python nell'output.

Per impostazione predefinita, quella sarà la versione di Python utilizzata per qualsiasi nuovo ambiente creato. Tuttavia, puoi specificare qualsiasi versione di Python installata sul tuo computer da utilizzare all'interno di un nuovo ambiente con -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 creerà una cartella nella directory corrente che conterrà i file eseguibili Python e una copia del pip [comando] che è possibile utilizzare per installare altri pacchetti.

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

virtualenv copia semplicemente Python da una posizione sul tuo computer nella directory my_env / bin / appena creata.

2) Il sistema Python è in /usr/bin, mentre le varie versioni di Python che ho installato sono state, per impostazione predefinita, installate in:

 /usr/local/bin

3) I vari pitoni che ho installato hanno nomi come python2.7o python3.2, e posso usare quei nomi piuttosto che percorsi completi.

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

1) Ho avuto dei problemi a far funzionare virtualenvwrapper. Questo è quello che ho finito per mettere ~/.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 optionFunziona diversamente con virtualenvwrapper: devo specificare il percorso completo dell'interprete Python da utilizzare nel nuovo ambiente (quando non voglio usare la versione predefinita di Python):

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

A differenza di virtualenv, virtualenvwrapper creerà l'ambiente nella posizione specificata dalla variabile di ambiente $ WORKON_HOME. Ciò mantiene tutti i tuoi ambienti in un unico posto.


which pipnon mi dice la versione di Python. Mi dà questo- /usr/local/bin/pip.
Sankalp,

@Sankalp, se fai cd /usr/local/bine fai $ ls -al pip, dovresti vedere qualcosa del genere: pip -> ../../../Library/Frameworks/Python.framework/Versions/2.7/bin/pip
7stud

Già un po 'notato nella risposta, ma mkprojectè il comando da utilizzare se si desidera che crei sia la directory del progetto che un ambiente virtuale di una determinata versione di Python. mkproject -p /usr/bin/python3.6 myNewPython36Project
Jim Factor

22

Questi due comandi dovrebbero funzionare correttamente.

virtualenv -p python2 myenv (Per python2)

virtualenv -p python3 myenv (Per python3)


1
Il flag -p python2 funziona in modo equivalente alla ricerca di / usr / bin / python2. Usa: virtualenv -p python2.7 myenv per 2.7 ecc.
Yash Sharma,

21

Supponiamo che tu abbia attualmente installato Python 2.7 nel tuo VirtualENV. Ma vuoi farne uso python3.2, dovresti aggiornarlo con:

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

Quindi attiva il tuo virtualenv :

$ source activate name_of_your_virtualenv

e poi fai: python --versionin shell per verificare se la tua versione è ora aggiornata.


Vedi la mia risposta di seguito per una soluzione equivalente che utilizza le variabili di ambiente. Questo approccio significa che non devi ricordarti di usare -p.
Chris Johnson,

13

Puoi chiamare virtualenvcon la versione di Python che desideri. Per esempio:

python3 -m virtualenv venv

O in alternativa, punta direttamente al tuo percorso virtualenv. ad es. per windows:

c:\Python34\Scripts\virtualenv.exe venv

E eseguendo:

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

puoi vedere la versione di Python installata nell'ambiente virtuale


Ho ricevuto questo errore nell'esecuzione del primo comando / usr / local / bin / python3: nessun modulo chiamato virtualenv
tanvi,

2
@tanvi: devi prima installare virtualenv in python3. Corri per pip3 install virtualenvprimo
Nima Soroush,

12

Il -p approccio funziona bene, ma devi ricordarti di usarlo ogni volta. Se il tuo obiettivo è passare a una versione più recente di Python in generale, questo è un dolore e può anche portare a errori.

L'altra opzione è impostare una variabile d'ambiente che faccia la stessa cosa di -p. Impostalo tramite il tuo ~/.bashrcfile o ovunque gestisci le variabili di ambiente per le tue sessioni di accesso:

export VIRTUALENV_PYTHON=/path/to/desired/version

Quindi virtualenvlo userai ogni volta che non specifichi -psulla riga di comando.


Questo ha funzionato magnificamente. Qualche idea sul perché l'impostazione export VIRTUALENVWRAPPER_PYTHON=/path/to/desired/versionsecondo i documenti virtualenvwrapper non ha funzionato ma questa soluzione ha funzionato?
YPCrumble

Quel var var controlla che Python virtualenvwrapperusa durante l'esecuzione, niente a che fare con le installazioni.
Chris Johnson,

Questo ha funzionato per me. Non è più necessario utilizzare -p ogni volta che creo un nuovo virtualenv. Grazie!
nedblorf,

7

Ancora più semplice, usando la sostituzione dei comandi per trovare python2 per te:

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

O quando si utilizza virtualenvwrapper:

mkvirtualenv -p $(which python2) <env_name>


7

Per Mac (High Sierra), installa virtualenv su python3 e crea un virtualenv per python2:

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

1
Installa virtualenv su python3 se non hai:python3 -m pip install virtualenv
Zihao Zhao

Non funziona La mia versione di Python è ancora 3.
shivendra pratap singh

6

Sul Mac uso pyenv e virtualenvwrapper. Ho dovuto creare un nuovo virtualenv. Hai bisogno di homebrew che suppongo tu abbia installato se sei su un Mac, ma solo per divertimento:

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}

Ho anche bloccato i miei requisiti prima di poter semplicemente reinstallare nella nuova virtualenv con:

pip install -r requirements.txt

Il comando dovrebbe essere mkvirtualenv -p ~/.pyenv/versions/2.7.10/bin/python {virtual_env_name}versioni, non versione. Se SO consentisse modifiche brevi, l'avrei riparato.
Martin Burch,

pyenvinclude il supporto di virtualenv tramite il pyenv-virtualenvplugin, quindi trovo che non ho davvero bisogno di virtualenvwrapper. Maggiori dettagli nella mia risposta pyenv .
RichVel

5

[Novembre 2019] Avevo bisogno di installare un ambiente Python 3.7 (env) sul mio sistema Arch Linux basato su Python 3.8. Python 3.7 non era più sul sistema, quindi non potevo effettuare il downgrade di Python per installare un pacchetto di cui avevo bisogno.

Inoltre, volevo usare quel pacchetto / Python 3.7 in un ambiente virtuale (venv). È così che l'ho fatto.


Scarica i file sorgente della versione Python:

Ho scaricato i file sorgente di Python 3.7.4 da

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

per

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

Ho quindi estratto quell'archivio (file sorgente) in

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


Installazione:

[Nota: nel mio sistema env, non 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

Esamina le versioni di Python installate:

$ 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

Come creare un venv per una versione specifica di Python:

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

12.2. CREAZIONE DI AMBIENTI VIRTUALI

Viene chiamato il modulo utilizzato per creare e gestire ambienti virtuali venv.venvdi solito installa la versione più recente di Python disponibile. Se hai più versioni di Python sul tuo sistema, puoi selezionare una versione specifica di Python eseguendo python3 o la versione che desideri.

Per creare un ambiente virtuale, decidere su una directory in cui si desidera posizionarlo ed eseguire il modulo venv come script con il percorso della directory:

python3 -m venv tutorial-env

Questo creerà la tutorial-envdirectory se non esiste, e creerà anche delle directory al suo interno contenenti una copia dell'interprete Python, la libreria standard e vari file di supporto. ...


Crea Python 3.7 venv [su un sistema operativo env / sistema 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)

Aggiunto a ~/.bashrc:

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

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

1
Questa è una risposta estremamente approfondita! :) Riscontro questo problema ogni volta che devo trasferire qualcosa da Arch Linux a qualsiasi altro sistema (ad es. Debian-ish).
Robbie Capps,

1
@Victoria Stuart, grazie mille. Questo e 'esattamente quello che stavo cercando.
daddyodevil

4

Nel sottosistema Windows per Linux:

  1. Creare un ambiente per python3:

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

    source env/bin/activate

3

Su Windows:

py -3.4x32 -m venv venv34

o

py -2.6.2 -m venv venv26

Questo utilizza il programma di pyavvio che troverà il giusto eseguibile python per te (supponendo che tu l'abbia installato).


3

, le risposte di cui sopra sono corrette e funzionano bene su sistemi basati su Unix come Linux e MAC OS X. .

Ho provato a creare virtualenv per Python2 e Python3 con i seguenti comandi.

Qui ho usato venv2 e venv3 come nomi per Python2 e Python3 rispettivamente.

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$ 

Verifica dei percorsi di installazione di 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$ 

2

Ha funzionato per me

sudo apt-get install python3-minimal

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

2

Uso pyenv per gestire la mia versione di Python.

pyenv install 3.7.3
pyenv local 3.7.3

Controlla la tua versione di Python:

$ python --version
Python 3.7.3

Crea l'ambiente virtuale con venv :

python -m venv .

Quindi attivare l'ambiente virtuale:

source bin/activate

Controlla la tua versione di Python:

$ python --version
Python 3.7.3

Potrebbe essere necessario rimuovere l'ambiente virtuale precedente

rm -rf bin

2

Questi sembrano un po 'troppo complicati per Windows. Se sei su Windows con Python 3.3 o versioni successive, puoi utilizzare Python Launcher pyper farlo molto più facilmente. Installa semplicemente la diversa versione di Python, quindi esegui:

py -[my version] -m venv env

Questo creerà un ambiente virtuale chiamato envnella directory corrente, usando Python [my version]. Come esempio:

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

Questo crea un ambiente virtuale chiamato envusando python3.7 e lo attiva. Non sono richiesti percorsi o altre cose complesse.


Non dovrebbe essere py -3.7 -m venv envinvece ( -mmanca)?
sinoroc

Sì, risolto nel post !.
Cole Smith,


1

Per Debian (debian 9) Systems nel 2019, ho scoperto una soluzione semplice che potrebbe risolvere il problema all'interno dell'ambiente virtuale.

Supponiamo che l'ambiente virtuale sia stato creato tramite:

python3.7 -m venv myenv

ma ha solo versioni di python2epython2.7 , ed è necessario le caratteristiche recenti di python3.7.

Quindi, semplicemente eseguendo il comando:

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

aggiungerà i pacchetti python3.7 se sono già disponibili sul tuo sistema.


1

Questo era un bug con virtualenv. Solo l'aggiornamento del pip dovrebbe essere la soluzione.

pip install --upgrade virtualenv


1

Come già accennato in più risposte, l'utilizzo di virtualenv è una soluzione pulita. Tuttavia, una piccola trappola di cui tutti dovrebbero essere consapevoli è che se un alias per Python è impostato in bash_aliases come:

python=python3.6

questo alias verrà utilizzato anche all'interno dell'ambiente virtuale. Quindi, in questo scenario, l'esecuzione python -Vall'interno dell'env virtuale produrrà sempre un output 3.6indipendentemente dall'interprete utilizzato per creare l'ambiente:

virtualenv venv --python=pythonX.X

0

Ha funzionato per me su Windows con l'installazione di Python 2:

  1. Passaggio 1: installa la versione di python 3.
  2. Passaggio 2: creare una cartella env per l'ambiente virtuale.
  3. Passaggio 3: c: \ Python37 \ python -m venv c: \ path \ to \ env.

È così che ho creato l'ambiente virtuale Python 3 sulla mia installazione esistente di Python 2.



0

Sì, devi solo installare l'altra versione di Python e definire la posizione dell'altra versione di Python nel tuo comando come:

virtualenv / home / paghe / Documenti / env -p / usr / bin / python3


0

Ecco il passo passo come creare l'ambiente virtuale nella cartella del codice di Visual Studio: Ho usato Powershell (modalità amministratore):
1. Creo una cartella VSCode - "D: \ Code_Python_VE" dove voglio creare un ambiente virtuale.
2. Quindi digito il comando "pip3 install virtualenv". (D: \ Code_Python_VE> pip3 installa 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 - Verrà elencato un nuovo directory "project_env".
6. D: \ Code_Python_VE> codice. Questo avvierà il codice di Visual Studio. Assicurarsi che il comando sia (codice.).
7. Creare launch.jason con il seguente contenuto:

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

(Cerca come andare alla finestra Debug e Aggiungi nuova configurazione in VS Code).

  1. Premi F1 nel codice di Visual Studio e si aprirà il pannello di comando - Seleziona Python Interpreter e seleziona l'ambiente virtuale project_env.
  2. Aggiungi il file test.py con una stampa dell'istruzione ("Hello World").
  3. Esegui questo programma.
  4. Nel terminale di Visual Studio Code -
    (project_env) d: \ Code_Python_VE> python -m pip install --upgrade
    Spero che questo aiuti.

-2

UBUNTU 19.04 / Global Python 3.7.

Questo ha funzionato per me, abilitando un ambiente Python 3.8 usando la venv consigliata per lo sviluppo di python 3.

Installare i moduli venv 3.8 e 3.8

$ sudo apt installa python3.8 python3.8-venv ## e qualsiasi altro modulo necessario

Crea il tuo Virtual Env usando la versione di Python che desideri in quel env

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

passa al tuo ambiente virtuale

$ source python38-env / bin / activ

python -V = python 3.8

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.