4. Utilisation de Python sur Windows
************************************

Ce document a pour but de donner une vue d'ensemble des comportements
spécifiques à Windows dont vous devriez être au courant si vous
utilisez Python sur Microsoft Windows.

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.

Comme spécifié dans la **PEP 11**, une *release* Python ne gère qu'une
plateforme Windows alors que Microsoft considère la plateforme sous
support étendu. Ce qui veut dire que Python 3.12 fonctionne sur
Windows 8.1 et plus. Si vous avez besoin de compatibilité Windows 7,
vous devez utiliser Python 3.8.

Il existe un certain nombre d'installateurs différents disponibles
pour Windows, chacun avec certains avantages et inconvénients.

L'installateur complet contient tous les composants et est la
meilleure option pour les développeurs utilisant Python pour tout type
de projet.

Le paquet Microsoft Store est une simple installation de Python qui
convient à l'exécution de scripts, de paquets et à l’utilisation
d’IDLE ou d'autres environnements de développement. Il nécessite
Windows 10 ou supérieur, mais peut être installé en toute sécurité
sans endommager d'autres programmes. Il fournit également de
nombreuses commandes pratiques pour lancer Python et ses outils.

Les paquets nuget.org sont des installations légères destinées aux
systèmes d'intégration continue. Ils peuvent être utilisés pour créer
des packages Python ou exécuter des scripts, mais ne sont pas
modifiables et n'ont pas d'outils d'interface utilisateur.

Le paquet intégrable est un paquet minimal de Python approprié pour
l'intégration dans une plus grande application.


4.1. L'installateur complet
===========================


4.1.1. Étapes d'installation
----------------------------

Quatre installateurs Python 3.12 sont disponibles au téléchargement —
deux de chaque pour les versions 32-bit et 64-bit de l'interpréteur.
L'**installateur web** est léger, et téléchargera automatiquement les
composants nécessaires. L'**installateur hors-ligne** inclut les
composants nécessaires pour une installation par défaut et n'a besoin
d'une connexion internet que pour des fonctionnalités optionnelles.
Voir Installation sans téléchargement pour d'autres moyens d’éviter
des téléchargements durant l'installation.

Après avoir lancé l'installateur, deux options s'affichent :

[image]

Si vous sélectionnez « Installer Maintenant » ("Install Now") :

* Vous n'aurez *pas* besoin d'avoir les droits d'administrateur (sauf
  si une mise à jour de la bibliothèque d'exécution C est nécessaire
  ou si vous installez le Lanceur Python pour Windows pour tous les
  utilisateurs)

* Python sera installé dans votre répertoire utilisateur

* Le Lanceur Python pour Windows sera installé suivant l'option en bas
  de la première page

* La bibliothèque standard, la suite de tests, le lanceur et *pip*
  seront installés

* Si l'option est cochée, le dossier d'installation sera ajouté à
  votre "PATH"

* Les raccourcis ne seront visibles que pour l'utilisateur actuel

Sélectionner « Personnaliser l’installation » ("Customize
installation") vous permettra de sélectionner les fonctionnalités à
installer, le chemin d'installation et d'autres options ou des options
post-installation. Pour installer des binaires ou symboles de
débogage, vous devrez utiliser cette option.

Pour effectuer une installation pour tous les utilisateurs, vous devez
sélectionner « Personnaliser l’installation ». Dans ce cas :

* Vous pouvez avoir à donner une approbation ou des identifiants
  administrateur

* Python sera installé dans le dossier *Program Files*

* Le Lanceur Python pour Windows sera installé dans le dossier
  *Windows*

* Des fonctionnalités optionnelles peuvent être sélectionnées durant
  l'installation

* La bibliothèque standard peut être pré-compilée en code
  intermédiaire (*bytecode* en anglais)

* Si sélectionné, le chemin d'installation sera ajouté au "PATH"
  système

* Les raccourcis sont disponibles pour tous les utilisateurs


4.1.2. Suppression de la limitation "MAX_PATH"
----------------------------------------------

Historiquement les chemins sous Windows étaient limités 260
caractères. Cela impliquait que les chemins plus longs n'étaient pas
résolus, et seraient une cause d'erreurs.

Dans les dernières versions de Windows, cette limitation peut être
étendue à approximativement 32.000 caractères. Votre administrateur
devra activer la stratégie de groupe « **Enable Win32 long paths** »
ou mettre la valeur de "LongPathsEnabled" à "1" dans de registre à
"HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\FileSystem".

Ceci permet à la fonction "open()", au module "os" et à la plupart des
autres fonctionnalités utilisant des chemins d'accepter et de renvoyer
des chemins plus longs que 260 caractères.

Après avoir changé l'option si-dessus, aucune configuration
supplémentaire n'est requise.

Modifié dans la version 3.6: Gestion des chemins longs.


4.1.3. Installation sans l'interface utilisateur
------------------------------------------------

Toutes les options disponibles dans l'installateur graphique peuvent
aussi être spécifiées dans l'invite de commande, permettant à des
installateurs scriptés de répliquer une installation sur plusieurs
machines sans interaction humaine. Ces options peuvent aussi être
ajoutées sans enlever l'interface graphique pour changer les valeurs
par défauts.

The following options (found by executing the installer with "/?") can
be passed into the installer:

+-----------------------+----------------------------------------------------------+
| Nom                   | Description                                              |
|=======================|==========================================================|
| /passive              | to display progress without requiring user interaction   |
+-----------------------+----------------------------------------------------------+
| /quiet                | to install/uninstall without displaying any UI           |
+-----------------------+----------------------------------------------------------+
| /simple               | to prevent user customization                            |
+-----------------------+----------------------------------------------------------+
| /uninstall            | to remove Python (without confirmation)                  |
+-----------------------+----------------------------------------------------------+
| /layout [directory]   | to pre-download all components                           |
+-----------------------+----------------------------------------------------------+
| /log [filename]       | to specify log files location                            |
+-----------------------+----------------------------------------------------------+

Toutes les autres options sont passées sous la forme "name=value", ou
"value" est normalement soit "0" pour désactiver une fonctionnalité,
soit "1" pour activer une fonctionnalité, soit un chemin. Ci-dessous
la liste complète des options.

+-----------------------------+----------------------------------------+----------------------------+
| Nom                         | Description                            | Valeur par défaut          |
|=============================|========================================|============================|
| InstallAllUsers             | Effectue une installation pour tous    | 0                          |
|                             | les utilisateurs.                      |                            |
+-----------------------------+----------------------------------------+----------------------------+
| TargetDir                   | Le dossier d'installation              | Sélection basée sur        |
|                             |                                        | InstallAllUsers            |
+-----------------------------+----------------------------------------+----------------------------+
| DefaultAllUsersTargetDir    | Le dossier d'installation par défaut   | "%ProgramFiles%\Python     |
|                             | pour les installations pour tous les   | X.Y" ou "%ProgramFiles(x8  |
|                             | utilisateurs                           | 6)%\Python X.Y"            |
+-----------------------------+----------------------------------------+----------------------------+
| DefaultJustForMeTargetDir   | Le dossier d'installation par défaut   | "%LocalAppData%\Programs\  |
|                             | pour des installations juste pour soi  | Python\PythonXY" ou "%Loc  |
|                             |                                        | alAppData%\Programs\Pytho  |
|                             |                                        | n\PythonXY-32" ou "%Local  |
|                             |                                        | AppData%\Programs\Python\  |
|                             |                                        | PythonXY-64"               |
+-----------------------------+----------------------------------------+----------------------------+
| DefaultCustomTargetDir      | Le dossier d'installation personnalisé | (vide)                     |
|                             | par défaut affiché par l'interface     |                            |
|                             | utilisateur                            |                            |
+-----------------------------+----------------------------------------+----------------------------+
| AssociateFiles              | Crée les associations de fichiers si   | 1                          |
|                             | le lanceur est aussi installé.         |                            |
+-----------------------------+----------------------------------------+----------------------------+
| CompileAll                  | Compile tous les fichiers ".py" en     | 0                          |
|                             | ".pyc".                                |                            |
+-----------------------------+----------------------------------------+----------------------------+
| PrependPath                 | Ajoute les dossiers "install" et       | 0                          |
|                             | "Scripts" à "PATH" et assigne ".PY" à  |                            |
|                             | "PATHEXT"                              |                            |
+-----------------------------+----------------------------------------+----------------------------+
| AppendPath                  | Ajoute les dossiers "install" et       | 0                          |
|                             | "Scripts" à "PATH" et assigne ".PY" à  |                            |
|                             | "PATHEXT"                              |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Shortcuts                   | Crée des raccourcis pour               | 1                          |
|                             | l'interpréteur, la documentation et    |                            |
|                             | IDLE si installé.                      |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Include_doc                 | Installe le manuel Python              | 1                          |
+-----------------------------+----------------------------------------+----------------------------+
| Include_debug               | Installe les binaires de débogage      | 0                          |
+-----------------------------+----------------------------------------+----------------------------+
| Include_dev                 | Installe les en-têtes et les           | 1                          |
|                             | bibliothèques de développement.        |                            |
|                             | L'omission de cette étape peut         |                            |
|                             | conduire à une installation            |                            |
|                             | inutilisable.                          |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Include_exe                 | Installer "python.exe" et les fichiers | 1                          |
|                             | associés. L'omission de cette étape    |                            |
|                             | peut conduire à une installation       |                            |
|                             | inutilisable.                          |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Include_launcher            | Installe le Lanceur Python pour        | 1                          |
|                             | Windows.                               |                            |
+-----------------------------+----------------------------------------+----------------------------+
| InstallLauncherAllUsers     | Installe le lanceur pour tous les      | 1                          |
|                             | utilisateurs. Nécessite que            |                            |
|                             | "Include_launcher" soit mis à "1"      |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Include_lib                 | Installe la bibliothèque standard et   | 1                          |
|                             | les modules d'extension. L'omission de |                            |
|                             | cette étape peut conduire à une        |                            |
|                             | installation inutilisable.             |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Include_pip                 | Installe "pip" et "setuptools"         | 1                          |
+-----------------------------+----------------------------------------+----------------------------+
| Include_symbols             | Installe les symboles de débogage      | 0                          |
|                             | ("*.pdb")                              |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Include_tcltk               | Installe Tcl/Tk et IDLE                | 1                          |
+-----------------------------+----------------------------------------+----------------------------+
| Include_test                | Installe la suite de tests de la       | 1                          |
|                             | bibliothèque standard                  |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Include_tools               | Installe les scripts utilitaires       | 1                          |
+-----------------------------+----------------------------------------+----------------------------+
| LauncherOnly                | Installe seulement le lanceur. Ceci    | 0                          |
|                             | écrasera la plupart des autres         |                            |
|                             | options.                               |                            |
+-----------------------------+----------------------------------------+----------------------------+
| SimpleInstall               | Désactive la plupart de l'interface    | 0                          |
|                             | d'installation                         |                            |
+-----------------------------+----------------------------------------+----------------------------+
| SimpleInstallDescription    | Un message personnalisé à afficher     | (vide)                     |
|                             | quand l'interface d'installation       |                            |
|                             | simplifiée est utilisée.               |                            |
+-----------------------------+----------------------------------------+----------------------------+

Par exemple, pour installer silencieusement Python sur tout le
système, vous pourriez utilisez la commande suivante (depuis une
invite de commande administrateur) :

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

Pour permettre à l'utilisateur d'installer facilement une copie de
Python sans la suite de tests, vous pouvez proposer un raccourci avec
la commande suivante. Cela affichera une page initiale simplifiée et
interdira la personnalisation :

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

(Notez qu'omettre le lanceur omet aussi les associations de fichiers,
et n'est recommandé que pour les installations par utilisateur quand
il y a aussi une installation complète sur le système qui a inclus de
lanceur.)

Les options listées ci-dessus peuvent aussi être passées dans un
fichier nommé "unattend.xml" à côté de l'exécutable. Ce fichier
spécifie une liste d'options et de valeurs. Quand une valeur est
donnée en tant qu'attribut, elle sera convertie en nombre si possible.
Les valeurs données en élément texte sont toujours laissées en tant
que chaînes de caractères. Ce fichier d'exemple propose les mêmes
options que l'exemple précédent :

   <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. Installation sans téléchargement
---------------------------------------

Comme certaines fonctionnalités de Python ne sont pas incluses dans
l'installateur initial, la sélection de certaines de ces
fonctionnalités peut demander une connexion Internet. Pour éviter ce
besoin, tous les composants nécessaires peuvent être téléchargés à la
demande pour créer un agencement (*layout*) complet qui ne demandera
plus de connexion Internet indépendamment des options sélectionnées.
Notez que ce téléchargement peut être plus gros que nécessaire, mais
lorsqu'un un grand nombre d'installations doivent être faites, il est
très utile d'avoir une copie locale.

Exécutez la commande suivante depuis l'invite de commande pour
télécharger tous les fichiers requis possibles. Rappelez-vous de
remplacer "python-3.9.0.exe" par le nom réel de votre installateur et
de créer des agencements avec leurs propres dossiers pour éviter les
conflits entre fichiers du même nom.

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

Vous pouvez aussi spécifier l'option "/quiet" pour masquer la
progression.


4.1.5. Modification d'une installation
--------------------------------------

Une fois Python installé, vous pouvez ajouter ou supprimer des
fonctionnalités depuis l'outil Windows *Programs and Features*
(Programmes et Fonctionnalités). Sélectionnez la ligne "Python" et
choisissez « Uninstall/Change » (Désinstaller/Modifier) pour ouvrir
l'installateur en mode maintenance.

« Modify » vous permet d'ajouter ou d'enlever des fonctionnalités en
modifiant les cases à cocher (les cases inchangées n'installeront ou
ne supprimeront rien). Certaines options ne peuvent pas être modifiées
dans ce mode, comme le dossier d'installation. Pour modifier ces
options, vous devrez ré-installer Python entièrement.

« Repair » vérifiera tous les fichiers qui doivent être installés avec
les paramètres actuels le sont, et remplacera ceux qui ont étés
supprimés ou modifiés.

« Uninstall » désinstallera Python entièrement, à l'exception du
Lanceur Python pour Windows qui à sa propre ligne dans *Programs and
Features*.


4.2. Le paquet Microsoft Store
==============================

Ajouté dans la version 3.7.2.

Le paquet *Microsoft Store* est un interpréteur Python facilement
installable qui est destiné principalement à une utilisation
interactive, par exemple, par des étudiants.

Pour installer le paquet, assurez-vous d'avoir les dernières mises à
jour de Windows 10 et de chercher dans l'application *Microsoft Store*
“Python 3.12”. Assurez-vous que l'application que vous sélectionnez
est publiée par la *Python Software Foundation* et installez-la.

Avertissement:

  Python sera toujours disponible gratuitement sur le Microsoft Store.
  Si vous êtes invité à payer, vous n'avez pas sélectionné le bon
  paquet.

Après l'installation, Python peut être lancé depuis le menu Démarrer.
Il est aussi disponible à partir de n'importe quelle invite de
commande ou session PowerShell en entrant "python". De plus, pip et
IDLE peuvent être utilisés en entrant "pip" ou "idle" . IDLE peut
également être trouvé dans le menu Démarrer.

Les trois commandes sont également disponibles avec les suffixes de
numéro de version, par exemple, "python3.exe" et "python3.x.exe" ainsi
que "python.exe" (ou "3.x" est la version spécifique que vous
souhaitez lancer, tel que 3.12). Depuis le « menu Démarrer », ouvrez «
Alias d'exécution d'application » (ou « *Manage App Execution Aliases*
» en anglais) pour choisir quelle version de Python est associée à
quelle commande. Il est recommandé de s'assurer que "pip" et "idle"
utilisent la même version de Python que la commande "python".

Les environnements virtuels peuvent être créés avec "python -m venv"
et activés et utilisés normalement.

Si vous avez installé une autre version de Python et l'avez ajoutée à
votre variable d'environnement "PATH", elle sera disponible en tant
que "python.exe" plutôt que celle de la boutique Microsoft. Pour
accéder à la nouvelle installation, utilisez "python3.exe" ou
"python3.x.exe".

Le lanceur "py.exe" va détecter cette installation Python, mais
préfèrera les versions de l'installateur traditionnel.

Pour supprimer Python, depuis les paramètres Windows ouvrez *Apps and
Features* (Applications et Fonctionnalités), ou bien trouvez Python
dans le menu Démarrer et cliquez avec le bouton droit pour
sélectionner désinstaller. La désinstallation supprimera tous les
paquets que vous avez installés directement dans cette installation
Python, mais ne supprimera aucun environnement virtuel


4.2.1. Problèmes connus
-----------------------


4.2.1.1. Redirection des données locales, du registre et des chemins temporaires
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

En raison de restrictions sur les applications Microsoft Store, les
scripts Python peuvent ne pas avoir un accès en écriture complet aux
emplacements partagés tels que "TEMP" et le registre. Au lieu de cela,
il écrira sur une copie privée. Si vos scripts doivent modifier les
emplacements partagés, vous devrez installer le programme
d'installation complet.

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".

Vous pouvez trouver le chemin réel de n'importe quel fichier existant
en utilisant "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'

Lors de l'écriture dans le registre Windows, les comportements
suivants existent :

* 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.

Pour en savoir plus sur ces limitations, consultez la documentation de
Microsoft à propos des applications avec une confiance totale,
actuellement disponible sur docs.microsoft.com/fr-
fr/windows/msix/desktop/desktop-to-uwp-behind-the-scenes


4.3. Les paquets *nuget.org*
============================

Ajouté dans la version 3.5.2.

Le paquet *nuget.org* est un environnement Python de taille réduite
destiné à être utilisé sur des systèmes d'intégration et de génération
continus qui n'ont pas Python d'installé. Alors que *nuget* est “le
gestionnaire de package pour .NET”, il fonctionne également
parfaitement bien pour les packages contenant des outils de *build-
time*.

Visitez nuget.org pour les informations les plus à jour sur
l'utilisation de *nuget*. Ce qui suit est un résumé suffisant pour les
développeurs Python.

L'outil de ligne de commande "nuget.exe" peut être téléchargé
directement à partir de "https://aka.ms/nugetclidl", par exemple, à
l'aide de *curl* ou de PowerShell. Avec l'outil, la dernière version
de Python pour les machines 64 bits ou 32 bits est installée à l'aide
de :

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

Pour sélectionner une version particulière, ajoutez un "-Version
3.x.y". Le répertoire d'installation être modifié (de "."), et le
paquet sera installé dans un sous-répertoire. Par défaut, le sous-
répertoire est nommé comme le paquet, et sans l'option
"-ExcludeVersion", ce nom inclura la version spécifique installée. À
l'intérieur du sous-répertoire se trouve un répertoire "tools" qui
contient l'installation Python :

   # 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

En général, les paquets *nuget* ne peuvent pas êtres mis à jour et les
versions plus récentes doivent être installées côte à côte et
référencées à l'aide du chemin d'accès complet. Vous pouvez également
supprimer le répertoire du paquet manuellement et l'installer à
nouveau. De nombreux systèmes CI le feront automatiquement s'ils ne
conservent pas les fichiers entre les *builds*.

À côté du répertoire "tools" est un répertoire "build\native". Il
contient un fichier de propriétés MSBuild "python.props" qui peut être
utilisé dans un projet C++ pour référencer l'installation de Python.
L'inclusion des paramètres utilisera automatiquement les en-têtes et
les bibliothèques d'importation dans votre *build*.

Les pages d’information sur *nuget.org* sont
www.nuget.org/packages/python pour la version 64 Bits et
www.nuget.org/packages/pythonx86 pour la version 32 Bits.


4.4. Le paquet intégrable
=========================

Ajouté dans la version 3.5.

La distribution embarquée est un fichier ZIP contenant un
environnement Python minimal. Il est destiné à agir dans le cadre
d'une autre application, plutôt que d'être directement accessible par
les utilisateurs finaux.

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.

Note:

  La distribution intégrée n'inclut pas le Microsoft C Runtime et il
  est de la responsabilité de l'installateur d'application de le
  fournir. Le *runtime* peut avoir déjà été installé sur le système
  d'un utilisateur précédemment ou automatiquement via Windows Update,
  et peut être détecté en trouvant "ucrtbase.dll" dans le répertoire
  système.

Les paquets tiers doivent être installés par le programme
d'installation de l'application parallèlement à la distribution
embarquée. L'utilisation de pip pour gérer les dépendances comme pour
une installation Python régulière n'est pas prise en charge avec cette
distribution, mais il reste possible d'inclure et d'utiliser pip pour
les mises à jour automatiques. En général, les paquets tiers doivent
être traités dans le cadre de l'application (*vendoring*) afin que le
développeur puisse assurer la compatibilité avec les versions plus
récentes avant de fournir des mises à jour aux utilisateurs.

Les deux cas d'utilisation recommandés pour cette distribution sont
décrits ci-dessous.


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

Une application écrite en Python n'exige pas nécessairement que les
utilisateurs soient au courant de ce fait. La distribution embarquée
peut être utilisée dans ce cas pour inclure une version privée de
Python dans un package d'installation. Selon la façon dont il devrait
être transparent (ou inversement, à quel point il doit paraître
professionnel), il y a deux options.

L'utilisation d'un exécutable spécialisé en tant que lanceur nécessite
de la programmation, mais fournit l'expérience la plus transparente
pour les utilisateurs. Avec un lanceur personnalisé, il n'y a pas
d'indications évidentes que le programme s'exécute sur Python : les
icônes peuvent être personnalisées, les informations de la société et
de la version peuvent être spécifiées, et les associations de fichiers
se comportent correctement. Dans la plupart des cas, un lanceur
personnalisé devrait simplement pouvoir appeler "Py_Main" avec une
ligne de commande codée en dur.

L'approche la plus simple consiste à fournir un fichier batch ou un
raccourci généré qui appelle directement le "python.exe" ou
"pythonw.exe" avec les arguments de ligne de commande requis. Dans ce
cas, l'application semble être Python et non son nom réel, et les
utilisateurs peuvent avoir du mal à le distinguer des autres processus
Python en cours d'exécution ou des associations de fichiers.

Avec cette dernière approche, les packages doivent être installés en
tant que répertoires à côté de l'exécutable Python pour s'assurer
qu'ils soient visibles par Python. Avec le lanceur spécialisé, les
paquets peuvent être installés dans d'autres emplacements car il y a
une possibilité de spécifier le chemin de recherche avant de lancer
l'application.


4.4.2. Embarquer Python
-----------------------

Les applications écrites en code natif nécessitent souvent une
certaine forme de langage de *scripting*, et la distribution Python
intégrée peut être utilisée à cette fin. En général, la majorité de
l'application est dans le code natif, qui soit invoque "python.exe"
soit utilise directement "python3.dll". Dans les deux cas,
l'extraction de la distribution intégrée dans un sous-répertoire de
l'installation de l'application est suffisante pour fournir un
interpréteur Python chargeable.

Comme pour l'utilisation de l'application, les paquets peuvent être
installés sur n'importe quel emplacement, car il est possible de
spécifier des chemins de recherche avant d'initialiser l'interpréteur.
Sinon, il n'y a pas de différences fondamentales entre l'utilisation
de la distribution embarquée et une installation classique.


4.5. Paquets alternatifs
========================

À part la distribution standard CPython, il y a des paquets modifiés
incluant des fonctionnalités additionnelles. La liste qui suit est une
liste de versions populaires et de leurs fonctionnalités principales :

ActivePython
   Installateur avec une compatibilité multiplateforme, de la
   documentation, et *PyWin32*

Anaconda
   Des modules scientifiques populaires (comme *numpy*, *scipy* et
   *pandas*) et le gestionnaire de paquets "conda".

Enthought Deployment Manager
   « L’environnement Python et gestionnaire de paquets de nouvelle
   génération ».

   Auparavant, Enthought fournissait Canopy, mais celui-ci est arrivé
   en fin de vie en 2016.

WinPython
   Distribution spécifique à Windows avec des paquets scientifiques
   pré-compilés et des outils pour construire des paquets.

Notez que ces paquets peuvent ne pas inclure la dernière version de
Python ou d'autres bibliothèques, et ne sont pas maintenus ni
supportés par les *core devs* Python.


4.6. Configurer Python
======================

Pour exécuter Python confortablement à partir d'une invite de
commandes, vous pouvez envisager de modifier certaines variables
d'environnement par défaut dans Windows. Bien que l'installateur offre
une option pour configurer les variables "PATH" et "PATHEXT" pour
vous, ce n'est fiable que pour une seule installation à l'échelle du
système. Si vous utilisez régulièrement plusieurs versions de Python,
pensez à utiliser le Lanceur Python pour Windows.


4.6.1. Digression : définition des variables d'environnement
------------------------------------------------------------

Windows permet de configurer les variables d'environnement de façon
permanente au niveau de l'utilisateur et du système, ou temporairement
dans une invite de commandes.

Pour définir temporairement les variables d'environnement, ouvrez
l'invite de commandes et utilisez la commande **set** :

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

Ces modifications s'appliqueront à toutes les autres commandes
exécutées dans cette console et seront héritées par toutes les
applications démarrées à partir de cette console.

Un nom de variable entre des signes pour cent sera remplacé par sa
valeur, vous permettant d'ajouter votre nouvelle valeur au début ou à
la fin. Ajouter **python.exe** au début de "PATH" est un moyen courant
de s'assurer que la version correcte de Python est lancée.

Pour modifier définitivement les variables d'environnement par défaut,
recherchez « modifier les variables d'environnement », via le menu
démarrer, ou ouvrez « Propriétés Système », Paramètres Système Avancés
et cliquez sur le bouton Variables d'Environnement. Dans cette boîte
de dialogue, vous pouvez ajouter ou modifier des variables
utilisateurs et systèmes. Pour modifier les variables systèmes, vous
avez besoin d'un accès non restreint à votre ordinateur (c'est-à-dire
aux droits d'administrateur).

Note:

  Windows va concaténer les variables utilisateurs *après* les
  variables systèmes, ce qui peut provoquer des résultats inattendus
  lors de la modification de "PATH".La variable "PYTHONPATH" est
  utilisée par toutes les versions de Python, vous ne devez donc pas
  configurer cette variable de façon permanente à moins qu'elle
  n'ajoute que du code compatible avec toutes les versions de Python
  installées.

Voir aussi:

  https://docs.microsoft.com/fr-fr/windows/win32/procthread
  /environment-variables
     Aperçu des variables d'environnement dans Windows

  https://docs.microsoft.com/fr-fr/windows-server/administration
  /windows-commands/set_1
     La commande "set", pour modifier temporairement les variables
     d'environnement

  https://docs.microsoft.com/fr-fr/windows-server/administration
  /windows-commands/setx
     La commande "setx", pour modifier de façon permanente les
     variables d'environnement


4.6.2. Trouver l'exécutable Python
----------------------------------

Modifié dans la version 3.5.

En plus d'utiliser l'entrée du menu Démarrer automatiquement créée
pour l'interpréteur Python, vous souhaiterez peut-être démarrer Python
depuis l'invite de commandes. L'installateur a une option pour
installer cela pour vous.

Sur la première page de l'installateur, une option intitulée « Ajouter
Python au *PATH* » peut être sélectionnée pour que l'installateur
ajoute l'emplacement d'installation dans le "PATH". L'emplacement du
dossier "Scripts\" y est également ajouté. Cela vous permet de taper
**Python** pour exécuter l'interpréteur, et **pip** pour
l'installateur de paquets. Ainsi, vous pouvez également exécuter vos
scripts avec les options de ligne de commande, voir la documentation
Ligne de commande.

Si vous n'activez pas cette option au moment de l'installation, vous
pouvez toujours ré-exécuter l'installateur, sélectionner Modifier et
l'activer. Vous pouvez également modifier manuellement le "PATH" à
l'aide des instructions de Digression : définition des variables
d'environnement. Vous devez définir votre variable d'environnement
"PATH" pour inclure le répertoire de votre installation Python,
délimité par un point-virgule des autres entrées. Une variable
d'exemple pourrait ressembler à ceci (en supposant que les deux
premières entrées existaient déjà) :

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


4.7. Mode UTF-8
===============

Ajouté dans la version 3.7.

Windows utilise toujours les anciens codages pour l'encodage du
système (la page de code ANSI).  Python l'utilise pour le codage par
défaut des fichiers texte (par exemple "locale.getencoding()").

Cela peut poser des problèmes car l'UTF-8 est largement utilisé sur
Internet et sur la plupart des systèmes Unix, y compris le WSL
(*Windows Subsystem for Linux*).

Vous pouvez utiliser le mode UTF-8 pour changer le codage de texte par
défaut en UTF-8. Vous pouvez activer le mode UTF-8 via l'option de
ligne de commande "-X utf8" ou la variable d'environnement
"PYTHONUTF8=1".  Voir "PYTHONUTF8" pour activer le mode UTF-8, et
Digression : définition des variables d'environnement pour savoir
comment modifier les variables d'environnement.

Lorsque le mode UTF-8 est activé, vous pouvez toujours utiliser
l’encodage système (la page de code ANSI) via le codec « *mbcs* ».

Notez que l'ajout de "PYTHONUTF8=1" aux variables d'environnement par
défaut affectera toutes les applications Python 3.7+ sur votre
système. Si vous avez des applications Python 3.7+ qui dépendent de
l'encodage du système existant, il est recommandé de définir la
variable d'environnement temporairement ou d'utiliser l'option de
ligne de commande "-X utf8".

Note:

  même lorsque le mode UTF-8 est désactivé, Python utilise UTF-8 par
  défaut sur Windows pour :

  * Les E/S de la console, y compris les E/S standards (voir **PEP
    528** pour plus de détails).

  * L'*encodage du système de fichiers* (voir **PEP 529** pour plus de
    détails).


4.8. Lanceur Python pour Windows
================================

Ajouté dans la version 3.3.

Le lanceur Python pour Windows est un utilitaire qui facilite la
recherche et l'exécution de différentes versions de Python. Il permet
aux scripts (ou à la ligne de commande) d'indiquer une préférence pour
une version Python spécifique, cherchera et exécutera cette version.

Contrairement à la variable "PATH", le lanceur sélectionne
correctement la version la plus appropriée de Python. Il préfère les
installations par utilisateur sur celles du système, et les trie par
version plutôt que d'utiliser la version la plus récente installée.

Le lanceur a été initialement spécifié dans **PEP 397**.


4.8.1. Pour commencer
---------------------


4.8.1.1. Depuis la ligne de commande
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Modifié dans la version 3.6.

Les installations systèmes de Python 3.3 et ultérieur placent le
lanceur dans votre "PATH". Le lanceur est compatible avec toutes les
versions disponibles de Python, peu importe lesquelles sont
installées. Pour vérifier que le lanceur est disponible, exécutez la
commande suivante dans l'invite de commandes :

   py

Vous devriez voir se lancer la dernière version de Python installée —
il peut être quitté normalement, et tous les arguments de ligne de
commande supplémentaires spécifiés seront envoyés directement à
Python.

Si plusieurs versions de Python sont installées (par exemple, 3.7 et
3.12), vous aurez remarqué que Python 3.12 se lance -- pour lancer
Python 3.7, essayez la commande :

   py -3.7

Si vous voulez que la dernière version de Python 2.x que vous avez
installé, essayez la commande :

   py -2

Si vous voyez l'erreur suivante, le lanceur n'est pas installé :

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

La commande :

   py --list

affiche la ou les versions actuellement installées de Python.

The "-x.y" argument is the short form of the "-V:Company/Tag"
argument, which allows selecting a specific Python runtime, including
those that may have come from somewhere other than python.org. Any
runtime registered by following **PEP 514** will be discoverable. The
"--list" command lists all available runtimes using the "-V:" format.

When using the "-V:" argument, specifying the Company will limit
selection to runtimes from that provider, while specifying only the
Tag will select from all providers. Note that omitting the slash
implies a tag:

   # 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

The short form of the argument ("-3") only ever selects from core
Python releases, and not other distributions. However, the longer form
("-V:3") will select from any.

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. Environnements virtuels
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Ajouté dans la version 3.5.

Si le lanceur est exécuté sans version de Python explicite et qu'un
environnement virtuel (créé avec le module de la bibliothèque standard
"venv" ou l'outil externe "virtualenv") est actif, le lanceur exécute
l'interpréteur de l'environnement virtuel plutôt que l'interpréteur
global. Pour exécuter l'interpréteur global, désactivez
l'environnement virtuel ou spécifiez explicitement la version Python
globale.


4.8.1.3. À partir d'un script
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Créons un script Python de test, créez un fichier appelé "hello.py"
avec le contenu suivant

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

À partir du répertoire dans lequel se trouve "hello.py", exécutez la
commande :

   py hello.py

Vous devriez voir le numéro de version du Python 2.x le plus récemment
installé. Maintenant, essayez de changer la première ligne en :

   #! python3

La commande doit maintenant afficher les dernières informations de
Python 3.x. Comme pour les exemples de ligne de commande ci-dessus,
vous pouvez spécifier un qualificateur de version plus explicite. En
supposant que vous avez installé Python 3.7, essayez de changer la
première ligne en "#! python3.7" et vous devriez trouver les
informations de version 3.7 affichées.

Notez que, contrairement à l'utilisation interactive, un "python" nu
utilisera la dernière version de Python 2.x que vous avez installé.
C'est pour la compatibilité ascendante et pour la compatibilité avec
UNIX, où la commande "python" fait généralement référence à Python 2.


4.8.1.4. À partir d'associations de fichiers
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Le lanceur aurait dû être associé à des fichiers Python (des fichiers
comme ".py", ".pyw", ".pyc") lorsqu'il a été installé. Cela signifie
que lorsque vous double-cliquez sur l'un de ces fichiers à partir de
l'Explorateur Windows, le lanceur sera utilisé, et donc vous pouvez
utiliser les mêmes installations décrites ci-dessus pour que le script
spécifie la version qui doit être utilisée.

L'avantage principal de ceci est qu'un seul lanceur peut prendre en
charge plusieurs versions de Python en même temps en fonction du
contenu de la première ligne.


4.8.2. Lignes Shebang
---------------------

Si la première ligne d'un fichier de script commence par "#!", elle
est connue sous le nom de ligne « *shebang* ». Linux et d'autres
systèmes basés sur Unix ont une prise en charge native de ces lignes
et les *shebangs* sont couramment utilisés sur ces systèmes pour
indiquer comment un script doit être exécuté. Ce lanceur permet aux
mêmes installations d'être utilisés avec des scripts Python sur
Windows et les exemples ci-dessus démontrent leur utilisation.

Pour permettre aux *shebang* dans les scripts Python d'être portables
entre UNIX et Windows, ce lanceur prend en charge un certain nombre de
commandes « virtuelles » pour spécifier l'interpréteur à utiliser. Les
commandes virtuelles prises en charge sont :

* "/usr/bin/env"

* "/usr/bin/python"

* "/usr/local/bin/python"

* "python"

Par exemple, si la première ligne de votre script commence par

   #! /usr/bin/python

Le Python par défaut sera trouvé et utilisé. Comme de nombreux scripts
Python écrits pour fonctionner sur UNIX auront déjà cette ligne, ils
devraient fonctionner avec le lanceur sans modification. Si vous
écrivez un nouveau script sur Windows et que vous pensez qu'il sera
utile sur UNIX, vous devez utiliser l'une des lignes *shebang*
commençant par "/usr".

Les commandes virtuelles ci-dessus peuvent être suffixées avec une
version explicite (soit seulement la version principale, soit la
version principale et mineure). De plus la version 32-bit peut être
demandée en ajoutant **-32** après le numéro de version mineur. Par
exemple "/usr/bin/python3.7-32" demande d’utiliser la version 32-bit
de Python 3.7.

Ajouté dans la version 3.7: Depuis la version 3.7 du lanceur Python,
il est possible de demander une version *64-bit* en utilisant le
suffixe **-64**. De plus il est possible de spécifier une version
majeure et une architecture sans version mineure (par exemple
"/usr/bin/python3-64").

Modifié dans la version 3.11: The "-64" suffix is deprecated, and now
implies "any architecture that is not provably i386/32-bit". To
request a specific environment, use the new "-V:*TAG*" argument with
the complete tag.

La forme "/usr/bin/env" de la ligne shebang possède une autre
propriété spéciale. Avant de rechercher les interpréteurs Python
installés, cette forme recherchera dans "PATH" un exécutable Python
correspondant au nom fourni en premier argument. Cela correspond au
comportement du programme Unix "env", qui effectue une recherche dans
"PATH". Si un exécutable correspondant au premier argument de la
commande "env" ne peut être trouvé, mais que l'argument commence par
"python", il sera traité comme décrit pour les autres commandes
virtuelles. La variable d'environnement "PYLAUNCHER_NO_SEARCH_PATH"
peut être définie (à n'importe quelle valeur) pour ignorer cette
recherche dans "PATH".

Shebang lines that do not match any of these patterns are looked up in
the "[commands]" section of the launcher's .INI file. This may be used
to handle certain commands in a way that makes sense for your system.
The name of the command must be a single argument (no spaces in the
shebang executable), and the value substituted is the full path to the
executable (additional arguments specified in the .INI will be quoted
as part of the filename).

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

Any commands not found in the .INI file are treated as **Windows**
executable paths that are absolute or relative to the directory
containing the script file. This is a convenience for Windows-only
scripts, such as those generated by an installer, since the behavior
is not compatible with Unix-style shells. These paths may be quoted,
and may include multiple arguments, after which the path to the script
and any additional arguments will be appended.


4.8.3. Arguments dans les lignes *shebang*
------------------------------------------

Les lignes *shebang* peuvent également spécifier des options
supplémentaires à passer à l'interpréteur Python. Par exemple, si vous
avez une ligne *shebang* :

   #! /usr/bin/python -v

Alors, Python sera démarré avec l'option "-v"


4.8.4. Personnalisation
-----------------------


4.8.4.1. Personnalisation via des fichiers INI
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Deux fichiers ".ini" seront recherchés par le lanceur - "py.ini" dans
le répertoire de données de l'application de l'utilisateur courant
("%LOCALAPPDATA%" ou "$env:LocalAppData") et "py.ini" dans le même
répertoire que le lanceur. Les mêmes fichiers ".ini" sont utilisés à
la fois pour la version *console* du lanceur (i.e. "py.exe") et pour
la version *windows* (i.e. "pyw.exe").

La personnalisation spécifiée dans le « répertoire de l'application »
aura la priorité sur celle à côté de l'exécutable, de sorte qu'un
utilisateur, qui peut ne pas avoir accès en écriture au fichier ".ini"
à côté du lanceur, peut substituer des commandes dans ce fichier
".ini" global)


4.8.4.2. Personnalisation des versions Python par défaut
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Dans certains cas, un qualificateur de version peut être inclus dans
une commande pour dicter quelle version de Python sera utilisée par la
commande. Un qualificateur de version commence par un numéro de
version majeure et peut éventuellement être suivi d'un point (".") et
d'un spécificateur de version secondaire. De plus il est possible de
préciser si une implémentation 32 ou 64 bit doit être demandée en
ajoutant **-32** ou **-64**.

Par exemple, une ligne *shebang* valant "#!python" n'a pas de
qualificateur de version, tandis que "#!python3" a un qualificateur de
version qui ne spécifie qu'une version majeure.

Si aucun qualificateur de version n'est trouvé dans une commande, la
variable d'environnement "PY_PYTHON" peut être définie pour spécifier
le qualificateur de version par défaut. Si non définie, la valeur par
défaut est "3". La variable peut spécifier n’importe quelle valeur qui
peut être passée dans la ligne de commande telle que "3", "3.7",
"3.7-32" ou "3.7-64". (Notez que l’option **-64** est seulement
disponible avec le lanceur inclus avec Python 3.7 ou plus récent.)

Si aucun qualificateur de version mineure n'est trouvé, la variable
d'environnement "PY_PYTHON{major}" (où "{major}" est le qualificateur
de version principale actuelle tel que déterminé ci-dessus) peut être
définie pour spécifier la version complète. Si aucune option de ce
type n'est trouvée, le lanceur énumérera les versions de Python
installées et utilisera la dernière version mineure trouvée pour la
version principale, qui est probablement la plus récemment installée
dans cette famille.

Sur Windows 64-bits avec les implémentations 32-bits et 64-bits de la
même version Python ("major.minor") installée, la version 64-bit est
toujours préférée. Cela est vrai pour les implémentations 32-bits et
64-bits du lanceur – un lanceur 32-bits préfère exécuter une
installation Python de 64-bits de la version spécifiée si elle est
disponible. Le comportement du lanceur est donc prévisible en sachant
seulement quelles versions sont installées sur le PC et sans tenir
compte de l'ordre dans lequel ils ont été installés (c.-à-d. sans
savoir si une version 32 ou 64-bit de Python et le lanceur
correspondant a été installé en dernier). Comme indiqué ci-dessus, un
suffixe optionnel "-32" ou "-64" peut être utilisé sur un
spécificateur de version pour modifier ce comportement.

Exemples :

* Si aucune option pertinente n'est définie, les commandes "python" et
  "python2" utiliseront la dernière version de Python 2.x installée et
  la commande "python3" utilisera le dernier Python 3.x installé.

* La commande "python3.7" ne consulte aucune option du tout car les
  versions sont entièrement spécifiées.

* Si "PY_PYTHON=3", les commandes "python" et "python3" utiliseront la
  dernière version de Python 3 installée.

* Si "PY_PYTHON=3.7-32", la commande "python" utilisera
  l'implémentation 32-bits de 3.7 alors que la commande "python3"
  utilisera le dernier Python installé (*PY_PYTHON* n'a pas été
  considéré du tout comme une version majeure a été spécifiée.)

* Si "PY_PYTHON=3" et "PY_PYTHON3=3.7", les commandes "python" et
  "python3" utiliseront spécifiquement 3.7

En plus des variables d'environnement, les mêmes paramètres peuvent
être configurés dans le ".INI" utilisé par le lanceur. La section dans
le fichier INI est appelée "[defaults]" et le nom de la clé sera le
même que les variables d'environnement sans le préfixe "PY_" principal
(et notez que les noms de clés dans le fichier **INI** sont
insensibles à la case.) Le contenu d'une variable d'environnement
remplacera les éléments spécifiés dans le fichier *INI*.

Par exemple :

* Le paramètre "PY_PYTHON=3.7" équivaut au fichier **INI** contenant :

   [defaults]
   python=3.7

* Le paramètre "PY_PYTHON=3" et "PY_PYTHON3=3.7" équivaut au fichier
  *INI* contenant :

   [defaults]
   python=3
   python3=3.7


4.8.5. Diagnostics
------------------

Si une variable d'environnement "PYLAUNCHER_DEBUG" est définie (à
n'importe quelle valeur), le lanceur affiche des informations de
diagnostic sur *stderr* (c'est-à-dire sur la console). Bien que ces
informations parviennent à être en même temps nombreuses et concises,
elles devraient vous permettre de voir quelles versions de Python ont
été trouvées, pourquoi une version particulière a été choisie et la
ligne de commande exacte utilisée pour exécuter le Python cible.


4.8.6. Exécution à vide
-----------------------

Si une variable d'environnement "PYLAUNCHER_DRYRUN" est définie (à
n'importe quelle valeur), le lanceur affiche la commande qu'il aurait
exécutée, mais ne lance pas réellement Python. Cela peut être utile
pour les outils qui souhaitent utiliser le lanceur pour détecter puis
lancer Python directement. Notez que la commande écrite sur la sortie
standard est toujours codée en UTF-8 et peut ne pas s'afficher
correctement dans la console.


4.8.7. Installation à la demande
--------------------------------

Si une variable d'environnement "PYLAUNCHER_ALLOW_INSTALL" est définie
(à n'importe quelle valeur) et que la version de Python demandée n'est
pas installée mais est disponible sur le Microsoft Store, le lanceur
tente de l'installer. Cela peut nécessiter une intervention de
l'utilisateur et il faudra peut-être exécuter à nouveau la commande.

Une variable supplémentaire "PYLAUNCHER_ALWAYS_INSTALL" oblige le
lanceur à toujours essayer d'installer Python, même s'il est détecté.
Ceci est principalement destiné aux tests (et doit être utilisé avec
"PYLAUNCHER_DRYRUN").


4.8.8. Codes de retour
----------------------

Les codes de retour suivants peuvent être renvoyés par le lanceur
Python. Malheureusement, il n'y a aucun moyen de les distinguer du
code de sortie de Python lui-même.

Les noms des codes sont tels qu'utilisés dans les sources et ne sont
donnés qu'à titre de référence. Il n'y a aucun moyen d'y accéder ou de
les résoudre en dehors de la lecture de cette page. Les entrées sont
classées par ordre alphabétique des noms.

+---------------------+---------+-------------------------------------------------+
| Nom                 | Valeur  | Description                                     |
|=====================|=========|=================================================|
| RC_BAD_VENV_CFG     | 107     | "pyvenv.cfg" a été trouvé mais est corrompu.    |
+---------------------+---------+-------------------------------------------------+
| RC_CREATE_PROCESS   | 101     | Échec du lancement de Python.                   |
+---------------------+---------+-------------------------------------------------+
| RC_INSTALLING       | 111     | Une installation a commencé, mais la commande   |
|                     |         | doit être relancée après qu'elle a terminé.     |
+---------------------+---------+-------------------------------------------------+
| RC_INTERNAL_ERROR   | 109     | Erreur non prévue. Merci de remonter un bogue.  |
+---------------------+---------+-------------------------------------------------+
| RC_NO_COMMANDLINE   | 108     | Le système d'exploitation n'a pas fourni de     |
|                     |         | ligne de commande.                              |
+---------------------+---------+-------------------------------------------------+
| RC_NO_PYTHON        | 103     | Impossible de trouver la version demandée.      |
+---------------------+---------+-------------------------------------------------+
| RC_NO_VENV_CFG      | 106     | "pyvenv.cfg" est requis mais n'a pas été        |
|                     |         | trouvé.                                         |
+---------------------+---------+-------------------------------------------------+


4.9. Recherche de modules
=========================

Ces notes complètent la description de The initialization of the
sys.path module search path avec des notes Windows détaillées.

Lorsque aucun fichier "._pth" n'est trouvé, voilà comment "sys.path"
est construit sur Windows :

* Une entrée vide est ajoutée au début, qui correspond au répertoire
  courant.

* Si la variable d'environnement "PYTHONPATH" existe, comme décrit
  dans Variables d'environnement, ses entrées sont ajoutées ensuite.
  Notez que sur Windows, les chemins d'accès de cette variable doivent
  être séparés par des points-virgules, pour les distinguer des deux
  points utilisés dans les identificateurs de lecteur ("C:\" etc.).

* Des "chemins d'accès d'application" supplémentaires peuvent être
  ajoutés dans le registre en tant que sous-clés de
  "\SOFTWARE\Python\PythonCore{version}\PythonPath" sous les ruches
  "HKEY_CURRENT_USER" et "HKEY_LOCAL_MACHINE". Les sous-clés qui ont
  des chaînes de chemin délimitées par des points-virgules comme
  valeur par défaut entraînent l'ajout de chaque chemin d'accès à
  "sys.path". (Notez que tous les installateurs connus utilisent
  seulement HKLM, donc HKCU est généralement vide.)

* Si la variable d'environnement "PYTHONHOME" est définie, elle est
  supposée comme "Python Home". Sinon, le chemin de l'exécutable
  principal de Python est utilisé pour chercher un "fichier de repère"
  (soit "Lib\os.py" ou "pythonXY.zip") pour déduire le "Python Home".
  Si un "Python Home" est trouvé, les sous-répertoires correspondants
  ajoutés à "sys.path" ("Lib", "plat-win", etc) sont basés sur ce
  dossier. Sinon, le chemin d'accès Python principal est construit à
  partir du PythonPath stocké dans le registre.

* Si le "Python Home" ne peut pas être trouvé, "PYTHONPATH" n'est pas
  spécifié dans l'environnement et aucune entrée de registre ne peut
  être trouvée, un chemin par défaut avec des entrées relatives est
  utilisé (par exemple ".\Lib" ; ".\plat-win", etc.).

Si un fichier "pyvenv.cfg" se trouve à côté de l'exécutable principal
ou dans le répertoire un niveau au-dessus de l'exécutable, les
variantes suivantes s'appliquent :

* Si "home" est un chemin absolu et "PYTHONHOME" n'est pas défini, ce
  chemin d'accès est utilisé au lieu du chemin d'accès à l'exécutable
  principal lors de la déduction de l'emplacement du "home".

Le résultat final de tout ceci est :

* Lors de l'exécution de "python.exe", ou tout autre ".exe" dans le
  répertoire principal de Python (soit une version installée, soit
  directement à partir du répertoire PCbuild), le chemin principal est
  déduit et les chemins d'accès principaux dans le Registre sont
  ignorés. D'autres "chemins d'application" dans le registre sont
  toujours lus.

* Lorsque Python est hébergé dans un autre fichier ".exe" (répertoire
  différent, intégré via COM, etc.), le "Python Home" ne sera pas
  déduit, de sorte que le chemin d'accès principal du registre est
  utilisé. D'autres "chemins d'application" dans le registre sont
  toujours lus.

* Si Python ne peut pas trouver son "home" et il n'y a pas de valeur
  de registre (*.exe* figé, une installation très étrange) vous
  obtenez un chemin d'accès avec certains chemins par défaut, mais
  relatif.

Pour ceux qui veulent intégrer Python dans leur application ou leur
distribution, les conseils suivants empêcheront les conflits avec
d'autres installations :

* Incluez un fichier "._pth" à côté de votre exécutable contenant les
  répertoires à inclure. Ceci ignorera les chemins répertoriés dans le
  registre et les variables d'environnement, et ignorera également
  "site" à moins que "import site" soit listé.

* Si vous chargez "python3.dll" ou "python37.dll" dans votre propre
  exécutable, appelez explicitement "Py_SetPath()" ou (au moins)
  "Py_SetProgramName()" avant "Py_Initialize()".

* Effacer et/ou écraser "PYTHONPATH" et configurez "PYTHONHOME" avant
  de lancer le "python.exe" de votre application.

* Si vous ne pouvez pas utiliser les suggestions précédentes (par
  exemple, vous êtes une distribution qui permet aux gens d'exécuter
  "python.exe" directement), assurez-vous que le point de repère
  "Lib\os.py" existe dans votre répertoire d'installation. (Notez
  qu'il ne sera pas détecté à l'intérieur d'un fichier ZIP, mais un
  fichier ZIP correctement nommé sera détecté à la place.)

Ceux-ci garantiront que les fichiers d'une installation à l'échelle du
système n'auront pas la priorité sur la copie de la bibliothèque
standard livrée avec votre application. Sinon, vos utilisateurs
pourraient rencontrer des problèmes en utilisant votre application.
Notez que la première suggestion est la meilleure, car les autres
peuvent encore être sensibles aux chemins non-standard dans le
registre et le *site-packages* utilisateur.

Modifié dans la version 3.6: Add "._pth" file support and removes
"applocal" option from "pyvenv.cfg".

Modifié dans la version 3.6: Add "python*XX*.zip" as a potential
landmark when directly adjacent to the executable.

Obsolète depuis la version 3.6: Modules specified in the registry
under "Modules" (not "PythonPath") may be imported by
"importlib.machinery.WindowsRegistryFinder". This finder is enabled on
Windows in 3.6.0 and earlier, but may need to be explicitly added to
"sys.meta_path" in the future.


4.10. Modules supplémentaires
=============================

Même si Python a l'ambition d'être portable parmi toutes les plates-
formes, il existe des fonctionnalités propres à Windows. Certains
modules, à la fois dans la bibliothèque standard et externe, et des
exemples existent pour utiliser ces fonctionnalités.

Les modules standard de Windows sont documentés dans Services
spécifiques à MS Windows.


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)

* Appels à l'API Win32

* Registre

* Journal d'événement

* Microsoft Foundation Classes (MFC) interfaces utilisateur

PythonWin est un exemple d'application MFC livrée avec PyWin32. Il
s'agit d'un IDE embarqué avec débogueur intégré.

Voir aussi:

  Win32 How Do I...?
     par Tim Golden

  Python and COM
     par David et Paul Boddie


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

cx_Freeze wraps Python scripts into executable Windows programs
("***.exe" files).  When you have done this, you can distribute your
application without requiring your users to install Python.


4.11. Compiler Python sous Windows
==================================

Si vous voulez compiler CPython vous-même, la première chose à faire
est obtenir la source. Vous pouvez télécharger soit la source de la
dernière version ou tout simplement prendre un checkout.

L'arborescence source contient une solution de compilation et des
fichiers projet pour Microsoft Visual Studio, qui est le compilateur
utilisé pour générer les versions officielles de Python. Ces fichiers
se trouvent dans le répertoire "PCbuild".

Consultez "PC/readme.txt" pour des informations générales sur le
processus de construction.

Pour les modules d'extension, consultez Construire des extensions C et
C++ sur Windows.


4.12. Autres plateformes
========================

Avec le développement continu de Python, certaines plateformes qui
étaient auparavant prises en charge ne sont plus prises en charge (en
raison du manque d'utilisateurs ou de développeurs). Voir **PEP 11**
pour plus de détails sur toutes les plateformes non prises en charge.

* Windows CE n’est plus pris en charge
  https://github.com/python/cpython/issues/71542 depuis Python 3 (s’il
  l’a jamais été).

* Le programme d’installation de Cygwin propose d’installer également
  l’interpréteur Python.

Voir Python pour Windows pour des instructions détaillées sur les
plateformes avec installateurs pré-compilés.
