venv — Virtuelle Umgebungen erstellen

Added in version 3.3.

Quellcode: Lib/venv/

Mit dem Modul venv lassen sich schlanke „virtuelle Umgebungen“ erstellen, die jeweils ihren eigenen, unabhängigen Satz an Python-Paketen in ihren site-Verzeichnissen haben. Eine virtuelle Umgebung wird auf einer vorhandenen Python-Installation aufgesetzt, dem „Basis“-Python der virtuellen Umgebung, und ist von den Paketen der Basisumgebung standardmäßig abgeschottet. Verfügbar sind damit nur die Pakete, die ausdrücklich in der virtuellen Umgebung installiert wurden. Näheres steht unter Virtual Environments und in der Dokumentation zu virtuellen Umgebungen von site.

Aus einer virtuellen Umgebung heraus aufgerufen, installieren verbreitete Installationswerkzeuge wie pip Python-Pakete von selbst in diese virtuelle Umgebung, ohne dass man es ihnen ausdrücklich sagen muss.

Eine virtuelle Umgebung ist unter anderem:

  • Ein Behälter für einen bestimmten Python-Interpreter sowie für Programmbibliotheken und Binärdateien, die ein Projekt (eine Bibliothek oder eine Anwendung) braucht. Diese sind standardmäßig abgeschottet gegenüber der Software in anderen virtuellen Umgebungen und gegenüber den im Betriebssystem installierten Python-Interpretern und Bibliotheken.

  • In einem Verzeichnis untergebracht, das üblicherweise .venv oder venv heißt und im Projektverzeichnis liegt, oder in einem Sammelverzeichnis für viele virtuelle Umgebungen wie ~/.virtualenvs.

  • Nicht in Versionsverwaltungen wie Git eingecheckt.

  • Als Wegwerfartikel zu betrachten: Sie sollte sich einfach löschen und von Grund auf neu anlegen lassen. Projektcode legst du nicht in der Umgebung ab.

  • Nicht zum Verschieben oder Kopieren gedacht: Du legst dieselbe Umgebung einfach am Zielort neu an.

Mehr Hintergrund zu virtuellen Python-Umgebungen steht in PEP 405.

Siehe auch

Python Packaging User Guide: Erstellen und Verwenden virtueller Umgebungen

Verfügbarkeit: not Android, not iOS, not WASI.

Dieses Modul wird auf mobilen Plattformen und WebAssembly-Plattformen nicht unterstützt.

Virtuelle Umgebungen erstellen

Virtuelle Umgebungen werden erstellt, indem man das Modul venv ausführt:

python -m venv /path/to/new/virtual/environment

Dabei wird das Zielverzeichnis angelegt, bei Bedarf samt der übergeordneten Verzeichnisse, und darin eine Datei pyvenv.cfg abgelegt, deren Schlüssel home auf die Python-Installation zeigt, aus der der Befehl ausgeführt wurde. Außerdem entsteht ein Unterverzeichnis bin (unter Windows Scripts) mit einer Kopie oder einem symbolischen Verweis auf das ausführbare Python, je nachdem, was zur Plattform und zu den beim Erstellen angegebenen Argumenten passt. Ebenso entsteht ein Unterverzeichnis lib/pythonX.Y/site-packages, unter Windows Lib\site-packages. Ist ein bereits vorhandenes Verzeichnis angegeben, wird es weiterverwendet.

Geändert in Version 3.5: Die Verwendung von venv wird nun für das Erstellen virtueller Umgebungen empfohlen.

Veraltet seit Version 3.6, entfernt in Version 3.8: pyvenv war in Python 3.3 und 3.4 das empfohlene Werkzeug, um virtuelle Umgebungen zu erstellen. In 3.5 wurde es durch den direkten Aufruf von venv ersetzt.

Unter Windows rufst du den Befehl venv so auf:

PS> python -m venv C:\path\to\new\virtual\environment

Mit -h aufgerufen, zeigt der Befehl die verfügbaren Optionen:

usage: venv [-h] [--system-site-packages] [--symlinks | --copies] [--clear]
            [--upgrade] [--without-pip] [--prompt PROMPT] [--upgrade-deps]
            [--without-scm-ignore-files]
            ENV_DIR [ENV_DIR ...]

Creates virtual Python environments in one or more target directories.

Once an environment has been created, you may wish to activate it, e.g. by
sourcing an activate script in its bin directory.
ENV_DIR

Ein erforderliches Argument, das das Verzeichnis angibt, in dem die Umgebung erstellt wird.

--system-site-packages

Gibt der virtuellen Umgebung Zugriff auf das site-packages-Verzeichnis des Systems.

Versucht, symbolische Verweise statt Kopien zu verwenden, wenn symbolische Verweise auf der Plattform nicht die Vorgabe sind.

--copies

Versucht, Kopien statt symbolischer Verweise zu verwenden, auch wenn symbolische Verweise auf der Plattform die Vorgabe sind.

--clear

Löscht den Inhalt des Umgebungsverzeichnisses, falls es schon vorhanden ist, bevor die Umgebung erstellt wird.

--upgrade

Bringt das Umgebungsverzeichnis auf diese Python-Version, unter der Annahme, dass Python an seinem Ort aktualisiert wurde.

--without-pip

Überspringt das Installieren oder Aktualisieren von pip in der virtuellen Umgebung. Standardmäßig wird pip eingerichtet.

--prompt <PROMPT>

Gibt ein anderes Präfix für die Eingabeaufforderung dieser Umgebung an.

--upgrade-deps

Bringt die Kernabhängigkeiten (pip) auf die neueste Version in PyPI.

--without-scm-ignore-files

Überspringt das Anlegen von Ignorierdateien der Versionsverwaltung im Umgebungsverzeichnis. Git wird standardmäßig unterstützt.

Geändert in Version 3.4: pip wird standardmäßig installiert. Die Optionen --without-pip und --copies wurden hinzugefügt.

Geändert in Version 3.4: In früheren Versionen wurde ein Fehler ausgelöst, wenn das Zielverzeichnis schon vorhanden war, sofern nicht die Option --clear oder --upgrade angegeben wurde.

Geändert in Version 3.9: Die Option --upgrade-deps wurde hinzugefügt, um pip und setuptools auf den neuesten Stand in PyPI zu bringen.

Geändert in Version 3.12: setuptools ist keine Kernabhängigkeit von venv mehr.

Geändert in Version 3.13: Die Option --without-scm-ignore-files wurde hinzugefügt.

Geändert in Version 3.13: venv erstellt jetzt standardmäßig eine Datei .gitignore für Git.

Bemerkung

Symbolische Verweise werden unter Windows zwar unterstützt, sind aber nicht empfehlenswert. Vor allem gilt: Ein Doppelklick auf python.exe im Explorer löst den Verweis sofort auf und übergeht die virtuelle Umgebung.

Bemerkung

Unter Microsoft Windows kann es nötig sein, das Skript Activate.ps1 freizuschalten, indem du die Ausführungsrichtlinie für den Benutzer setzt. Dazu dient der folgende PowerShell-Befehl:

PS C:\> Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

Näheres steht unter About Execution Policies.

Die erzeugte Datei pyvenv.cfg enthält außerdem den Schlüssel include-system-site-packages. Er steht auf true, wenn venv mit der Option --system-site-packages aufgerufen wurde, sonst auf false.

Sofern nicht die Option --without-pip angegeben ist, wird ensurepip aufgerufen, um pip in der virtuellen Umgebung einzurichten.

venv nimmt auch mehrere Pfade an. Dann wird an jedem angegebenen Pfad eine gleiche virtuelle Umgebung entsprechend den angegebenen Optionen erstellt.

Wie venvs arbeiten

Läuft ein Python-Interpreter aus einer virtuellen Umgebung, zeigen sys.prefix und sys.exec_prefix auf die Verzeichnisse der virtuellen Umgebung, während sys.base_prefix und sys.base_exec_prefix auf die des Basis-Python zeigen, mit dem die Umgebung erstellt wurde. Um festzustellen, ob der aktuelle Interpreter aus einer virtuellen Umgebung läuft, genügt die Prüfung sys.prefix != sys.base_prefix.

Eine virtuelle Umgebung lässt sich mit einem Skript in ihrem Binärverzeichnis „aktivieren“ (bin unter POSIX, Scripts unter Windows). Das stellt dieses Verzeichnis vorne in deinen PATH, sodass der Aufruf von python den Python-Interpreter der Umgebung startet und du installierte Skripte ohne vollständigen Pfad ausführen kannst. Wie das Aktivierungsskript aufgerufen wird, hängt von der Plattform ab; <venv> ist dabei durch den Pfad des Verzeichnisses zu ersetzen, in dem die virtuelle Umgebung liegt:

Plattform

Shell

Befehl zum Aktivieren der virtuellen Umgebung

POSIX

bash/zsh

$ source <venv>/bin/activate

fish

$ source <venv>/bin/activate.fish

csh/tcsh

$ source <venv>/bin/activate.csh

pwsh

$ <venv>/bin/Activate.ps1

Windows

cmd.exe

C:\> <venv>\Scripts\activate.bat

PowerShell

PS C:\> <venv>\Scripts\Activate.ps1

Added in version 3.4: Aktivierungsskripte für fish und csh.

Added in version 3.8: Unter POSIX werden PowerShell-Aktivierungsskripte installiert, damit PowerShell Core unterstützt wird.

Du musst eine virtuelle Umgebung nicht unbedingt aktivieren, denn du kannst beim Aufruf von Python einfach den vollständigen Pfad zum Python-Interpreter dieser Umgebung angeben. Außerdem sollten sich alle in der Umgebung installierten Skripte auch ohne Aktivierung ausführen lassen.

Dazu haben Skripte, die in virtuelle Umgebungen installiert werden, eine „Shebang“-Zeile, die auf den Python-Interpreter der Umgebung zeigt: #!/<path-to-venv>/bin/python. Das Skript läuft damit unabhängig vom Wert von PATH mit diesem Interpreter. Unter Windows werden „Shebang“-Zeilen ausgewertet, wenn der Python Install Manager installiert ist. Ein Doppelklick auf ein installiertes Skript im Windows-Explorer sollte es also mit dem richtigen Interpreter ausführen, ohne dass die Umgebung aktiviert oder im PATH sein muss.

Ist eine virtuelle Umgebung aktiviert, enthält die Umgebungsvariable VIRTUAL_ENV den Pfad der Umgebung. Da eine virtuelle Umgebung nicht ausdrücklich aktiviert werden muss, um sie zu nutzen, lässt sich an VIRTUAL_ENV nicht verlässlich ablesen, ob eine virtuelle Umgebung im Einsatz ist.

Warnung

Weil Skripte, die in Umgebungen installiert sind, nicht davon ausgehen sollen, dass die Umgebung aktiviert ist, enthalten ihre Shebang-Zeilen die absoluten Pfade zu den Interpretern ihrer Umgebung. Deshalb sind Umgebungen im Allgemeinen von Natur aus nicht übertragbar. Du solltest immer eine einfache Möglichkeit haben, eine Umgebung neu anzulegen. Hast du zum Beispiel eine Anforderungsdatei requirements.txt, kannst du mit dem pip der Umgebung pip install -r requirements.txt aufrufen und so alle Pakete installieren, die die Umgebung braucht. Musst du die Umgebung aus irgendeinem Grund an einen neuen Ort verschieben, lege sie am gewünschten Ort neu an und lösche die alte. Verschiebst du eine Umgebung, weil du ein übergeordnetes Verzeichnis verschoben hast, lege die Umgebung an ihrem neuen Ort neu an. Andernfalls arbeitet die in der Umgebung installierte Software vielleicht nicht wie erwartet.

Eine virtuelle Umgebung deaktivierst du, indem du in deiner Shell deactivate eingibst. Wie das genau geschieht, hängt von der Plattform ab und ist ein internes Detail der Umsetzung. Üblicherweise kommt ein Skript oder eine Shell-Funktion zum Einsatz.

API

Der oben beschriebene Weg auf hoher Ebene nutzt eine einfache API, die Klasse EnvBuilder. Mit ihr können fremde Werkzeuge zum Erstellen virtueller Umgebungen die Erstellung nach ihren Bedürfnissen anpassen.

class venv.EnvBuilder(system_site_packages=False, clear=False, symlinks=False, upgrade=False, with_pip=False, prompt=None, upgrade_deps=False, *, scm_ignore_files=frozenset())

Die Klasse EnvBuilder nimmt beim Erzeugen die folgenden Schlüsselwortargumente an:

  • system_site_packages – ein Wahrheitswert, der angibt, dass die site-packages des System-Python in der Umgebung verfügbar sein sollen (Vorgabe False).

  • clear – ein Wahrheitswert. Ist er wahr, wird der Inhalt eines vorhandenen Zielverzeichnisses gelöscht, bevor die Umgebung erstellt wird.

  • symlinks – ein Wahrheitswert, der angibt, ob versucht werden soll, auf die Python-Binärdatei symbolisch zu verweisen, statt sie zu kopieren.

  • upgrade – ein Wahrheitswert. Ist er wahr, wird eine vorhandene Umgebung auf das laufende Python gebracht. Gedacht für den Fall, dass dieses Python an seinem Ort aktualisiert wurde (Vorgabe False).

  • with_pip – ein Wahrheitswert. Ist er wahr, wird sichergestellt, dass pip in der virtuellen Umgebung installiert ist. Dazu dient ensurepip mit der Option --default-pip.

  • prompt – eine Zeichenkette, die nach dem Aktivieren der virtuellen Umgebung verwendet wird (Vorgabe None, dann wird der Verzeichnisname der Umgebung genommen). Bei der besonderen Zeichenkette "." wird der Basisname des aktuellen Verzeichnisses als Eingabeaufforderung verwendet.

  • upgrade_deps – bringt die Basismodule von venv auf den neuesten Stand in PyPI

  • scm_ignore_files – legt Ignorierdateien für die im Iterable angegebenen Versionsverwaltungen (SCM) an. Unterstützt wird eine Verwaltung, wenn es eine Methode namens create_{scm}_ignore_file gibt. Standardmäßig wird nur der Wert "git" über create_git_ignore_file() unterstützt.

Geändert in Version 3.4: Der Parameter with_pip wurde hinzugefügt

Geändert in Version 3.6: Der Parameter prompt wurde hinzugefügt

Geändert in Version 3.9: Der Parameter upgrade_deps wurde hinzugefügt

Geändert in Version 3.13: Der Parameter scm_ignore_files wurde hinzugefügt

EnvBuilder kann als Basisklasse dienen.

create(env_dir)

Erstellt eine virtuelle Umgebung. Angegeben wird das Zielverzeichnis, absolut oder relativ zum aktuellen Verzeichnis, das die virtuelle Umgebung enthalten soll. Die Methode create erstellt die Umgebung entweder im angegebenen Verzeichnis oder löst eine passende Ausnahme aus.

Die Methode create der Klasse EnvBuilder zeigt, welche Einhängepunkte Unterklassen zum Anpassen zur Verfügung stehen:

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.ensure_directories(env_dir)
    self.create_configuration(context)
    self.setup_python(context)
    self.setup_scripts(context)
    self.post_setup(context)

Jede der Methoden ensure_directories(), create_configuration(), setup_python(), setup_scripts() und post_setup() lässt sich überschreiben.

ensure_directories(env_dir)

Legt das Umgebungsverzeichnis und alle nötigen Unterverzeichnisse an, die noch nicht vorhanden sind, und gibt ein Kontextobjekt zurück. Dieses Kontextobjekt ist nur ein Behälter für Attribute wie Pfade, die die übrigen Methoden verwenden. Wurde der EnvBuilder mit dem Argument clear=True erzeugt, wird der Inhalt des Umgebungsverzeichnisses geleert und danach werden alle nötigen Unterverzeichnisse neu angelegt.

Das zurückgegebene Kontextobjekt ist ein types.SimpleNamespace mit den folgenden Attributen:

  • env_dir – der Ort der virtuellen Umgebung. Wird in Aktivierungsskripten für __VENV_DIR__ verwendet (siehe install_scripts()).

  • env_name – der Name der virtuellen Umgebung. Wird in Aktivierungsskripten für __VENV_NAME__ verwendet (siehe install_scripts()).

  • prompt – die Eingabeaufforderung, die die Aktivierungsskripte verwenden. Wird in Aktivierungsskripten für __VENV_PROMPT__ verwendet (siehe install_scripts()).

  • executable – das zugrundeliegende ausführbare Python, das die virtuelle Umgebung verwendet. Dabei ist der Fall berücksichtigt, dass eine virtuelle Umgebung aus einer anderen virtuellen Umgebung heraus erstellt wird.

  • inc_path – der Include-Pfad der virtuellen Umgebung.

  • lib_path – der purelib-Pfad der virtuellen Umgebung.

  • platlib_path – der platlib-Pfad der virtuellen Umgebung.

  • bin_path – der Skriptpfad der virtuellen Umgebung.

  • bin_name – der Name des Skriptpfads relativ zum Ort der virtuellen Umgebung. Wird in Aktivierungsskripten für __VENV_BIN_NAME__ verwendet (siehe install_scripts()).

  • env_exe – der Name des Python-Interpreters in der virtuellen Umgebung. Wird in Aktivierungsskripten für __VENV_PYTHON__ verwendet (siehe install_scripts()).

  • env_exec_cmd – der Name des Python-Interpreters unter Berücksichtigung von Umleitungen im Dateisystem. Damit lässt sich Python in der virtuellen Umgebung ausführen.

Geändert in Version 3.11: Die Pfade der angelegten Verzeichnisse werden nach dem sysconfig-Installationsschema venv gebildet.

Geändert in Version 3.12: Das Attribut lib_path kam zum Kontext hinzu, und das Kontextobjekt wurde dokumentiert.

Geändert in Version 3.15: Das Attribut platlib_path kam zum Kontext hinzu.

create_configuration(context)

Legt die Konfigurationsdatei pyvenv.cfg in der Umgebung an.

setup_python(context)

Legt in der Umgebung eine Kopie des ausführbaren Python oder einen symbolischen Verweis darauf an. Wurde auf POSIX-Systemen ein bestimmtes python3.x verwendet, entstehen symbolische Verweise python und python3 auf diese Datei, sofern es nicht schon Dateien mit diesen Namen gibt.

setup_scripts(context)

Installiert die zur Plattform passenden Aktivierungsskripte in die virtuelle Umgebung.

upgrade_dependencies(context)

Bringt die Kernabhängigkeiten von venv in der Umgebung auf den neuesten Stand, derzeit pip. Dazu wird das ausführbare pip der Umgebung in einer Shell aufgerufen.

Added in version 3.9.

Geändert in Version 3.12: setuptools ist keine Kernabhängigkeit von venv mehr.

post_setup(context)

Eine Platzhaltermethode, die fremde Umsetzungen überschreiben können, um Pakete in der virtuellen Umgebung vorzuinstallieren oder andere Schritte nach dem Erstellen auszuführen.

install_scripts(context, path)

Unterklassen können diese Methode aus setup_scripts() oder post_setup() aufrufen, um eigene Skripte in die virtuelle Umgebung zu installieren.

path ist der Pfad eines Verzeichnisses, das die Unterverzeichnisse common, posix und nt enthalten sollte. In jedem davon liegen Skripte für das Verzeichnis bin der Umgebung. Der Inhalt von common und des zu os.name passenden Verzeichnisses wird kopiert, nachdem einige Platzhalter im Text ersetzt wurden:

  • __VENV_DIR__ wird durch den absoluten Pfad des Umgebungsverzeichnisses ersetzt.

  • __VENV_NAME__ wird durch den Namen der Umgebung ersetzt, also durch den letzten Pfadabschnitt des Umgebungsverzeichnisses.

  • __VENV_PROMPT__ wird durch die Eingabeaufforderung ersetzt, also durch den Namen der Umgebung in Klammern mit einem Leerzeichen danach

  • __VENV_BIN_NAME__ wird durch den Namen des bin-Verzeichnisses ersetzt, entweder bin oder Scripts.

  • __VENV_PYTHON__ wird durch den absoluten Pfad der ausführbaren Datei der Umgebung ersetzt.

Die Verzeichnisse dürfen schon vorhanden sein, für den Fall, dass eine bestehende Umgebung aktualisiert wird.

create_git_ignore_file(context)

Legt in der virtuellen Umgebung eine Datei .gitignore an, die dafür sorgt, dass die Versionsverwaltung Git das gesamte Verzeichnis übergeht.

Added in version 3.13.

Geändert in Version 3.7.2: Unter Windows werden für python[w].exe jetzt Umleitungsskripte verwendet, statt die eigentlichen Binärdateien zu kopieren. Nur in 3.7.2 tut setup_python() nichts, außer beim Lauf aus einem Build im Quellbaum.

Geändert in Version 3.7.3: Unter Windows werden die Umleitungsskripte als Teil von setup_python() kopiert, nicht von setup_scripts(). In 3.7.2 war das noch nicht so. Bei symbolischen Verweisen wird auf die ursprünglichen ausführbaren Dateien verwiesen.

Außerdem gibt es eine bequeme Funktion auf Modulebene:

venv.create(env_dir, system_site_packages=False, clear=False, symlinks=False, with_pip=False, prompt=None, upgrade_deps=False, *, scm_ignore_files=frozenset())

Erzeugt einen EnvBuilder mit den angegebenen Schlüsselwortargumenten und ruft dessen Methode create() mit dem Argument env_dir auf.

Added in version 3.3.

Geändert in Version 3.4: Der Parameter with_pip wurde hinzugefügt

Geändert in Version 3.6: Der Parameter prompt wurde hinzugefügt

Geändert in Version 3.9: Der Parameter upgrade_deps wurde hinzugefügt

Geändert in Version 3.13: Der Parameter scm_ignore_files wurde hinzugefügt

Ein Beispiel für die Erweiterung von EnvBuilder

Das folgende Skript zeigt, wie man EnvBuilder erweitert: durch eine Unterklasse, die setuptools und pip in eine erstellte virtuelle Umgebung installiert:

import os
import os.path
from subprocess import Popen, PIPE
import sys
from threading import Thread
from urllib.parse import urlsplit
from urllib.request import urlretrieve
import venv

class ExtendedEnvBuilder(venv.EnvBuilder):
    """
    This builder installs setuptools and pip so that you can pip or
    easy_install other packages into the created virtual environment.

    :param nodist: If true, setuptools and pip are not installed into the
                   created virtual environment.
    :param nopip: If true, pip is not installed into the created
                  virtual environment.
    :param progress: If setuptools or pip are installed, the progress of the
                     installation can be monitored by passing a progress
                     callable. If specified, it is called with two
                     arguments: a string indicating some progress, and a
                     context indicating where the string is coming from.
                     The context argument can have one of three values:
                     'main', indicating that it is called from
                     install_script() itself, and 'stdout' and 'stderr',
                     which are obtained by reading lines from the output
                     streams of a subprocess which is used to install
                     the app.

                     If a callable is not specified, default progress
                     information is output to sys.stderr.
    """

    def __init__(self, *args, **kwargs):
        self.nodist = kwargs.pop('nodist', False)
        self.nopip = kwargs.pop('nopip', False)
        self.progress = kwargs.pop('progress', None)
        self.verbose = kwargs.pop('verbose', False)
        super().__init__(*args, **kwargs)

    def post_setup(self, context):
        """
        Set up any packages which need to be pre-installed into the
        virtual environment being created.

        :param context: The information for the virtual environment
                        creation request being processed.
        """
        os.environ['VIRTUAL_ENV'] = context.env_dir
        if not self.nodist:
            self.install_setuptools(context)
        # Can't install pip without setuptools
        if not self.nopip and not self.nodist:
            self.install_pip(context)

    def reader(self, stream, context):
        """
        Read lines from a subprocess' output stream and either pass to a progress
        callable (if specified) or write progress information to sys.stderr.
        """
        progress = self.progress
        while True:
            s = stream.readline()
            if not s:
                break
            if progress is not None:
                progress(s, context)
            else:
                if not self.verbose:
                    sys.stderr.write('.')
                else:
                    sys.stderr.write(s.decode('utf-8'))
                sys.stderr.flush()
        stream.close()

    def install_script(self, context, name, url):
        _, _, path, _, _ = urlsplit(url)
        fn = os.path.split(path)[-1]
        binpath = context.bin_path
        distpath = os.path.join(binpath, fn)
        # Download script into the virtual environment's binaries folder
        urlretrieve(url, distpath)
        progress = self.progress
        if self.verbose:
            term = '\n'
        else:
            term = ''
        if progress is not None:
            progress('Installing %s ...%s' % (name, term), 'main')
        else:
            sys.stderr.write('Installing %s ...%s' % (name, term))
            sys.stderr.flush()
        # Install in the virtual environment
        args = [context.env_exe, fn]
        p = Popen(args, stdout=PIPE, stderr=PIPE, cwd=binpath)
        t1 = Thread(target=self.reader, args=(p.stdout, 'stdout'))
        t1.start()
        t2 = Thread(target=self.reader, args=(p.stderr, 'stderr'))
        t2.start()
        p.wait()
        t1.join()
        t2.join()
        if progress is not None:
            progress('done.', 'main')
        else:
            sys.stderr.write('done.\n')
        # Clean up - no longer needed
        os.unlink(distpath)

    def install_setuptools(self, context):
        """
        Install setuptools in the virtual environment.

        :param context: The information for the virtual environment
                        creation request being processed.
        """
        url = "https://bootstrap.pypa.io/ez_setup.py"
        self.install_script(context, 'setuptools', url)
        # clear up the setuptools archive which gets downloaded
        pred = lambda o: o.startswith('setuptools-') and o.endswith('.tar.gz')
        files = filter(pred, os.listdir(context.bin_path))
        for f in files:
            f = os.path.join(context.bin_path, f)
            os.unlink(f)

    def install_pip(self, context):
        """
        Install pip in the virtual environment.

        :param context: The information for the virtual environment
                        creation request being processed.
        """
        url = 'https://bootstrap.pypa.io/get-pip.py'
        self.install_script(context, 'pip', url)


def main(args=None):
    import argparse

    parser = argparse.ArgumentParser(prog=__name__,
                                     description='Creates virtual Python '
                                                 'environments in one or '
                                                 'more target '
                                                 'directories.')
    parser.add_argument('dirs', metavar='ENV_DIR', nargs='+',
                        help='A directory in which to create the '
                             'virtual environment.')
    parser.add_argument('--no-setuptools', default=False,
                        action='store_true', dest='nodist',
                        help="Don't install setuptools or pip in the "
                             "virtual environment.")
    parser.add_argument('--no-pip', default=False,
                        action='store_true', dest='nopip',
                        help="Don't install pip in the virtual "
                             "environment.")
    parser.add_argument('--system-site-packages', default=False,
                        action='store_true', dest='system_site',
                        help='Give the virtual environment access to the '
                             'system site-packages dir.')
    if os.name == 'nt':
        use_symlinks = False
    else:
        use_symlinks = True
    parser.add_argument('--symlinks', default=use_symlinks,
                        action='store_true', dest='symlinks',
                        help='Try to use symlinks rather than copies, '
                             'when symlinks are not the default for '
                             'the platform.')
    parser.add_argument('--clear', default=False, action='store_true',
                        dest='clear', help='Delete the contents of the '
                                           'virtual environment '
                                           'directory if it already '
                                           'exists, before virtual '
                                           'environment creation.')
    parser.add_argument('--upgrade', default=False, action='store_true',
                        dest='upgrade', help='Upgrade the virtual '
                                             'environment directory to '
                                             'use this version of '
                                             'Python, assuming Python '
                                             'has been upgraded '
                                             'in-place.')
    parser.add_argument('--verbose', default=False, action='store_true',
                        dest='verbose', help='Display the output '
                                             'from the scripts which '
                                             'install setuptools and pip.')
    options = parser.parse_args(args)
    if options.upgrade and options.clear:
        raise ValueError('you cannot supply --upgrade and --clear together.')
    builder = ExtendedEnvBuilder(system_site_packages=options.system_site,
                                   clear=options.clear,
                                   symlinks=options.symlinks,
                                   upgrade=options.upgrade,
                                   nodist=options.nodist,
                                   nopip=options.nopip,
                                   verbose=options.verbose)
    for d in options.dirs:
        builder.create(d)

if __name__ == '__main__':
    rc = 1
    try:
        main()
        rc = 0
    except Exception as e:
        print('Error: %s' % e, file=sys.stderr)
    sys.exit(rc)

Das Skript steht auch online zum Herunterladen bereit.