New in version 3.3.
Source code: Lib/venv.py
The venv module provides support for creating lightweight “virtual environments” with their own site directories, optionally isolated from system site directories. Each virtual environment has its own Python binary (allowing creation of environments with various Python versions) and can have its own independent set of installed Python packages in its site directories.
Creation of virtual environments is done by executing the pyvenv script:
pyvenv /path/to/new/virtual/environment
Running this command creates the target directory (creating any parent directories that don’t exist already) and places a pyvenv.cfg file in it with a home key pointing to the Python installation the command was run from. It also creates a bin (or Scripts on Windows) subdirectory containing a copy of the python binary (or binaries, in the case of Windows). It also creates an (initially empty) lib/pythonX.Y/site-packages subdirectory (on Windows, this is Lib\site-packages).
On Windows, you may have to invoke the pyvenv script as follows, if you don’t have the relevant PATH and PATHEXT settings:
c:\Temp>c:\Python33\python c:\Python33\Tools\Scripts\pyvenv.py myenv
or equivalently:
c:\Temp>c:\Python33\python -m venv myenv
The command, if run with -h, will show the available options:
usage: pyvenv [-h] [--system-site-packages] [--symlinks] [--clear]
[--upgrade] ENV_DIR [ENV_DIR ...]
Creates virtual Python environments in one or more target directories.
positional arguments:
ENV_DIR A directory to create the environment in.
optional arguments:
-h, --help show this help message and exit
--system-site-packages Give access to the global site-packages dir to the
virtual environment.
--symlinks Try to use symlinks rather than copies, when symlinks
are not the default for the platform.
--clear Delete the environment directory if it already exists.
If not specified and the directory exists, an error is
raised.
--upgrade Upgrade the environment directory to use this version
of Python, assuming Python has been upgraded in-place.
If the target directory already exists an error will be raised, unless the --clear or --upgrade option was provided.
The created pyvenv.cfg file also includes the include-system-site-packages key, set to true if venv is run with the --system-site-packages option, false otherwise.
Multiple paths can be given to pyvenv, in which case an identical virtualenv will be created, according to the given options, at each provided path.
Once a venv has been created, it can be “activated” using a script in the venv’s binary directory. The invocation of the script is platform-specific:
| Platform | Shell | Command to activate virtual environment |
|---|---|---|
| Posix | bash/zsh | $ source <venv>/bin/activate |
| fish | $ . <venv>/bin/activate.fish | |
| csh/tcsh | $ source <venv>/bin/activate.csh | |
| Windows | cmd.exe | C:> <venv>/Scripts/activate.bat |
| PowerShell | PS C:> <venv>/Scripts/Activate.ps1 |
You don’t specifically need to activate an environment; activation just prepends the venv’s binary directory to your path, so that “python” invokes the venv’s Python interpreter and you can run installed scripts without having to use their full path. However, all scripts installed in a venv should be runnable without activating it, and run with the venv’s Python automatically.
You can deactivate a venv by typing “deactivate” in your shell. The exact mechanism is platform-specific: for example, the Bash activation script defines a “deactivate” function, whereas on Windows there are separate scripts called deactivate.bat and Deactivate.ps1 which are installed when the venv is created.
Note
A virtual environment (also called a venv) is a Python environment such that the Python interpreter, libraries and scripts installed into it are isolated from those installed in other virtual environments, and (by default) any libraries installed in a “system” Python, i.e. one which is installed as part of your operating system.
A venv is a directory tree which contains Python executable files and other files which indicate that it is a venv.
Common installation tools such as Distribute and pip work as expected with venvs - i.e. when a venv is active, they install Python packages into the venv without needing to be told to do so explicitly. Of course, you need to install them into the venv first: this could be done by running distribute_setup.py with the venv activated, followed by running easy_install pip. Alternatively, you could download the source tarballs and run python setup.py install after unpacking, with the venv activated.
When a venv is active (i.e. the venv’s Python interpreter is running), the attributes sys.prefix and sys.exec_prefix point to the base directory of the venv, whereas sys.base_prefix and sys.base_exec_prefix point to the non-venv Python installation which was used to create the venv. If a venv is not active, then sys.prefix is the same as sys.base_prefix and sys.exec_prefix is the same as sys.base_exec_prefix (they all point to a non-venv Python installation).
The high-level method described above makes use of a simple API which provides mechanisms for third-party virtual environment creators to customize environment creation according to their needs, the EnvBuilder class.
The EnvBuilder class accepts the following keyword arguments on instantiation:
Creators of third-party virtual environment tools will be free to use the provided EnvBuilder class as a base class.
The returned env-builder is an object which has a method, create:
This method takes as required argument the path (absolute or relative to the current directory) of the target directory which is to contain the virtual environment. The create method will either create the environment in the specified directory, or raise an appropriate exception.
The create method of the EnvBuilder class illustrates the hooks available for subclass customization:
def create(self, env_dir):
"""
Create a virtualized Python environment in a directory.
env_dir is the target directory to create an environment in.
"""
env_dir = os.path.abspath(env_dir)
context = self.create_directories(env_dir)
self.create_configuration(context)
self.setup_python(context)
self.setup_scripts(context)
self.post_setup(context)
Each of the methods create_directories(), create_configuration(), setup_python(), setup_scripts() and post_setup() can be overridden.
Creates the environment directory and all necessary directories, and returns a context object. This is just a holder for attributes (such as paths), for use by the other methods.
Creates the pyvenv.cfg configuration file in the environment.
Creates a copy of the Python executable (and, under Windows, DLLs) in the environment.
Installs activation scripts appropriate to the platform into the virtual environment.
A placeholder method which can be overridden in third party implementations to pre-install packages in the virtual environment or perform other post-creation steps.
In addition, EnvBuilder provides this utility method that can be called from setup_scripts() or post_setup() in subclasses to assist in installing custom scripts into the virtual environment.
path is the path to a directory that should contain subdirectories “common”, “posix”, “nt”, each containing scripts destined for the bin directory in the environment. The contents of “common” and the directory corresponding to os.name are copied after some text replacement of placeholders:
There is also a module-level convenience function:
Create an EnvBuilder with the given keyword arguments, and call its create() method with the env_dir argument.