Use different Python version with virtualenv
PythonVirtualenvVirtualenvwrapperPython Problem Overview
I have a Debian system currently running with python 2.5.4. I got virtualenv properly installed, everything is working fine. Is there a possibility that I can use a virtualenv with a different version of Python?
I compiled Python 2.6.2 and would like to use it with some virtualenv. Is it enough to overwrite the binary file? Or do I have to change something in respect to the libraries?
Python Solutions
Solution 1 - Python
Just use the --python
(or short -p
) option when creating your virtualenv instance to specify the Python executable you want to use, e.g.:
virtualenv --python=/usr/bin/python2.6 <path/to/new/virtualenv/>
N.B. For Python 3.3 or later, refer to The Aelfinn's answer below.
Solution 2 - Python
Since Python 3, [the Python Docs suggest][1] creating the virtual environment with the following command:
python3 -m venv <myenvname>
Please note that venv
does not permit creating virtual environments with other versions of Python. For that, install and use the virtualenv
[package][2].
Obsolete information
The pyvenv
[script][1] can be used to create a virtual environment
pyvenv /path/to/new/virtual/environment
but it has been deprecated since Python 3.6.
[1]: https://docs.python.org/3/library/venv.html "Python 3.6.4 documentation - Creation of virtual environments" [2]: https://pypi.python.org/pypi/virtualenv
Solution 3 - Python
These are the steps you can follow when you are on a shared hosting environment and need to install & compile Python from source and then create venv
from your Python version. For Python 2.7.9. you would do something along these lines:
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
virtual env
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
Naturally, this can be applicable to any situation where you want to replicate the exact environment you work and deploy on.
Solution 4 - Python
There is an easier way,
virtualenv venv --python=python2.7
Thanks to a comment, this only works if you have python2.7 installed at the system level (e.g. /usr/bin/python2.7).
Otherwise, if you are using homebrew you can use the path to give you what you want.
virtualenv venv --python=/usr/local/bin/python
You can find the path to your python installation with
which python
This will also work with python 3.
which python3
>> /usr/local/bin/python3
virtualenv venv --python=/usr/local/bin/python3
Ultimately condensing to:
virtualenv venv -p `which python`
virtualenv venv -p `which python3`
Solution 5 - Python
virtualenv --python=/usr/bin/python2.6 <path/to/myvirtualenv>
Solution 6 - Python
Under Windows for me this works:
virtualenv --python=c:\Python25\python.exe envname
without the python.exe
I got WindowsError: [Error 5] Access is denied
I have Python2.7.1 installed with virtualenv 1.6.1, and I wanted python 2.5.2.
Solution 7 - Python
Mac OSX 10.6.8 (Snow Leopard):
-
When you do
pip install virtualenv
, the pip command is associated with one of your python versions, andvirtualenv
gets installed into that version of python. You can do$ which pip
to see what version of python that is. If you see something like:
$ which pip
/usr/local/bin/pip
then do:
$ 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
You can see the python version in the output.
By default, that will be the version of python that is used for any new environment you create. However, you can specify any version of python installed on your computer to use inside a new environment with the -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
will create a folder in the current directory which
> will contain the Python executable files, and a copy of the pip
> [command] which you can use to install other packages.
http://docs.python-guide.org/en/latest/dev/virtualenvs/
virtualenv
just copies python from a location on your computer into the newly created my_env/bin/ directory.
-
The system python is in
/usr/bin
, while the various python versions I installed were, by default, installed into:/usr/local/bin
-
The various pythons I installed have names like
python2.7
orpython3.2
, and I can use those names rather than full paths.
========VIRTUALENVWRAPPER=========
-
I had some problems getting virtualenvwrapper to work. This is what I ended up putting in
~/.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
-
The
-p option
works differently with virtualenvwrapper: I have to specify the full path to the python interpreter to be used in the new environment(when I do not want to use the default python version):$ 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.
Unlike virtualenv, virtualenvwrapper will create the environment at the location specified by the $WORKON_HOME environment variable. That keeps all your environments in one place.
Solution 8 - Python
[November 2019] I needed to install a Python 3.7 environment (env) on my Python 3.8-based Arch Linux system. Python 3.7 was no longer on the system, so I could not downgrade Python, to install a package that I needed.
Furthermore, I wanted to use that package / Python 3.7 inside a virtual environment (venv). This is how I did it.
Download Python version source files:
I downloaded the Python 3.7.4 source files from
> https://www.python.org/downloads/source/
to
/mnt/Vancouver/apps/python_versions/src/Python-3.7.4.tgz
I then extracted that archive (source files) to
/mnt/Vancouver/apps/python_versions/src/Python-3.7.4/
Installation:
[Note: in my system env, not a 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
Examine installed Python versions:
$ 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
How to create a venv for a specific Python version:
> https://docs.python.org/3/tutorial/venv.html
> 12.2. CREATING VIRTUAL ENVIRONMENTS
> The module used to create and manage virtual environments is called venv
. venv
will usually install the most recent version of Python that you have available. If you have multiple versions of Python on your system, you can select a specific Python version by running python3 or whichever version you want.
> To create a virtual environment, decide upon a directory where you want to place it, and run the venv module as a script with the directory path:
>> python3 -m venv tutorial-env
> This will create the tutorial-env
directory if it doesn’t exist, and also create directories inside it containing a copy of the Python interpreter, the standard library, and various supporting files.
> ...
Create Python 3.7 venv [on a Python 3.8 operating env / system]:
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)
Added to ~/.bashrc
:
alias p37='echo " [Python 3.7 venv (source ~/venv/py3.7/bin/activate)]" && source ~/venv/py3.7/bin/activate'
Test 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]
>>>
Solution 9 - Python
Suppose you currently have python 2.7 installed in your virtualenv. But want to make use of python3.2
, You would have to update this with:
$ virtualenv --python=/usr/bin/python3.2 name_of_your_virtualenv
Then activate your virtualenv by:
$ source activate name_of_your_virtualenv
and then do: python --version
in shell to check whether your version is now updated.
Solution 10 - Python
You should have that Python version installed. If you have it then basically,
With virtualenv,
virtualenv --python=python3.8 env/place/you/want/to/save/to
with venv
python3.8 -m venv env/place/you/want/to/save/to
The above examples are for python3.8, you can change it to have different versions of virtual environments given that they are installed in your computer.
Solution 11 - Python
These two commands should work fine.
virtualenv -p python2 myenv
(For python2)
virtualenv -p python3 myenv
(For python3)
Solution 12 - Python
You can call virtualenv
with python version you want. For example:
python3 -m virtualenv venv
Or alternatively directly point to your virtualenv path. e.g. for windows:
c:\Python34\Scripts\virtualenv.exe venv
And by running:
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.
>>>
you can see the python version installed in virtual environment
Solution 13 - Python
The -p
approach works well, but you do have to remember to use it every time. If your goal is to switch to a newer version of Python generally, that's a pain and can also lead to mistakes.
Your other option is to set an environment variable that does the same thing as -p
. Set this via your ~/.bashrc
file or wherever you manage environment variables for your login sessions:
export VIRTUALENV_PYTHON=/path/to/desired/version
Then virtualenv
will use that any time you don't specify -p
on the command line.
Solution 14 - Python
On the mac I use pyenv and virtualenvwrapper. I had to create a new virtualenv. You need homebrew which I'll assume you've installed if you're on a mac, but just for fun:
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}
I also froze my requirements first so i could simply reinstall in the new virtualenv with:
pip install -r requirements.txt
Solution 15 - Python
Even easier, by using command substitution to find python2 for you:
virtualenv -p $(which python2) <path/to/new/virtualenv/>
Or when using virtualenvwrapper :
mkvirtualenv -p $(which python2) <env_name>
Solution 16 - Python
For Mac(High Sierra), install the virtualenv on python3 and create a virtualenv for python2:
$ python3 -m pip install virtualenv
$ python3 -m virtualenv --python=python2 vp27
$ source vp27/bin/activate
(vp27)$ python --version
Python 2.7.14
Solution 17 - Python
These seem a little overcomplicated for Windows. If you're on Windows running python 3.3 or later, you can use the python launcher py
to do this much more easily. Simply install the different python version, then run:
py -[my version] -m venv env
This will create a virtual environment called env
in your current directory, using python [my version]
. As an example:
py -3.7 -m venv env
./env/Scripts/activate
This creates a virtual environment called env
using python3.7 and activates it. No paths or other complex stuff required.
Solution 18 - Python
On windows:
py -3.4x32 -m venv venv34
or
py -2.6.2 -m venv venv26
This uses the py
launcher which will find the right python executable for you (assuming you have it installed).
Solution 19 - Python
As already mentioned in multiple answers, using virtualenv is a clean solution. However a small pitfall that everyone should be aware of is that if an alias for python is set in bash_aliases like:
python=python3.6
this alias will also be used inside the virtual environment. So in this scenario running python -V
inside the virtual env will always output 3.6
regardless of what interpreter is used to create the environment:
virtualenv venv --python=pythonX.X
Solution 20 - Python
In windows subsystem for linux:
-
Create environment for python3:
virtualenv --python=/usr/bin/python3 env
-
Activate it:
source env/bin/activate
Solution 21 - Python
I use pyenv to manage my python version.
pyenv install 3.7.3
pyenv local 3.7.3
Check your python version:
$ python --version
Python 3.7.3
Create the virtual environment with venv:
python -m venv .
Then activate the Virtual Environment:
source bin/activate
Check your python version:
$ python --version
Python 3.7.3
You may need to remove the previous virtual environment
rm -rf bin
Solution 22 - Python
End of 2020:
The most seamless experience for using virtualenv (added benefit: with any possible python version) would be to use pyenv and its (bundled) pyenv-virtualenv plugin (cf https://realpython.com/intro-to-pyenv/#virtual-environments-and-pyenv)
Usage: pyenv virtualenv <python_version> <environment_name>
Installation:
- first check that you've got all prerequisites (depending on your OS): https://github.com/pyenv/pyenv/wiki/Common-build-problems#prerequisites
curl https://pyenv.run | bash
exec $SHELL
cf https://github.com/pyenv/pyenv-installer
That being said, nowadays the best possible alternative instead of using virtualenv
(and pip
) would be Poetry (along with pyenv
indicated above, to handle different python versions).
Another option, because it's supported directly by the PyPA (the org behind pip
and the PyPI) and has restarted releasing since the end of May (didn't release since late 2018 prior to that...) would be Pipenv
Solution 23 - Python
This worked for my usage in Windows 10, where I have Python 3.7 and want to downgrade for a project in Python 3.6.6:
I used "venv" to create a new environment called "venv", I downloaded from https://www.python.org/downloads/windows/ ; install "Download Windows x86-64 executable installer-" ; then I used the following command line in the directory where I want to create my environment
>C:\Users\...\Python\Python36\python.exe -m venv venv
Finally, I activated the environnent using the command line:
>venv\Scripts\activate.bat
And check the python version by calling:
>python --version
Python 3.6.6
Solution 24 - Python
I utilized this answer for Windows
https://stackoverflow.com/a/22793687/15435022
py -3.4 -m venv c:\path\to\wherever\you\want\it
Solution 25 - Python
Yes, the above answers are correct and works fine on Unix based systems like Linux & MAC OS X.
I tried to create virtualenv for Python2 & Python3 with the following commands.
Here I have used venv2 & venv3 as their names for Python2 & Python3 respectively.
> 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$
> Checking Python installation locations
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$
Solution 26 - Python
On Linux Ubuntu 21.04 (currently Python 3.9.5) I needed to get a virtualenv of Python 3.7.8. Full steps to get working:
Find the Python version source you want, for example 3.7.8 is here: https://www.python.org/downloads/release/python-378/
Download the Gzipped source tarball
Unzip it with tar zxvf Python-3.7.8.tgz
(amend as required with your version number if different from 3.7.8)
Copy the unzipped folder to /usr/bin with: sudo cp -r Python-3.7.8 /usr/bin
cd /usr/bin/Python-3.7.8/
Check the contents if you wanted to see what you have so far: ls
sudo time ./configure
sudo time make
time sudo make install
time make clean
Check how your python is set up and reporting:
which python
python --version
Should be all relating to your primary install (Python 3.9.5 for me)
To check your new install:
which python 3.7
python3.7 --version
Should be all relating to your 3.7.8 install
If you want to run it to check, do:
python3.7
exit()
Install venv:
sudo apt install venv
To create a venv (maybe in your repo, if so, add .venv to .gitignore):
python3.7 -m venv .venv
To activate your venv:
source .venv/bin/activate
Check your version:
python --version
Solution 27 - Python
It worked for me
sudo apt-get install python3-minimal
virtualenv --no-site-packages --distribute -p /usr/bin/python3 ~/.virtualenvs/py3
Solution 28 - Python
virtualenv -p python3 myenv
Solution 29 - Python
This was a bug with virtualenv. Just upgrading your pip should be the fix.
pip install --upgrade virtualenv
Solution 30 - Python
I use Windows so I should use .exe
on the pthon path
virtualenv -p=C:\Python27\python2.exe <envname>
Solution 31 - Python
For Debian (debian 9) Systems in 2019, I discovered a simple solution that may solve the problem from within the virtual environment.
Suppose the virtual environment were created via:
python3.7 -m venv myenv
but only has versions of python2
and python2.7
, and you need the recent features of python3.7.
Then, simply running the command:
(myvenv) $ python3.7 -m venv --upgrade /home/username/path/to/myvenv/
will add python3.7 packages if they are already available on your system.
Solution 32 - Python
It worked for me on windows with python 2 installation :
- Step 1: Install python 3 version .
- Step 2: create a env folder for the virtual environment.
- Step 3 : c:\Python37\python -m venv c:\path\to\env.
This is how i created Python 3 virtual environment on my existing python 2 installation.
Solution 33 - Python
Yes you just need to install the other version of python, and define the location of your other version of python in your command like :
>>> virtualenv /home/payroll/Documents/env -p /usr/bin/python3
Solution 34 - Python
Here is the stepbystep how to create the Virtual environment in Visual Studio Code folder: I used Powershell (Administrator mode):
-
I create a VSCode folder - "D:\Code_Python_VE" where I want to create Virtual environment.
-
Next I type the command - "pip3 install virtualenv". (D:\Code_Python_VE> pip3 install virtualenv)
-
D:\Code_Python_VE> python3 -m venv project_env
-
D:\Code_Python_VE>project_env\Scripts\activate.bat
-
D:\Code_Python_VE> ls - This will list a new directory "project_env".
-
D:\Code_Python_VE> code . This will start Visual Studio Code. Make sure the command is (code .).
-
Create launch.jason with following content:
{ // 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" } ] }
(Please search how to go to Debug window and Add new Configuration in VS Code).
- Press F1 in Visual studio code and the command pallet will open - Select Python Interpreter and select the virtual environment project_env.
- Add test.py file with one statement print("Hello World").
- Run this program.
- In Visual studio Code terminal -
(project_env) d:\Code_Python_VE>python -m pip install --upgrade
I hope this helps.
Solution 35 - Python
UBUNTU 19.04 / Global Python 3.7.
This worked for me, enabling a Python 3.8 environment using the recommended venv for python 3 development.
Install 3.8 and 3.8 venv module:
$ sudo apt install python3.8 python3.8-venv
plus any other modules you need
Create your Virtual Env using the python version you want in that env
$ /usr/bin/python3.8 -m venv python38-env
switch into your virtual env
$ source python38-env/bin/activate
python -V = python 3.8
Solution 36 - Python
Surprised that no one has mentioned conda
so far. I have found this is a lot more straightforward than the other methods mentioned here. Let's say I have python 3.9 and python 2.7 and a project I am working on was python 3.5.4, I could simply create the isolated virtual env for 3.5.4 with the conda command without downloading anything else.
To see a list of available python versions first, use the command
conda search "^python$"
To create the virtual environment for python version x.y.z, use the command
conda create -n yourenvname python=x.y.z
Activate venv with
conda activate yourenvname
Deactivate with
conda deactivate
To delete the virtual environment when done, use the command
conda remove -n yourenvname --all