A Comprehensive Guide to Specifying Python Versions in Virtual Environments

The Importance of Python Virtual Environments and Version Management

In Python development, virtual environments are essential for isolating project dependencies. However, different projects may require specific Python versions, such as when libraries like Opencv3 only support particular versions. By default, virtualenv might use the system's default Python version (e.g., python3.6), leading to compatibility issues. Thus, learning to specify Python versions is crucial.

Specifying Python Versions with virtualenv

Based on best practices, virtualenv offers the -p or --python parameter to specify Python executables. This allows developers to precisely control the base Python version of the virtual environment. The following examples illustrate three common approaches:

First, if multiple Python versions are installed on the system and accessible via command aliases (e.g., python3), you can use the alias directly. For instance, to create a virtual environment based on Python 3:

$ virtualenv -p python3 new_p3_env

Here, python3 must be a valid system command, i.e., found in the PATH environment variable. This works on most Linux and Mac systems, where python3 typically points to the default Python 3.x version.

Second, for more precise version control, you can specify the absolute path to the Python executable. For example, assuming Python 3.5 is installed at /usr/bin/python3.5:

$ virtualenv -p /usr/bin/python3.5 new_env

This method ensures the virtual environment uses the exact Python binary, avoiding version confusion. It is particularly useful when multiple Python installations or custom paths exist on the system.

Additionally, virtualenv supports pointing to Python binaries from other virtual environments, offering greater flexibility. For example:

$ virtualenv -p /path/to/another_env/bin/python new_env

This can be used to create new environments based on existing ones, but dependency compatibility should be considered.

Alternative Method: Using python -m venv

Besides virtualenv, Python 3.3 and later include the built-in venv module, providing another way to create virtual environments. This method directly invokes the venv module with a specific Python version, ensuring the environment is based on that version. For example, to create a virtual environment with Python 3.5:

$ python3.5 -m venv test35

You can then verify by activating the environment and checking the Python version:

$ source test35/bin/activate
$ python --version
Python 3.5.2

This approach is straightforward but requires the target Python version to be installed and accessible via command. It suits standard Python installations, while virtualenv offers more flexibility with non-standard paths.

Practical Examples and Verification

To ensure the virtual environment uses the correct Python version, verification after creation is recommended. Here is a complete example demonstrating how to specify Python 3.5 and verify it:

# Assume the Python 3.5 executable is at /usr/local/bin/python3.5
$ virtualenv -p /usr/local/bin/python3.5 my_project_env
$ source my_project_env/bin/activate
(my_project_env) $ python --version
Python 3.5.6
(my_project_env) $ python -c "import sys; print(sys.executable)"
/usr/local/bin/python3.5

In this example, sys.executable confirms the path of the Python binary used in the virtual environment, ensuring version accuracy. If issues arise, such as the --python flag not working, it is often due to incorrect paths or permission problems; check that the path exists and has execution permissions.

Summary and Best Practices

When specifying Python versions, using virtualenv -p with an absolute path is recommended for highest precision and compatibility. For simple cases, python -m venv is also a valid option. Key steps include confirming the target Python version is installed, using the correct path, and verifying the version after creation. This helps avoid dependency conflicts and ensures projects run stably on the target Python version. In practice, combining with version management tools like pyenv can further simplify managing multiple Python versions.