4. Python unter Windows verwenden
*********************************

Dieses Dokument gibt einen Überblick über das Windows-spezifische
Verhalten, das du kennen solltest, wenn du Python unter Microsoft
Windows verwendest.

Unlike most Unix systems and services, Windows does not include a
system supported installation of Python. To make Python available, the
CPython team has compiled Windows installers with every release for
many years. These installers are primarily intended to add a per-user
installation of Python, with the core interpreter and library being
used by a single user. The installer is also able to install for all
users of a single machine, and a separate ZIP file is available for
application-local distributions.

As specified in **PEP 11**, a Python release only supports a Windows
platform while Microsoft considers the platform under extended
support. This means that Python 3.11 supports Windows 8.1 and newer.
If you require Windows 7 support, please install Python 3.8.

There are a number of different installers available for Windows, each
with certain benefits and downsides.

The full installer contains all components and is the best option for
developers using Python for any kind of project.

The Microsoft Store package is a simple installation of Python that is
suitable for running scripts and packages, and using IDLE or other
development environments. It requires Windows 10 and above, but can be
safely installed without corrupting other programs. It also provides
many convenient commands for launching Python and its tools.

Die Pakete von nuget.org are lightweight installations intended for
continuous integration systems. It can be used to build Python
packages or run scripts, but is not updateable and has no user
interface tools.

Das einbettbare Paket is a minimal package of Python suitable for
embedding into a larger application.


4.1. The full installer
=======================


4.1.1. Installationsschritte
----------------------------

Für Python 3.11 stehen vier Installationsprogramme zum Herunterladen
bereit — jeweils zwei für die 32-Bit- und die 64-Bit-Version des
Interpreters. Das *Web-Installationsprogramm* ist ein kleiner erster
Download und lädt die benötigten Bestandteile bei Bedarf automatisch
nach. Das *Offline-Installationsprogramm* enthält die für eine
Standardinstallation nötigen Bestandteile und braucht nur für
optionale Funktionen eine Internetverbindung. Unter Installing Without
Downloading stehen weitere Wege, das Herunterladen während der
Installation zu vermeiden.

Nach dem Starten den Installers kann eine der beiden Optionen
ausgewählt werden:

[Bild]

Wenn du „Jetzt installieren“ wählst:

* Du brauchst *keine* Administratorrechte (es sei denn, eine
  Systemaktualisierung der C-Laufzeitbibliothek ist nötig oder du
  installierst den Python Launcher for Windows für alle Benutzer)

* Python wird in dein Benutzerverzeichnis installiert

* Der Python Launcher for Windows wird gemäß der Option am unteren
  Rand der ersten Seite installiert

* Die Standardbibliothek, die Testsammlung, der Starter und pip werden
  installiert

* Wenn ausgewählt, wird das Installationsverzeichnis zu deinem "PATH"
  hinzugefügt

* Verknüpfungen sind nur für den aktuellen Benutzer sichtbar

Mit „Customize installation“ kannst du die zu installierenden
Funktionen, den Installationsort und weitere Optionen oder Aktionen
nach der Installation auswählen. Um Debugsymbole oder Debug-
Binärdateien zu installieren, brauchst du diese Option.

Für eine Installation für alle Benutzer solltest du „Customize
installation“ wählen. In diesem Fall:

* Möglicherweise musst du administrative Anmeldedaten oder eine
  Freigabe bereitstellen

* Python wird in das Verzeichnis „Programme“ installiert

* Der Python Launcher for Windows wird in das Windows-Verzeichnis
  installiert

* Optionale Funktionen lassen sich während der Installation auswählen

* Die Standardbibliothek kann vorab zu Bytecode kompiliert werden

* Wenn ausgewählt, wird das Installationsverzeichnis zum System-"PATH"
  hinzugefügt

* Verknüpfungen stehen allen Benutzern zur Verfügung


4.1.2. Removing the MAX_PATH Limitation
---------------------------------------

Windows hat die Pfadlänge aus historischen Gründen auf 260 Zeichen
beschränkt. Längere Pfade ließen sich dadurch nicht auflösen, und es
kam zu Fehlern.

In den neuesten Windows-Versionen lässt sich diese Beschränkung auf
etwa 32.000 Zeichen erweitern. Deine Administration muss dazu die
Gruppenrichtlinie „Win32-Pfade mit langen Namen aktivieren“
einschalten oder "LongPathsEnabled" im Registrierungsschlüssel
"HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\FileSystem" auf
"1" setzen.

Damit können die Funktion "open()", das Modul "os" und die meisten
anderen Pfadfunktionen Pfade mit mehr als 260 Zeichen annehmen und
zurückgeben.

Nach dem Ändern der obigen Option ist keine weitere Einrichtung nötig.

Geändert in Version 3.6: Die Unterstützung langer Pfade wurde in
Python eingeschaltet.


4.1.3. Installing Without UI
----------------------------

Alle in der Oberfläche des Installationsprogramms verfügbaren Optionen
lassen sich auch über die Befehlszeile angeben, sodass
skriptgesteuerte Installationen eine Installation ohne Zutun des
Benutzers auf vielen Rechnern nachbilden können. Diese Optionen lassen
sich auch setzen, ohne die Oberfläche zu unterdrücken, um einige der
Vorgaben zu ändern.

To completely hide the installer UI and install Python silently, pass
the "/quiet" option. To skip past the user interaction but still
display progress and errors, pass the "/passive" option. The
"/uninstall" option may be passed to immediately begin removing Python
- no confirmation prompt will be displayed.

Alle anderen Optionen werden als "name=value" übergeben, wobei der
Wert meist "0" zum Abschalten einer Funktion, "1" zum Einschalten
einer Funktion oder ein Pfad ist. Die vollständige Liste der
verfügbaren Optionen steht unten.

+-----------------------------+----------------------------------------+----------------------------+
| Name                        | Beschreibung                           | Standard                   |
|=============================|========================================|============================|
| InstallAllUsers             | Nimmt eine systemweite Installation    | 0                          |
|                             | vor.                                   |                            |
+-----------------------------+----------------------------------------+----------------------------+
| TargetDir                   | Das Installations-Verzeichnis          | Wird anhand von            |
|                             |                                        | InstallAllUsers gewählt    |
+-----------------------------+----------------------------------------+----------------------------+
| DefaultAllUsersTargetDir    | Das Standardinstallationsverzeichnis   | "%ProgramFiles%\Python     |
|                             | für Installationen für alle Benutzer   | X.Y" or "%ProgramFiles(x8  |
|                             |                                        | 6)%\Python X.Y"            |
+-----------------------------+----------------------------------------+----------------------------+
| DefaultJustForMeTargetDir   | Das Standardinstallationsverzeichnis   | "%LocalAppData%\Programs\  |
|                             | für Installationen nur für mich        | Python\PythonXY" or "%Loc  |
|                             |                                        | alAppData%\Programs\Pytho  |
|                             |                                        | n\PythonXY-32" or "%Local  |
|                             |                                        | AppData%\Programs\Python\  |
|                             |                                        | PythonXY-64"               |
+-----------------------------+----------------------------------------+----------------------------+
| DefaultCustomTargetDir      | Das in der Oberfläche angezeigte       | (leer)                     |
|                             | Standardverzeichnis für eine eigene    |                            |
|                             | Installation                           |                            |
+-----------------------------+----------------------------------------+----------------------------+
| AssociateFiles              | Legt Dateiverknüpfungen an, wenn auch  | 1                          |
|                             | der Starter installiert ist.           |                            |
+-----------------------------+----------------------------------------+----------------------------+
| CompileAll                  | Kompiliert alle ".py"-Dateien zu       | 0                          |
|                             | ".pyc".                                |                            |
+-----------------------------+----------------------------------------+----------------------------+
| PrependPath                 | Stellt die Installations- und Scripts- | 0                          |
|                             | Verzeichnisse an den Anfang von "PATH" |                            |
|                             | und fügt ".PY" zu "PATHEXT" hinzu      |                            |
+-----------------------------+----------------------------------------+----------------------------+
| AppendPath                  | Hängt die Installations- und Scripts-  | 0                          |
|                             | Verzeichnisse an "PATH" an und fügt    |                            |
|                             | ".PY" zu "PATHEXT" hinzu               |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Shortcuts                   | Legt Verknüpfungen für den             | 1                          |
|                             | Interpreter, die Dokumentation und     |                            |
|                             | IDLE an, sofern installiert.           |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Include_doc                 | Installiert das Python-Handbuch        | 1                          |
+-----------------------------+----------------------------------------+----------------------------+
| Include_debug               | Installiert die Debug-Binärdateien     | 0                          |
+-----------------------------+----------------------------------------+----------------------------+
| Include_dev                 | Installiert Headerdateien und          | 1                          |
|                             | Bibliotheken für die Entwicklung. Wird |                            |
|                             | das weggelassen, kann die Installation |                            |
|                             | unbrauchbar sein.                      |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Include_exe                 | Installiert "python.exe" und           | 1                          |
|                             | zugehörige Dateien. Wird das           |                            |
|                             | weggelassen, kann die Installation     |                            |
|                             | unbrauchbar sein.                      |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Include_launcher            | Installiert den Python Launcher for    | 1                          |
|                             | Windows.                               |                            |
+-----------------------------+----------------------------------------+----------------------------+
| InstallLauncherAllUsers     | Installiert den Starter für alle       | 1                          |
|                             | Benutzer. Erfordert außerdem, dass     |                            |
|                             | "Include_launcher" auf 1 gesetzt ist   |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Include_lib                 | Installiert die Standardbibliothek und | 1                          |
|                             | die Erweiterungsmodule. Wird das       |                            |
|                             | weggelassen, kann die Installation     |                            |
|                             | unbrauchbar sein.                      |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Include_pip                 | Installiert die beiliegenden pip und   | 1                          |
|                             | setuptools                             |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Include_symbols             | Installiert Debugsymbole ("*.pdb")     | 0                          |
+-----------------------------+----------------------------------------+----------------------------+
| Include_tcltk               | Installiert die Unterstützung für      | 1                          |
|                             | Tcl/Tk und IDLE                        |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Include_test                | Installiert die Testsammlung der       | 1                          |
|                             | Standardbibliothek                     |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Include_tools               | Installiert Hilfsskripte               | 1                          |
+-----------------------------+----------------------------------------+----------------------------+
| LauncherOnly                | Installiert nur den Starter. Das       | 0                          |
|                             | überschreibt die meisten anderen       |                            |
|                             | Optionen.                              |                            |
+-----------------------------+----------------------------------------+----------------------------+
| SimpleInstall               | Schaltet den größten Teil der          | 0                          |
|                             | Installationsoberfläche ab             |                            |
+-----------------------------+----------------------------------------+----------------------------+
| SimpleInstallDescription    | Eine eigene Meldung, die bei der       | (leer)                     |
|                             | vereinfachten Installationsoberfläche  |                            |
|                             | angezeigt wird.                        |                            |
+-----------------------------+----------------------------------------+----------------------------+

Um zum Beispiel stillschweigend eine systemweite Standardinstallation
von Python vorzunehmen, kannst du den folgenden Befehl verwenden (an
einer Eingabeaufforderung mit erhöhten Rechten):

   python-3.9.0.exe /quiet InstallAllUsers=1 PrependPath=1 Include_test=0

Damit Benutzer bequem eine eigene Python-Kopie ohne die Testsammlung
installieren können, kannst du eine Verknüpfung mit dem folgenden
Befehl bereitstellen. Dabei wird eine vereinfachte erste Seite
angezeigt und eine Anpassung verhindert:

   python-3.9.0.exe InstallAllUsers=0 Include_launcher=0 Include_test=0
       SimpleInstall=1 SimpleInstallDescription="Just for me, no test suite."

(Beachte, dass mit dem Starter auch die Dateiverknüpfungen wegfallen.
Das ist nur für Installationen je Benutzer empfehlenswert, wenn es
zusätzlich eine systemweite Installation gibt, die den Starter
enthielt.)

Die oben aufgeführten Optionen lassen sich auch in einer Datei namens
"unattend.xml" neben der ausführbaren Datei angeben. Diese Datei gibt
eine Liste von Optionen und Werten an. Wird ein Wert als Attribut
angegeben, wird er nach Möglichkeit in eine Zahl umgewandelt. Als
Elementtext angegebene Werte bleiben immer Zeichenketten. Diese
Beispieldatei setzt dieselben Optionen wie das vorige Beispiel:

   <Options>
       <Option Name="InstallAllUsers" Value="no" />
       <Option Name="Include_launcher" Value="0" />
       <Option Name="Include_test" Value="no" />
       <Option Name="SimpleInstall" Value="yes" />
       <Option Name="SimpleInstallDescription">Just for me, no test suite</Option>
   </Options>


4.1.4. Installing Without Downloading
-------------------------------------

Da einige Funktionen von Python nicht im ersten Download des
Installationsprogramms enthalten sind, kann die Auswahl dieser
Funktionen eine Internetverbindung erfordern. Um das zu vermeiden,
lassen sich alle möglichen Bestandteile bei Bedarf herunterladen und
zu einem vollständigen *Layout* zusammenstellen, das unabhängig von
den gewählten Funktionen keine Internetverbindung mehr braucht.
Beachte, dass dieser Download größer sein kann als nötig. Wenn aber
viele Installationen vorgenommen werden sollen, ist eine lokal
zwischengespeicherte Kopie sehr nützlich.

Führe den folgenden Befehl an der Eingabeaufforderung aus, um alle
möglicherweise benötigten Dateien herunterzuladen. Denke daran,
"python-3.9.0.exe" durch den tatsächlichen Namen deines
Installationsprogramms zu ersetzen und Layouts in eigenen
Verzeichnissen anzulegen, damit Dateien gleichen Namens nicht
zusammenstoßen.

   python-3.9.0.exe /layout [optional target directory]

Mit der Option "/quiet" lässt sich außerdem die Fortschrittsanzeige
verbergen.


4.1.5. Eine Installation ändern
-------------------------------

Nachdem Python installiert ist, kannst du Funktionen über das zu
Windows gehörende Werkzeug „Programme und Features“ hinzufügen oder
entfernen. Wähle den Python-Eintrag und dann „Deinstallieren/Ändern“,
um das Installationsprogramm im Wartungsmodus zu öffnen.

Mit „Modify“ lassen sich Funktionen über die Kontrollkästchen
hinzufügen oder entfernen — unveränderte Kästchen installieren und
entfernen nichts. Einige Optionen lassen sich in diesem Modus nicht
ändern, etwa das Installationsverzeichnis. Dafür musst du Python
vollständig entfernen und neu installieren.

Mit „Repair“ werden alle Dateien überprüft, die mit den aktuellen
Einstellungen installiert sein sollten, und alle ersetzt, die entfernt
oder verändert wurden.

Mit „Uninstall“ wird Python vollständig entfernt, mit Ausnahme des
Python Launcher for Windows, der seinen eigenen Eintrag in „Programme
und Features“ hat.


4.2. The Microsoft Store package
================================

Neu in Version 3.7.2.

The Microsoft Store package is an easily installable Python
interpreter that is intended mainly for interactive use, for example,
by students.

To install the package, ensure you have the latest Windows 10 updates
and search the Microsoft Store app for "Python 3.11". Ensure that the
app you select is published by the Python Software Foundation, and
install it.

Warnung:

  Python will always be available for free on the Microsoft Store. If
  you are asked to pay for it, you have not selected the correct
  package.

After installation, Python may be launched by finding it in Start.
Alternatively, it will be available from any Command Prompt or
PowerShell session by typing "python". Further, pip and IDLE may be
used by typing "pip" or "idle". IDLE can also be found in Start.

All three commands are also available with version number suffixes,
for example, as "python3.exe" and "python3.x.exe" as well as
"python.exe" (where "3.x" is the specific version you want to launch,
such as 3.11). Open "Manage App Execution Aliases" through Start to
select which version of Python is associated with each command. It is
recommended to make sure that "pip" and "idle" are consistent with
whichever version of "python" is selected.

Virtual environments can be created with "python -m venv" and
activated and used as normal.

If you have installed another version of Python and added it to your
"PATH" variable, it will be available as "python.exe" rather than the
one from the Microsoft Store. To access the new installation, use
"python3.exe" or "python3.x.exe".

The "py.exe" launcher will detect this Python installation, but will
prefer installations from the traditional installer.

To remove Python, open Settings and use Apps and Features, or else
find Python in Start and right-click to select Uninstall. Uninstalling
will remove all packages you installed directly into this Python
installation, but will not remove any virtual environments


4.2.1. Known issues
-------------------


4.2.1.1. Redirection of local data, registry, and temporary paths
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Because of restrictions on Microsoft Store apps, Python scripts may
not have full write access to shared locations such as "TEMP" and the
registry. Instead, it will write to a private copy. If your scripts
must modify the shared locations, you will need to install the full
installer.

At runtime, Python will use a private copy of well-known Windows
folders and the registry. For example, if the environment variable
"%APPDATA%" is "c:\Users\<user>\AppData\", then when writing to
"C:\Users\<user>\AppData\Local" will write to "C:\Users\<user>\AppDat
a\Local\Packages\PythonSoftwareFoundation.Python.3.8_qbz5n2kfra8p0\Lo
calCache\Local\".

When reading files, Windows will return the file from the private
folder, or if that does not exist, the real Windows directory. For
example reading "C:\Windows\System32" returns the contents of
"C:\Windows\System32" plus the contents of "C:\Program
Files\WindowsApps\package_name\VFS\SystemX86".

You can find the real path of any existing file using
"os.path.realpath()":

   >>> import os
   >>> test_file = 'C:\\Users\\example\\AppData\\Local\\test.txt'
   >>> os.path.realpath(test_file)
   'C:\\Users\\example\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.8_qbz5n2kfra8p0\\LocalCache\\Local\\test.txt'

When writing to the Windows Registry, the following behaviors exist:

* Reading from "HKLM\\Software" is allowed and results are merged with
  the "registry.dat" file in the package.

* Writing to "HKLM\\Software" is not allowed if the corresponding
  key/value exists, i.e. modifying existing keys.

* Writing to "HKLM\\Software" is allowed as long as a corresponding
  key/value does not exist in the package and the user has the correct
  access permissions.

For more detail on the technical basis for these limitations, please
consult Microsoft's documentation on packaged full-trust apps,
currently available at docs.microsoft.com/en-us/windows/msix/desktop
/desktop-to-uwp-behind-the-scenes


4.3. Die Pakete von nuget.org
=============================

Neu in Version 3.5.2.

Das Paket von nuget.org ist eine verkleinerte Python-Umgebung, die für
Systeme zur fortlaufenden Integration und für Buildsysteme gedacht
ist, auf denen Python nicht systemweit installiert ist. Nuget ist zwar
„der Paketmanager für .NET“, funktioniert aber auch für Pakete mit
Werkzeugen für die Bauzeit einwandfrei.

Die neuesten Hinweise zur Verwendung von nuget stehen auf nuget.org.
Es folgt eine Zusammenfassung, die Python-Entwicklern genügt.

Das Befehlszeilenwerkzeug "nuget.exe" lässt sich direkt von
"https://dist.nuget.org/win-x86-commandline/latest/nuget.exe"
herunterladen, zum Beispiel mit curl oder PowerShell. Mit dem Werkzeug
wird die neueste Python-Version für 64-Bit- oder 32-Bit-Rechner so
installiert:

   nuget.exe install python -ExcludeVersion -OutputDirectory .
   nuget.exe install pythonx86 -ExcludeVersion -OutputDirectory .

Um eine bestimmte Version auszuwählen, ergänze ein "-Version 3.x.y".
Das Ausgabeverzeichnis kann von "." abweichen, und das Paket wird in
ein Unterverzeichnis installiert. Standardmäßig trägt das
Unterverzeichnis denselben Namen wie das Paket, und ohne die Option
"-ExcludeVersion" enthält dieser Name die installierte Version. In dem
Unterverzeichnis liegt ein Verzeichnis "tools" mit der Python-
Installation:

   # Without -ExcludeVersion
   > .\python.3.5.2\tools\python.exe -V
   Python 3.5.2

   # With -ExcludeVersion
   > .\python\tools\python.exe -V
   Python 3.5.2

Grundsätzlich lassen sich nuget-Pakete nicht aktualisieren. Neuere
Versionen sollten nebeneinander installiert und über den vollständigen
Pfad angesprochen werden. Alternativ kannst du das Paketverzeichnis
von Hand löschen und es erneut installieren. Viele CI-Systeme tun das
automatisch, wenn sie Dateien zwischen Builds nicht aufbewahren.

Neben dem Verzeichnis "tools" liegt ein Verzeichnis "build\native". Es
enthält eine MSBuild-Eigenschaftsdatei "python.props", die sich in
einem C++-Projekt verwenden lässt, um auf die Python-Installation zu
verweisen. Werden die Einstellungen eingebunden, verwendet dein Build
automatisch die Headerdateien und Importbibliotheken.

The package information pages on nuget.org are
www.nuget.org/packages/python for the 64-bit version and
www.nuget.org/packages/pythonx86 for the 32-bit version.


4.4. Das einbettbare Paket
==========================

Neu in Version 3.5.

Die einbettbare Distribution ist eine ZIP-Datei mit einer minimalen
Python-Umgebung. Sie ist dafür gedacht, Teil einer anderen Anwendung
zu sein, und nicht dafür, von Endbenutzern direkt verwendet zu werden.

When extracted, the embedded distribution is (almost) fully isolated
from the user's system, including environment variables, system
registry settings, and installed packages. The standard library is
included as pre-compiled and optimized ".pyc" files in a ZIP, and
"python3.dll", "python37.dll", "python.exe" and "pythonw.exe" are all
provided. Tcl/tk (including all dependents, such as Idle), pip and the
Python documentation are not included.

Bemerkung:

  The embedded distribution does not include the Microsoft C Runtime
  and it is the responsibility of the application installer to provide
  this. The runtime may have already been installed on a user's system
  previously or automatically via Windows Update, and can be detected
  by finding "ucrtbase.dll" in the system directory.

Pakete von Dritten sollten vom Installationsprogramm der Anwendung
neben der einbettbaren Distribution installiert werden. Abhängigkeiten
mit pip zu verwalten wie bei einer gewöhnlichen Python-Installation
wird mit dieser Distribution nicht unterstützt, auch wenn es mit
einiger Sorgfalt möglich sein mag, pip für automatische
Aktualisierungen beizulegen und zu verwenden. Grundsätzlich sollten
Pakete von Dritten als Teil der Anwendung behandelt werden
(„Vendoring“), damit die Entwicklung die Verträglichkeit mit neueren
Versionen sicherstellen kann, bevor sie Aktualisierungen an die
Benutzer ausliefert.

Die beiden empfohlenen Anwendungsfälle dieser Distribution sind unten
beschrieben.


4.4.1. Python Application
-------------------------

Eine in Python geschriebene Anwendung erfordert nicht zwangsläufig,
dass die Benutzer davon wissen. Die einbettbare Distribution lässt
sich in diesem Fall verwenden, um eine private Python-Version in ein
Installationspaket aufzunehmen. Je nachdem, wie unauffällig das sein
soll (oder umgekehrt, wie professionell es wirken soll), gibt es zwei
Möglichkeiten.

Eine besondere ausführbare Datei als Starter zu verwenden erfordert
etwas Programmierarbeit, bietet den Benutzern aber das unauffälligste
Erlebnis. Mit einem eigenen Starter gibt es keine offensichtlichen
Anzeichen dafür, dass das Programm auf Python läuft: Symbole lassen
sich anpassen, Angaben zu Unternehmen und Version festlegen, und
Dateiverknüpfungen verhalten sich richtig. In den meisten Fällen
sollte ein eigener Starter einfach "Py_Main" mit einer festgelegten
Befehlszeile aufrufen können.

Der einfachere Weg ist, eine Batchdatei oder eine erzeugte Verknüpfung
bereitzustellen, die "python.exe" oder "pythonw.exe" direkt mit den
nötigen Befehlszeilenargumenten aufruft. In diesem Fall erscheint die
Anwendung als Python und nicht unter ihrem eigenen Namen, und Benutzer
könnten Schwierigkeiten haben, sie von anderen laufenden Python-
Prozessen oder Dateiverknüpfungen zu unterscheiden.

Beim zweiten Weg sollten Pakete als Verzeichnisse neben der
ausführbaren Python-Datei installiert werden, damit sie im Suchpfad
liegen. Mit dem besonderen Starter können Pakete auch an anderen Orten
liegen, weil sich der Suchpfad vor dem Starten der Anwendung festlegen
lässt.


4.4.2. Python einbetten
-----------------------

In nativem Code geschriebene Anwendungen brauchen oft eine
Skriptsprache, und dafür lässt sich die einbettbare Python-
Distribution verwenden. Grundsätzlich liegt der größte Teil der
Anwendung in nativem Code, und ein Teil ruft entweder "python.exe" auf
oder verwendet "python3.dll" direkt. In beiden Fällen genügt es, die
einbettbare Distribution in ein Unterverzeichnis der
Anwendungsinstallation zu entpacken, um einen ladbaren Python-
Interpreter bereitzustellen.

Wie bei der Verwendung als Anwendung können Pakete an jedem Ort
installiert werden, weil sich die Suchpfade vor dem Hochfahren des
Interpreters festlegen lassen. Davon abgesehen gibt es keine
grundlegenden Unterschiede zwischen der einbettbaren Distribution und
einer gewöhnlichen Installation.


4.5. Alternative Distributionen
===============================

Neben der Standard-Distribution von CPython gibt es abgewandelte
Pakete mit zusätzlichen Funktionen. Es folgt eine Liste verbreiteter
Varianten und ihrer wichtigsten Eigenschaften:

ActivePython
   Installationsprogramm mit plattformübergreifender Verträglichkeit,
   Dokumentation, PyWin32

Anaconda
   Verbreitete wissenschaftliche Module (etwa numpy, scipy und pandas)
   und der Paketmanager "conda".

Enthought Deployment Manager
   „The Next Generation Python Environment and Package Manager“.

   Früher stellte Enthought Canopy bereit, das aber 2016 das Ende
   seiner Lebensdauer erreicht hat.

WinPython
   Windows-spezifische Distribution mit vorgefertigten
   wissenschaftlichen Paketen und Werkzeugen zum Bauen von Paketen.

Beachte, dass diese Pakete nicht die neuesten Versionen von Python
oder anderen Bibliotheken enthalten müssen und nicht vom Kern-Team von
Python gepflegt oder unterstützt werden.


4.6. Configuring Python
=======================

To run Python conveniently from a command prompt, you might consider
changing some default environment variables in Windows.  While the
installer provides an option to configure the PATH and PATHEXT
variables for you, this is only reliable for a single, system-wide
installation.  If you regularly use multiple versions of Python,
consider using the Python Launcher for Windows.


4.6.1. Excursus: Setting environment variables
----------------------------------------------

Windows allows environment variables to be configured permanently at
both the User level and the System level, or temporarily in a command
prompt.

To temporarily set environment variables, open Command Prompt and use
the **set** command:

   C:\>set PATH=C:\Program Files\Python 3.9;%PATH%
   C:\>set PYTHONPATH=%PYTHONPATH%;C:\My_python_lib
   C:\>python

These changes will apply to any further commands executed in that
console, and will be inherited by any applications started from the
console.

Including the variable name within percent signs will expand to the
existing value, allowing you to add your new value at either the start
or the end. Modifying "PATH" by adding the directory containing
**python.exe** to the start is a common way to ensure the correct
version of Python is launched.

To permanently modify the default environment variables, click Start
and search for 'edit environment variables', or open System
properties, Advanced system settings and click the Environment
Variables button. In this dialog, you can add or modify User and
System variables. To change System variables, you need non-restricted
access to your machine (i.e. Administrator rights).

Bemerkung:

  Windows will concatenate User variables *after* System variables,
  which may cause unexpected results when modifying "PATH".The
  "PYTHONPATH" variable is used by all versions of Python, so you
  should not permanently configure it unless the listed paths only
  include code that is compatible with all of your installed Python
  versions.

Siehe auch:

  https://docs.microsoft.com/en-us/windows/win32/procthread
  /environment-variables
     Overview of environment variables on Windows

  https://docs.microsoft.com/en-us/windows-server/administration
  /windows-commands/set_1
     The "set" command, for temporarily modifying environment
     variables

  https://docs.microsoft.com/en-us/windows-server/administration
  /windows-commands/setx
     The "setx" command, for permanently modifying environment
     variables


4.6.2. Finding the Python executable
------------------------------------

Geändert in Version 3.5.

Besides using the automatically created start menu entry for the
Python interpreter, you might want to start Python in the command
prompt. The installer has an option to set that up for you.

On the first page of the installer, an option labelled "Add Python to
PATH" may be selected to have the installer add the install location
into the "PATH".  The location of the "Scripts\" folder is also added.
This allows you to type **python** to run the interpreter, and **pip**
for the package installer. Thus, you can also execute your scripts
with command line options, see Befehlszeile documentation.

If you don't enable this option at install time, you can always re-run
the installer, select Modify, and enable it.  Alternatively, you can
manually modify the "PATH" using the directions in Excursus: Setting
environment variables.  You need to set your "PATH" environment
variable to include the directory of your Python installation,
delimited by a semicolon from other entries.  An example variable
could look like this (assuming the first two entries already existed):

   C:\WINDOWS\system32;C:\WINDOWS;C:\Program Files\Python 3.9


4.7. UTF-8-Modus
================

Neu in Version 3.7.

Windows verwendet für die Systemkodierung weiterhin alte Kodierungen
(die ANSI-Codepage). Python verwendet sie als Standardkodierung für
Textdateien, etwa in "locale.getencoding()".

Das kann Schwierigkeiten machen, weil UTF-8 im Internet und auf den
meisten Unix-Systemen weit verbreitet ist, auch im WSL (Windows-
Subsystem für Linux).

Mit dem Python-UTF-8-Modus kannst du die Standardkodierung für Text
auf UTF-8 umstellen. Einschalten lässt sich der Python-UTF-8-Modus
über die Befehlszeilenoption "-X utf8" oder über die Umgebungsvariable
"PYTHONUTF8=1". Zum Einschalten des UTF-8-Modus siehe "PYTHONUTF8",
und wie du Umgebungsvariablen änderst, steht unter Excursus: Setting
environment variables.

Ist der Python-UTF-8-Modus eingeschaltet, lässt sich die
Systemkodierung (die ANSI-Codepage) weiterhin über den Codec „mbcs“
verwenden.

Beachte, dass "PYTHONUTF8=1" in den Standard-Umgebungsvariablen alle
Python-Anwendungen ab 3.7 auf deinem System betrifft. Wenn du
Anwendungen ab Python 3.7 hast, die auf die alte Systemkodierung
angewiesen sind, solltest du die Umgebungsvariable besser nur
zeitweise setzen oder die Befehlszeilenoption "-X utf8" verwenden.

Bemerkung:

  Auch bei abgeschaltetem UTF-8-Modus verwendet Python unter Windows
  standardmäßig UTF-8 für:

  * Ein- und Ausgabe der Konsole einschließlich der Standard-Ein- und
    -Ausgabe (Einzelheiten in **PEP 528**).

  * Die *Dateisystemkodierung* (Einzelheiten in **PEP 529**).


4.8. Python Launcher for Windows
================================

Neu in Version 3.3.

Der Python-Starter für Windows ist ein Hilfsprogramm, das beim
Auffinden und Ausführen verschiedener Python-Versionen hilft. Er
erlaubt Skripten (oder der Befehlszeile), eine bestimmte Python-
Version zu bevorzugen, und findet und führt diese Version aus.

Anders als die Variable "PATH" wählt der Starter die passendste
Python-Version richtig aus. Er zieht Installationen je Benutzer den
systemweiten vor und ordnet nach Sprachversion, statt die zuletzt
installierte Version zu nehmen.

Der Starter wurde ursprünglich in **PEP 397** festgelegt.


4.8.1. Los geht's
-----------------


4.8.1.1. Von der Befehlszeile
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Geändert in Version 3.6.

Systemweite Installationen von Python 3.3 und neuer legen den Starter
in deinen "PATH". Der Starter ist mit allen verfügbaren Python-
Versionen verträglich, es ist also unerheblich, welche Version
installiert ist. Um zu prüfen, ob der Starter verfügbar ist, führe den
folgenden Befehl an der Eingabeaufforderung aus:

   py

Du solltest feststellen, dass die neueste installierte Python-Version
startet — sie lässt sich wie üblich verlassen, und alle zusätzlich
angegebenen Befehlszeilenargumente werden direkt an Python
weitergegeben.

Wenn mehrere Python-Versionen installiert sind (etwa 3.7 und 3.11),
ist dir aufgefallen, dass Python 3.11 gestartet wurde — um Python 3.7
zu starten, versuche den Befehl:

   py -3.7

Wenn du die neueste installierte Version von Python 2 möchtest,
versuche den Befehl:

   py -2

Wenn du den folgenden Fehler siehst, ist der Starter nicht
installiert:

   'py' is not recognized as an internal or external command,
   operable program or batch file.

Der Befehl:

   py --list

zeigt die derzeit installierte Python-Version beziehungsweise die
installierten Versionen an.

Das Argument "-x.y" ist die Kurzform des Arguments "-V:Company/Tag",
mit dem sich eine bestimmte Python-Runtime auswählen lässt, auch eine,
die nicht von python.org stammt. Jede nach **PEP 514** registrierte
Runtime ist auffindbar. Der Befehl "--list" führt alle verfügbaren
Runtimes im Format "-V:" auf.

Beim Argument "-V:" schränkt die Angabe der Company die Auswahl auf
Runtimes dieses Anbieters ein, während die Angabe nur des Tags unter
allen Anbietern auswählt. Beachte, dass ein fehlender Schrägstrich ein
Tag bedeutet:

   # Select any '3.*' tagged runtime
   py -V:3

   # Select any 'PythonCore' released runtime
   py -V:PythonCore/

   # Select PythonCore's latest Python 3 runtime
   py -V:PythonCore/3

Die Kurzform des Arguments ("-3") wählt immer nur aus den Kern-
Veröffentlichungen von Python und nicht aus anderen Distributionen.
Die längere Form ("-V:3") wählt dagegen aus allen.

The Company is matched on the full string, case-insenitive. The Tag is
matched oneither the full string, or a prefix, provided the next
character is a dot or a hyphen. This allows "-V:3.1" to match
"3.1-32", but not "3.10". Tags are sorted using numerical ordering
("3.10" is newer than "3.1"), but are compared using text ("-V:3.01"
does not match "3.1").


4.8.1.2. Virtuelle Umgebungen
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Neu in Version 3.5.

Wird der Starter ohne ausdrückliche Angabe einer Python-Version
aufgerufen und ist eine virtuelle Umgebung aktiv (angelegt mit dem
Modul "venv" der Standardbibliothek oder dem externen Werkzeug
"virtualenv"), führt der Starter den Interpreter der virtuellen
Umgebung aus und nicht den globalen. Um den globalen Interpreter
auszuführen, deaktiviere entweder die virtuelle Umgebung oder gib die
globale Python-Version ausdrücklich an.


4.8.1.3. Aus einem Skript
~~~~~~~~~~~~~~~~~~~~~~~~~

Legen wir ein Python-Testskript an — erstelle eine Datei namens
"hello.py" mit folgendem Inhalt

   #! python
   import sys
   sys.stdout.write("hello from Python %s\n" % (sys.version,))

Führe aus dem Verzeichnis, in dem hello.py liegt, den folgenden Befehl
aus:

   py hello.py

Du solltest sehen, dass die Versionsnummer deiner neuesten
Installation von Python 2.x ausgegeben wird. Versuche jetzt, die erste
Zeile zu ändern in:

   #! python3

Beim erneuten Ausführen des Befehls sollten nun die Angaben zum
neuesten Python 3.x erscheinen. Wie bei den obigen
Befehlszeilenbeispielen kannst du einen genaueren Versionszusatz
angeben. Wenn Python 3.7 installiert ist, versuche, die erste Zeile in
"#! python3.7" zu ändern, dann sollten die Versionsangaben von 3.7
ausgegeben werden.

Beachte, dass ein bloßes „python“ — anders als bei interaktiver
Verwendung — die neueste installierte Version von Python 2.x
verwendet. Das dient der Abwärtsverträglichkeit und der
Verträglichkeit mit Unix, wo der Befehl "python" üblicherweise Python
2 meint.


4.8.1.4. Über Dateiverknüpfungen
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Der Starter sollte bei seiner Installation mit Python-Dateien
verknüpft worden sein (also mit ".py"-, ".pyw"- und ".pyc"-Dateien).
Das heißt, wenn du eine dieser Dateien im Windows-Explorer doppelt
anklickst, wird der Starter verwendet, und du kannst daher dieselben
oben beschriebenen Mittel nutzen, um im Skript die zu verwendende
Version anzugeben.

Der wesentliche Vorteil dabei ist, dass ein einziger Starter je nach
Inhalt der ersten Zeile gleichzeitig mehrere Python-Versionen
unterstützen kann.


4.8.2. Shebang Lines
--------------------

Beginnt die erste Zeile einer Skriptdatei mit "#!", spricht man von
einer „Shebang“-Zeile. Linux und andere unixartige Betriebssysteme
unterstützen solche Zeilen von Haus aus, und dort werden sie häufig
verwendet, um anzugeben, wie ein Skript ausgeführt werden soll. Dieser
Starter erlaubt dasselbe für Python-Skripte unter Windows, und die
obigen Beispiele zeigen die Verwendung.

Damit Shebang-Zeilen in Python-Skripten zwischen Unix und Windows
übertragbar bleiben, unterstützt dieser Starter mehrere „virtuelle“
Befehle, mit denen sich der zu verwendende Interpreter angeben lässt.
Die unterstützten virtuellen Befehle sind:

* "/usr/bin/env"

* "/usr/bin/python"

* "/usr/local/bin/python"

* "python"

Beginnt die erste Zeile deines Skripts zum Beispiel mit

   #! /usr/bin/python

The default Python will be located and used.  As many Python scripts
written to work on Unix will already have this line, you should find
these scripts can be used by the launcher without modification.  If
you are writing a new script on Windows which you hope will be useful
on Unix, you should use one of the shebang lines starting with "/usr".

Any of the above virtual commands can be suffixed with an explicit
version (either just the major version, or the major and minor
version). Furthermore the 32-bit version can be requested by adding
"-32" after the minor version. I.e. "/usr/bin/python3.7-32" will
request usage of the 32-bit python 3.7.

Neu in Version 3.7: Ab Python-Starter 3.7 lässt sich mit dem Suffix
„-64“ die 64-Bit-Version anfordern. Außerdem lassen sich Hauptversion
und Architektur ohne Nebenversion angeben (also
"/usr/bin/python3-64").

Geändert in Version 3.11: Das Suffix „-64“ ist veraltet und bedeutet
jetzt „jede Architektur, die nicht nachweislich i386/32-Bit ist“. Um
eine bestimmte Umgebung anzufordern, verwende das neue Argument
"-V:*TAG*" mit dem vollständigen Tag.

The "/usr/bin/env" form of shebang line has one further special
property. Before looking for installed Python interpreters, this form
will search the executable "PATH" for a Python executable matching the
name provided as the first argument. This corresponds to the behaviour
of the Unix "env" program, which performs a "PATH" search. If an
executable matching the first argument after the "env" command cannot
be found, but the argument starts with "python", it will be handled as
described for the other virtual commands. The environment variable
"PYLAUNCHER_NO_SEARCH_PATH" may be set (to any value) to skip this
search of "PATH".

Shebang-Zeilen, die auf keines dieser Muster passen, werden im
Abschnitt "[commands]" der .INI-Datei des Starters nachgeschlagen.
Damit lassen sich bestimmte Befehle so behandeln, wie es für dein
System sinnvoll ist. Der Name des Befehls muss ein einzelnes Argument
sein (keine Leerzeichen in der ausführbaren Datei des Shebangs), und
der eingesetzte Wert ist der vollständige Pfad zur ausführbaren Datei
(in der .INI angegebene zusätzliche Argumente werden als Teil des
Dateinamens in Anführungszeichen gesetzt).

   [commands]
   /bin/xpython=C:\Program Files\XPython\python.exe

Alle Befehle, die nicht in der .INI-Datei zu finden sind, werden als
**Windows**-Pfade zu ausführbaren Dateien behandelt, die absolut oder
relativ zum Verzeichnis der Skriptdatei sind. Das ist eine
Bequemlichkeit für Skripte, die nur unter Windows laufen, etwa von
einem Installationsprogramm erzeugte, denn dieses Verhalten ist mit
unixartigen Shells nicht vereinbar. Diese Pfade dürfen in
Anführungszeichen stehen und mehrere Argumente enthalten. Danach
werden der Pfad zum Skript und etwaige weitere Argumente angehängt.


4.8.3. Argumente in Shebang-Zeilen
----------------------------------

Die Shebang-Zeilen können auch zusätzliche Optionen angeben, die an
den Python-Interpreter weitergegeben werden. Wenn du zum Beispiel
diese Shebang-Zeile hast:

   #! /usr/bin/python -v

dann wird Python mit der Option "-v" gestartet


4.8.4. Anpassung
----------------


4.8.4.1. Anpassung über INI-Dateien
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Der Starter sucht nach zwei .ini-Dateien — "py.ini" im
Anwendungsdatenverzeichnis des aktuellen Benutzers ("%LOCALAPPDATA%"
oder "$env:LocalAppData") und "py.ini" im Verzeichnis des Starters.
Dieselben .ini-Dateien werden sowohl für die „Konsolen“-Fassung des
Starters (also py.exe) als auch für die „Windows“-Fassung (also
pyw.exe) verwendet.

Anpassungen im „Anwendungsverzeichnis“ haben Vorrang vor denen neben
der ausführbaren Datei, sodass ein Benutzer, der möglicherweise keinen
Schreibzugriff auf die .ini-Datei neben dem Starter hat, Befehle in
dieser globalen .ini-Datei überschreiben kann.


4.8.4.2. Standard-Python-Versionen anpassen
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

In manchen Fällen lässt sich einem Befehl ein Versionszusatz mitgeben,
der festlegt, welche Python-Version der Befehl verwendet. Ein
Versionszusatz beginnt mit einer Hauptversionsnummer und kann
wahlweise von einem Punkt („.“) und einer Nebenversionsangabe gefolgt
werden. Außerdem lässt sich durch Anfügen von „-32“ oder „-64“
angeben, ob eine 32- oder 64-Bit-Umsetzung angefordert wird.

Die Shebang-Zeile "#!python" hat zum Beispiel keinen Versionszusatz,
während "#!python3" einen Versionszusatz hat, der nur eine
Hauptversion angibt.

If no version qualifiers are found in a command, the environment
variable "PY_PYTHON" can be set to specify the default version
qualifier. If it is not set, the default is "3". The variable can
specify any value that may be passed on the command line, such as "3",
"3.7", "3.7-32" or "3.7-64". (Note that the "-64" option is only
available with the launcher included with Python 3.7 or newer.)

Finden sich keine Nebenversionszusätze, lässt sich die
Umgebungsvariable "PY_PYTHON{major}" setzen (wobei "{major}" der oben
ermittelte aktuelle Hauptversionszusatz ist), um die vollständige
Version anzugeben. Findet sich keine solche Option, zählt der Starter
die installierten Python-Versionen auf und verwendet die neueste
gefundene Nebenveröffentlichung zur Hauptversion. Das ist
wahrscheinlich, aber nicht garantiert die zuletzt installierte Version
dieser Familie.

Sind unter 64-Bit-Windows die 32- und die 64-Bit-Umsetzung derselben
Python-Version (Haupt.Neben) installiert, wird immer die 64-Bit-
Version vorgezogen. Das gilt für die 32- wie für die 64-Bit-Umsetzung
des Starters — ein 32-Bit-Starter führt bevorzugt eine 64-Bit-Python-
Installation der angegebenen Version aus, sofern vorhanden. So lässt
sich das Verhalten des Starters vorhersagen, wenn man nur weiß, welche
Versionen auf dem PC installiert sind, ohne die Reihenfolge der
Installation zu kennen (also ohne zu wissen, ob zuletzt eine 32- oder
eine 64-Bit-Version von Python und der zugehörige Starter installiert
wurde). Wie oben erwähnt, lässt sich dieses Verhalten mit einem
optionalen Suffix „-32“ oder „-64“ an der Versionsangabe ändern.

Beispiele:

* Sind keine einschlägigen Optionen gesetzt, verwenden die Befehle
  "python" und "python2" die neueste installierte Version von Python
  2.x, und der Befehl "python3" verwendet das neueste installierte
  Python 3.x.

* Der Befehl "python3.7" zieht überhaupt keine Optionen heran, da die
  Versionen vollständig angegeben sind.

* Bei "PY_PYTHON=3" verwenden die Befehle "python" und "python3" beide
  die neueste installierte Python-3-Version.

* Bei "PY_PYTHON=3.7-32" verwendet der Befehl "python" die 32-Bit-
  Umsetzung von 3.7, während der Befehl "python3" das neueste
  installierte Python verwendet (PY_PYTHON wurde überhaupt nicht
  herangezogen, da eine Hauptversion angegeben war).

* Bei "PY_PYTHON=3" und "PY_PYTHON3=3.7" verwenden die Befehle
  "python" und "python3" beide ausdrücklich 3.7

Neben Umgebungsvariablen lassen sich dieselben Einstellungen in der
.INI-Datei des Starters vornehmen. Der Abschnitt in der INI-Datei
heißt "[defaults]", und der Name des Schlüssels entspricht dem der
Umgebungsvariablen ohne das führende Präfix "PY_" (beachte, dass die
Schlüsselnamen in der INI-Datei ohne Rücksicht auf Groß- und
Kleinschreibung gelesen werden). Der Inhalt einer Umgebungsvariablen
überschreibt die Angaben in der INI-Datei.

Zum Beispiel:

* "PY_PYTHON=3.7" zu setzen entspricht einer INI-Datei mit folgendem
  Inhalt:

   [defaults]
   python=3.7

* "PY_PYTHON=3" und "PY_PYTHON3=3.7" zu setzen entspricht einer INI-
  Datei mit folgendem Inhalt:

   [defaults]
   python=3
   python3=3.7


4.8.5. Diagnose
---------------

If an environment variable "PYLAUNCHER_DEBUG" is set (to any value),
the launcher will print diagnostic information to stderr (i.e. to the
console). While this information manages to be simultaneously verbose
*and* terse, it should allow you to see what versions of Python were
located, why a particular version was chosen and the exact command-
line used to execute the target Python. It is primarily intended for
testing and debugging.


4.8.6. Dry Run
--------------

If an environment variable "PYLAUNCHER_DRYRUN" is set (to any value),
the launcher will output the command it would have run, but will not
actually launch Python. This may be useful for tools that want to use
the launcher to detect and then launch Python directly. Note that the
command written to standard output is always encoded using UTF-8, and
may not render correctly in the console.


4.8.7. Installation bei Bedarf
------------------------------

If an environment variable "PYLAUNCHER_ALLOW_INSTALL" is set (to any
value), and the requested Python version is not installed but is
available on the Microsoft Store, the launcher will attempt to install
it. This may require user interaction to complete, and you may need to
run the command again.

An additional "PYLAUNCHER_ALWAYS_INSTALL" variable causes the launcher
to always try to install Python, even if it is detected. This is
mainly intended for testing (and should be used with
"PYLAUNCHER_DRYRUN").


4.8.8. Rückgabewerte
--------------------

Der Python-Starter kann die folgenden Beendigungswerte zurückgeben.
Leider lassen sie sich nicht vom Beendigungswert von Python selbst
unterscheiden.

Die Namen der Werte sind die im Quellcode verwendeten und dienen nur
dem Nachschlagen. Es gibt keine Möglichkeit, sie abzurufen oder
aufzulösen, außer diese Seite zu lesen. Die Einträge stehen in
alphabetischer Reihenfolge der Namen.

+---------------------+---------+-------------------------------------------------+
| Name                | Wert    | Beschreibung                                    |
|=====================|=========|=================================================|
| RC_BAD_VENV_CFG     | 107     | Eine "pyvenv.cfg" wurde gefunden, ist aber      |
|                     |         | beschädigt.                                     |
+---------------------+---------+-------------------------------------------------+
| RC_CREATE_PROCESS   | 101     | Python konnte nicht gestartet werden.           |
+---------------------+---------+-------------------------------------------------+
| RC_INSTALLING       | 111     | Eine Installation wurde angestoßen, der Befehl  |
|                     |         | muss aber nach deren Abschluss erneut           |
|                     |         | ausgeführt werden.                              |
+---------------------+---------+-------------------------------------------------+
| RC_INTERNAL_ERROR   | 109     | Unerwarteter Fehler. Bitte melde einen          |
|                     |         | Fehlerbericht.                                  |
+---------------------+---------+-------------------------------------------------+
| RC_NO_COMMANDLINE   | 108     | Die Befehlszeile konnte nicht vom               |
|                     |         | Betriebssystem bezogen werden.                  |
+---------------------+---------+-------------------------------------------------+
| RC_NO_PYTHON        | 103     | Die verlangte Version konnte nicht gefunden     |
|                     |         | werden.                                         |
+---------------------+---------+-------------------------------------------------+
| RC_NO_VENV_CFG      | 106     | Eine "pyvenv.cfg" war erforderlich, wurde aber  |
|                     |         | nicht gefunden.                                 |
+---------------------+---------+-------------------------------------------------+


4.9. Module finden
==================

Diese Hinweise ergänzen die Beschreibung unter The initialization of
the sys.path module search path um Einzelheiten zu Windows.

Wird keine Datei "._pth" gefunden, wird "sys.path" unter Windows so
gefüllt:

* Am Anfang wird ein leerer Eintrag hinzugefügt, der dem aktuellen
  Verzeichnis entspricht.

* Existiert die Umgebungsvariable "PYTHONPATH", wie unter
  Umgebungsvariablen beschrieben, werden als nächstes ihre Einträge
  hinzugefügt. Beachte, dass die Pfade in dieser Variablen unter
  Windows durch Semikolons getrennt sein müssen, um sie vom
  Doppelpunkt in Laufwerksbezeichnungen ("C:\" und so weiter) zu
  unterscheiden.

* Weitere „Anwendungspfade“ lassen sich in der Registrierung als
  Unterschlüssel von "\SOFTWARE\Python\PythonCore{version}\PythonPath"
  sowohl unter "HKEY_CURRENT_USER" als auch unter "HKEY_LOCAL_MACHINE"
  hinzufügen. Unterschlüssel, deren Standardwert durch Semikolons
  getrennte Pfadangaben sind, führen dazu, dass jeder dieser Pfade zu
  "sys.path" hinzugefügt wird. (Beachte, dass alle bekannten
  Installationsprogramme nur HKLM verwenden, HKCU ist daher meist
  leer.)

* Ist die Umgebungsvariable "PYTHONHOME" gesetzt, wird sie als
  „Python-Heimat“ angenommen. Andernfalls wird über den Pfad der
  ausführbaren Python-Hauptdatei eine „Wegmarke“ gesucht (entweder
  "Lib\os.py" oder "pythonXY.zip"), um die „Python-Heimat“ zu
  erschließen. Wird eine Python-Heimat gefunden, richten sich die zu
  "sys.path" hinzugefügten Unterverzeichnisse ("Lib", "plat-win" und
  so weiter) nach diesem Ordner. Andernfalls wird der Kernpfad von
  Python aus dem in der Registrierung gespeicherten PythonPath
  gebildet.

* Lässt sich die Python-Heimat nicht ermitteln, ist in der Umgebung
  kein "PYTHONPATH" angegeben und sind keine Registrierungseinträge zu
  finden, wird ein Standardpfad mit relativen Einträgen verwendet
  (etwa ".\Lib;.\plat-win" und so weiter).

Wird neben der ausführbaren Hauptdatei oder im Verzeichnis eine Ebene
darüber eine Datei "pyvenv.cfg" gefunden, gilt Folgendes abweichend:

* Ist "home" ein absoluter Pfad und "PYTHONHOME" nicht gesetzt, wird
  beim Erschließen der Heimat dieser Pfad anstelle des Pfads zur
  ausführbaren Hauptdatei verwendet.

Unterm Strich ergibt sich daraus:

* Wird "python.exe" oder eine andere .exe im Python-Hauptverzeichnis
  ausgeführt (entweder eine installierte Version oder direkt aus dem
  Verzeichnis PCbuild), wird der Kernpfad erschlossen und die
  Kernpfade in der Registrierung werden ignoriert. Andere
  „Anwendungspfade“ in der Registrierung werden immer gelesen.

* Läuft Python innerhalb einer anderen .exe (anderes Verzeichnis, über
  COM eingebettet und so weiter), wird die „Python-Heimat“ nicht
  erschlossen, es wird daher der Kernpfad aus der Registrierung
  verwendet. Andere „Anwendungspfade“ in der Registrierung werden
  immer gelesen.

* Findet Python seine Heimat nicht und gibt es keinen
  Registrierungswert (eingefrorene .exe, sehr eigenartige
  Installationsaufbauten), erhältst du einen Pfad mit einigen
  vorgegebenen, aber relativen Pfaden.

Wer Python in seine Anwendung oder Distribution einpacken möchte,
vermeidet mit den folgenden Ratschlägen Konflikte mit anderen
Installationen:

* Lege eine Datei "._pth" neben deine ausführbare Datei, die die
  einzubeziehenden Verzeichnisse enthält. Damit werden in der
  Registrierung und in Umgebungsvariablen aufgeführte Pfade ignoriert,
  ebenso "site", sofern dort nicht "import site" steht.

* If you are loading "python3.dll" or "python37.dll" in your own
  executable, explicitly call "Py_SetPath()" or (at least)
  "Py_SetProgramName()" before "Py_Initialize()".

* Leere beziehungsweise überschreibe "PYTHONPATH" und setze
  "PYTHONHOME", bevor du "python.exe" aus deiner Anwendung startest.

* Wenn du die vorherigen Vorschläge nicht verwenden kannst (etwa weil
  du eine Distribution bist, die den direkten Aufruf von "python.exe"
  erlaubt), stelle sicher, dass die Wegmarke ("Lib\os.py") in deinem
  Installationsverzeichnis vorhanden ist. (Beachte, dass sie innerhalb
  einer ZIP-Datei nicht erkannt wird, eine richtig benannte ZIP-Datei
  dagegen schon.)

Damit ist sichergestellt, dass die Dateien einer systemweiten
Installation nicht Vorrang vor der mit deiner Anwendung ausgelieferten
Standardbibliothek erhalten. Andernfalls könnten deine Benutzer
Schwierigkeiten mit deiner Anwendung bekommen. Beachte, dass der erste
Vorschlag der beste ist, weil die anderen weiterhin für ungewöhnliche
Pfade in der Registrierung und für site-packages des Benutzers
anfällig sein können.

Geändert in Version 3.6: Unterstützung für die Datei "._pth"
hinzugefügt und die Option "applocal" aus "pyvenv.cfg" entfernt.

Geändert in Version 3.6: "python*XX*.zip" als mögliche Wegmarke
hinzugefügt, wenn sie direkt neben der ausführbaren Datei liegt.

Veraltet ab Version 3.6: Module, die in der Registrierung unter
"Modules" (nicht "PythonPath") angegeben sind, können von
"importlib.machinery.WindowsRegistryFinder" importiert werden. Dieser
Finder ist unter Windows in 3.6.0 und früher eingeschaltet, muss
künftig aber möglicherweise ausdrücklich zu "sys.meta_path"
hinzugefügt werden.


4.10. Zusätzliche Module
========================

Auch wenn Python darauf abzielt, auf allen Plattformen zu laufen, gibt
es Funktionen, die es nur unter Windows gibt. Es existieren einige
Module — in der Standardbibliothek und außerhalb — sowie
Codeschnipsel, um diese Funktionen zu nutzen.

Die Windows-spezifischen Standardmodule sind unter MS Windows-
spezifische Dienste beschrieben.


4.10.1. PyWin32
---------------

The PyWin32 module by Mark Hammond is a collection of modules for
advanced Windows-specific support.  This includes utilities for:

* Component Object Model (COM)

* Win32-API-Aufrufe

* Registrierung

* Ereignisprotokoll

* Microsoft Foundation Classes (MFC) user interfaces

PythonWin ist eine Beispielanwendung mit MFC, die mit PyWin32
ausgeliefert wird. Es ist eine einbettbare Entwicklungsumgebung mit
integriertem Debugger.

Siehe auch:

  Win32 How Do I...?
     von Tim Golden

  Python and COM
     von David und Paul Boddie


4.10.2. cx_Freeze
-----------------

cx_Freeze verpackt Python-Skripte in ausführbare Windows-Programme
("***.exe"-Dateien). Danach kannst du deine Anwendung weitergeben,
ohne dass deine Benutzer Python installieren müssen.


4.11. Python unter Windows kompilieren
======================================

Wenn du CPython selbst kompilieren möchtest, besorge dir als Erstes
den Quellcode. Du kannst entweder den Quellcode der neuesten
Veröffentlichung herunterladen oder einfach einen frischen Checkout
holen.

Der Quellbaum enthält eine Build-Solution und Projektdateien für
Microsoft Visual Studio, den Compiler, mit dem die offiziellen Python-
Veröffentlichungen gebaut werden. Diese Dateien liegen im Verzeichnis
"PCbuild".

Allgemeine Hinweise zum Bauvorgang stehen in "PCbuild/readme.txt".

Für Erweiterungsmodule siehe Building C and C++ Extensions on Windows.


4.12. Other Platforms
=====================

With ongoing development of Python, some platforms that used to be
supported earlier are no longer supported (due to the lack of users or
developers). Check **PEP 11** for details on all unsupported
platforms.

* Windows CE is no longer supported since Python 3 (if it ever was).

* The Cygwin installer offers to install the Python interpreter as
  well

See Python for Windows for detailed information about platforms with
pre-compiled installers.
