4. Uso de Python en Windows
***************************

Este documento pretende dar una visión general del comportamiento
específico de Windows que se debería conocer al usar Python en
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.

Como se especifica en **PEP 11**, una versión de Python solo admite
una plataforma Windows, mientras que Microsoft considera la plataforma
con soporte extendido. Esto significa que Python 3.12 es compatible
con Windows 8.1 y versiones posteriores. Si necesita compatibilidad
con Windows 7, instale Python 3.8.

Hay varios instaladores diferentes disponibles para Windows, cada uno
con determinados beneficios y desventajas.

El instalador completo contiene todos los componentes y es la mejor
opción para desarrolladores que usan Python para cualquier clase de
proyecto.

El paquete Microsoft Store es una instalación simple de Python que es
adecuada para ejecutar scripts y paquetes y usar IDLE u otros entornos
de desarrollo. Requiere Windows 10 o superior, pero se puede instalar
de forma segura sin corromper otros programas. También proporciona
muchos comandos convenientes para iniciar Python y sus herramientas.

El paquete de nuget.org son instalaciones ligeras destinadas a
sistemas de integración continua. Puede ser usada para crear paquetes
de Python o para ejecutar scripts, pero no es actualizable y no posee
herramientas de interfaz de usuario.

El paquete incrustable es un paquete de Python mínimo que es adecuado
para incrustar en una aplicación más grande.


4.1. El instalador completo
===========================


4.1.1. Pasos para la instalación
--------------------------------

Cuatro instaladores de Python 3.12 están disponibles para descargar -
dos por cada una de las versiones de 32-bit y 64-bit del intérprete.
El *instalador web* es una pequeña descarga inicial que
automáticamente descargará los componentes requeridos cuando sea
necesario. El *instalador fuera de línea* incluye los componentes
necesarios para una instalación por defecto y solo requiere de una
conexión a internet para características opcionales. Consultar
Instalación sin descargas para conocer otras formas de evitar
descargas durante la instalación.

Luego de iniciar el instalador, se puede seleccionar una de estas dos
opciones:

[imagen]

Si se selecciona "Install Now":

* *No* necesitarás ser administrador (a menos que se requiera una
  actualización de sistema para C Runtime Library o se necesite
  instalar el Lanzador de Python para Windows para todos los usuarios)

* Python será instalado en su directorio de usuario

* El Lanzador de Python para Windows será instalado de acuerdo con la
  opción en la parte inferior de la primera página

* La biblioteca estándar, conjunto de pruebas, lanzador y pip serán
  instalados

* Si se selecciona, el directorio de instalación se agregará a su
  "PATH"

* Los accesos directos solo serán visibles para al usuario actual

Si selecciona "Customize installation" podrá elegir qué funciones
instalar, el destino de la instalación y otras opciones o acciones
posinstalación. Para instalar símbolos de depuración o binarios,
necesitará usar esta opción.

Para realizar una instalación para todos los usuarios, deberá
seleccionar "Customize installation". En este caso:

* Es posible que deba proporcionar credenciales administrativas o
  aprobación

* Python será instalado en el directorio Program Files

* El Lanzador de Python para Windows será instalado en el directorio
  Windows

* Se pueden seleccionar características opcionales durante la
  instalación

* La biblioteca estándar puede ser precompilada a bytecode

* Si se selecciona, el directorio de instalación será agregado al
  "PATH" del sistema

* Los accesos directos están disponibles para todos los usuarios


4.1.2. Quitar el límite de MAX_PATH
-----------------------------------

Windows históricamente ha limitado la longitud de las rutas a 260
caracteres. Esto significaba que rutas de mayor longitud no
resolverían y se producirían errores.

En las últimas versiones de Windows, esta limitación se puede ampliar
a aproximadamente 32.000 caracteres. Su administrador deberá activar
la política de grupo "Habilitar rutas largas de Win32" o establecer
"LongPathsEnabled" en "1" en la clave de registro
"HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\FileSystem".

Esto permite que la función "open()", el módulo "os" y la mayoría de
las demás funciones de ruta acepten y retornen rutas de más de 260
caracteres.

Luego de cambiar la opción anterior, no es necesaria ninguna otra
configuración.

Distinto en la versión 3.6: Se habilitó el soporte para rutas largas
en Python.


4.1.3. Instalación sin interfaz de usuario
------------------------------------------

Todas las opciones disponibles desde la interfaz de usuario del
instalador también pueden especificarse desde la línea de comandos, lo
cual permite que instaladores mediante scripts repliquen una
instalación en muchas máquinas sin la interacción del usuario. Estas
opciones también pueden ser configuradas sin anular la interfaz de
usuario con el fin de cambiar alguno de los valores predeterminados.

Las siguientes opciones (encontradas al ejecutar el instalador con
"/?") pueden ser pasadas al instalador

+-----------------------+----------------------------------------------------------+
| Nombre                | Descripción                                              |
|=======================|==========================================================|
| /passive              | para mostrar el progreso sin requerir interacción del    |
|                       | usuario                                                  |
+-----------------------+----------------------------------------------------------+
| /quiet                | para instalar/desinstalar sin mostrar ninguna interfaz   |
+-----------------------+----------------------------------------------------------+
| /simple               | para prevenir la personalización del usuario             |
+-----------------------+----------------------------------------------------------+
| /uninstall            | para eliminar Python (sin confirmación)                  |
+-----------------------+----------------------------------------------------------+
| /layout [directorio]  | para pre-descargar todos los componentes                 |
+-----------------------+----------------------------------------------------------+
| /log [nombre de       | para especificar la ubicación de los archivos de         |
| archivo]              | registro                                                 |
+-----------------------+----------------------------------------------------------+

Todas las otras opciones se especifican con la forma "nombre=valor",
siendo el valor usualmente "0" para deshabilitar una funcionalidad,
"1" para habilitar una funcionalidad, o una ruta. La lista completa de
opciones disponibles se muestra a continuación.

+-----------------------------+----------------------------------------+----------------------------+
| Nombre                      | Descripción                            | Predeterminado             |
|=============================|========================================|============================|
| InstallAllUsers             | Realizar una instalación en todo el    | 0                          |
|                             | sistema.                               |                            |
+-----------------------------+----------------------------------------+----------------------------+
| TargetDir                   | El directorio de instalación           | Seleccionado de acuerdo a  |
|                             |                                        | InstallAllUsers            |
+-----------------------------+----------------------------------------+----------------------------+
| DefaultAllUsersTargetDir    | El directorio predeterminado de        | "%ProgramFiles%\Python     |
|                             | instalación cuando se instala para     | X.Y" o "%ProgramFiles(x86  |
|                             | todos los usuarios                     | )%\Python X.Y"             |
+-----------------------------+----------------------------------------+----------------------------+
| DefaultJustForMeTargetDir   | El directorio predeterminado de        | "%LocalAppData%\Programs\  |
|                             | instalación para instalaciones del     | Python\PythonXY" or "%Loc  |
|                             | usuario actual solamente               | alAppData%\Programs\Pytho  |
|                             |                                        | n\PythonXY-32" or "%Local  |
|                             |                                        | AppData%\Programs\Python\  |
|                             |                                        | PythonXY-64"               |
+-----------------------------+----------------------------------------+----------------------------+
| DefaultCustomTargetDir      | El valor predeterminado de directorio  | (vacío)                    |
|                             | de instalación personalizado que se    |                            |
|                             | muestra en la interfaz de usuario      |                            |
+-----------------------------+----------------------------------------+----------------------------+
| AssociateFiles              | Crear asociaciones de archivos si el   | 1                          |
|                             | lanzador también es instalado.         |                            |
+-----------------------------+----------------------------------------+----------------------------+
| CompileAll                  | Compilar todos los archivos ".py" a    | 0                          |
|                             | ".pyc".                                |                            |
+-----------------------------+----------------------------------------+----------------------------+
| PrependPath                 | Anteponga los directorios de           | 0                          |
|                             | instalación y scripts a "PATH" y       |                            |
|                             | agregue ".PY" a "PATHEXT"              |                            |
+-----------------------------+----------------------------------------+----------------------------+
| AppendPath                  | Agregue directorios de instalación y   | 0                          |
|                             | scripts a "PATH" y agregue ".PY" a     |                            |
|                             | "PATHEXT"                              |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Shortcuts                   | Crear accesos directos para el         | 1                          |
|                             | intérprete, documentación e IDLE si    |                            |
|                             | está instalado.                        |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Include_doc                 | Instalar el manual de Python           | 1                          |
+-----------------------------+----------------------------------------+----------------------------+
| Include_debug               | Instalar los binarios de depuración    | 0                          |
+-----------------------------+----------------------------------------+----------------------------+
| Include_dev                 | Instale encabezados y bibliotecas de   | 1                          |
|                             | desarrollador. Omitir esto puede       |                            |
|                             | conducir a una instalación             |                            |
|                             | inutilizable.                          |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Include_exe                 | Instale "python.exe" y archivos        | 1                          |
|                             | relacionados. Omitir esto puede        |                            |
|                             | conducir a una instalación             |                            |
|                             | inutilizable.                          |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Include_launcher            | Instalar Lanzador de Python para       | 1                          |
|                             | Windows.                               |                            |
+-----------------------------+----------------------------------------+----------------------------+
| InstallLauncherAllUsers     | Instala el lanzador para todos los     | 1                          |
|                             | usuarios. También requiere que         |                            |
|                             | "Include_launcher" se establezca en 1  |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Include_lib                 | Instale la biblioteca estándar y los   | 1                          |
|                             | módulos de extensión. Omitir esto      |                            |
|                             | puede conducir a una instalación       |                            |
|                             | inutilizable.                          |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Include_pip                 | Instalar los paquetes pip y setuptools | 1                          |
+-----------------------------+----------------------------------------+----------------------------+
| Include_symbols             | Instalar los símbolos de depuración    | 0                          |
|                             | ("*.pdb")                              |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Include_tcltk               | Instalar IDLE y soporte para Tcl/Tk    | 1                          |
+-----------------------------+----------------------------------------+----------------------------+
| Include_test                | Instalar el conjunto de pruebas de la  | 1                          |
|                             | biblioteca estándar                    |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Include_tools               | Instalar scripts de utilidades         | 1                          |
+-----------------------------+----------------------------------------+----------------------------+
| LauncherOnly                | Instalar solo el lanzador. Esto        | 0                          |
|                             | anulará la mayoría de las otras        |                            |
|                             | opciones.                              |                            |
+-----------------------------+----------------------------------------+----------------------------+
| SimpleInstall               | Deshabilitar muchas de las partes de   | 0                          |
|                             | la interfaz de usuario                 |                            |
+-----------------------------+----------------------------------------+----------------------------+
| SimpleInstallDescription    | Un mensaje personalizado para mostrar  | (vacío)                    |
|                             | cuando se use la versión simplificada  |                            |
|                             | de la interfaz de usuario de           |                            |
|                             | instalación.                           |                            |
+-----------------------------+----------------------------------------+----------------------------+

Por ejemplo, para realizar de forma silenciosa una instalación
predeterminada de Python para todo el sistema, se puede usar el
siguiente comando (desde un símbolo del sistema con privilegios
elevados):

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

Para permitir que los usuarios instalen fácilmente una copia personal
de Python sin el conjunto de pruebas, se puede proporcionar un acceso
directo con el siguiente comando. Esto mostrará una página inicial
simplificada y no permitirá la personalización:

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

(Tener en cuenta que al omitir el lanzador también se omiten las
asociaciones de archivos y solo es recomendable hacerlo para
instalaciones por usuario cuando ya hay una instalación en todo el
sistema que incluye el lanzador.)

Las opciones enumeradas anteriormente también se pueden proporcionar
en un archivo de nombre "unattend.xml" junto al ejecutable. Este
archivo especifica una lista de opciones y valores. Cuando un valor se
proporciona como un atributo, se convertirá a número si es posible.
Los valores proporcionados como elementos de texto siempre se dejan
como cadenas. Este archivo de ejemplo configura las mismas opciones
que el ejemplo anterior:

   <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. Instalación sin descargas
--------------------------------

Como algunas características de Python no se incluyen con la descarga
inicial del instalador, la selección de estas características podría
requerir de una conexión a internet. Para evitar esta necesidad, todos
los posibles componentes pueden ser descargados a pedido para crear
una estructura que no necesitará una conexión a internet,
independientemente de las características que se seleccionen. Tener en
cuenta que esta descarga puede ser más grande de lo necesario, pero si
se va a realizar un gran número de instalaciones es muy útil tener una
copia en la caché local.

Ejecute el siguiente comando desde el símbolo del sistema para
descargar todos los archivos necesarios posibles. Recuerde sustituir
"python-3.9.0.exe" por el nombre real de su instalador y crear diseños
en sus propios directorios para evitar colisiones entre archivos con
el mismo nombre.

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

También se puede especificar la opción "/quiet" para no mostrar el
progreso.


4.1.5. Modificar una instalación
--------------------------------

Una vez que Python ha sido instalado, se puede agregar o quitar
funciones a través de la herramienta Programas y características que
es parte de Windows. Seleccionar la entrada Python y elegir
"Desinstalar/Cambiar" para abrir el instalador en modo mantenimiento.

"Cambiar" permite agregar o eliminar características modificando las
casillas de verificación - aquellas casillas que no se cambien no
agregarán ni quitarán nada. Algunas opciones no pueden cambiarse de
esta forma, como el directorio de instalación; para modificarlas es
necesario eliminar y reinstalar Python completamente.

"Reparar" verificará todos los archivos que deben instalarse con la
configuración actual y reemplazará los que se hayan eliminado o
modificado.

"Desinstalar" eliminará Python completamente, a excepción del Lanzador
de Python para Windows, el cual posee su propia entrada en Programas y
características.


4.2. El paquete Microsoft Store
===============================

Added in version 3.7.2.

El paquete de Microsoft Store es un intérprete de Python fácilmente
instalable destinado principalmente al uso interactivo, por ejemplo,
por estudiantes.

Para instalar el paquete, asegúrate de tener las últimas
actualizaciones de Windows 10 y busca "Python 3.12" en Microsoft
Store. Comprueba que la aplicación que seleccionas es una publicación
de la Python Software Foundation y procede a instalarla.

Advertencia:

  Python siempre estará disponible de forma gratuita en Microsoft
  Store. Si se te solicita que pagues por él, entonces el paquete
  seleccionado no es el correcto.

Luego de la instalación, Python puede iniciarse a través del menú de
Inicio. Como alternativa, también estará disponible desde cualquier
símbolo del sistema o sesión de PowerShell al escribir "python".
Además, pip e IDLE pueden ser usados escribiendo "pip" o "idle". IDLE
también puede ser encontrado en el Inicio.

Los tres comandos también están disponibles con el número de versión
como sufijo, por ejemplo, como "python3.exe" y "python3.x.exe" así
como también "python.exe" (donde "3.x" es la versión específica que se
quiera iniciar, como 3.12). Abrir "Administrar alias de ejecución de
aplicaciones" a través del menú de Inicio para seleccionar cuál
versión de Python se asocia con cada comando. Se recomienda asegurarse
de que "pip" e "idle" sean consistentes con la versión de "python" que
esté seleccionada.

Los entornos virtuales se pueden crear con "python -m venv" y se
activan y usan normalmente.

Si ha instalado otra versión de Python que se haya agregado a la
variable "PATH", estará disponible como "python.exe" en lugar de la de
Microsoft Store. Para acceder a la nueva instalación, use
"python3.exe" o "python3.x.exe".

El lanzador "py.exe" detectará esta instalación de Python, pero
priorizará instalaciones realizadas con el instalador tradicional.

Para eliminar Python, abra Configuración y utilice Aplicaciones y
características, o encuentre Python en el Inicio y mediante click
derecho seleccione Desinstalar. La desinstalación eliminará todos los
paquetes instalados directamente en esta instalación de Python, pero
no eliminará ningún entorno virtual


4.2.1. Problemas conocidos
--------------------------


4.2.1.1. Redirección de datos locales, registro y rutas temporales
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Debido a las restricciones de las aplicaciones de Microsoft Store, es
posible que los scripts de Python no tengan acceso de escritura
completo a ubicaciones compartidas, como "TEMP" y el registro. En su
lugar, escribirá en una copia privada. Si sus scripts deben modificar
las ubicaciones compartidas, deberá instalar el instalador completo.

En tiempo de ejecución, Python usará una copia privada de carpetas
conocidas de Windows y el registro. Por ejemplo, si la variable de
entorno "%APPDATA%" es "c:\Users\<user>\AppData\", al escribir en
"C:\Users\<user>\AppData\Local" se escribirá en "C:\Users\<user>\AppD
ata\Local\Packages\PythonSoftwareFoundation.Python.3.8_qbz5n2kfra8p0\
LocalCache\Local\".

Al leer archivos, Windows retornará el archivo de la carpeta privada,
o si no existe, el directorio real de Windows. Por ejemplo, leer
"C:\Windows\System32" retorna el contenido de "C:\Windows\System32"
más el contenido de "C:\Program
Files\WindowsApps\package_name\VFS\SystemX86".

Puede encontrar la ruta real de cualquier archivo existente usando
"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'

Al escribir en el Registro de Windows, existen los siguientes
comportamientos:

* Se permite la lectura desde "HKLM\\Software" y los resultados se
  fusionan con el archivo "registry.dat" en el paquete.

* No se permite escribir en "HKLM\\Software" si existe la clave/valor
  correspondiente, es decir, modificar las claves existentes.

* Se permite escribir en "HKLM\\Software" siempre que no exista una
  clave/valor correspondiente en el paquete y el usuario tenga los
  permisos de acceso correctos.

Para obtener más detalles sobre la base técnica de estas limitaciones,
consulte la documentación de Microsoft sobre aplicaciones empaquetadas
de plena confianza, actualmente disponible en docs.microsoft.com/en-
us/windows/msix/desktop/desktop-to-uwp-behind-the-scenes


4.3. El paquete de nuget.org
============================

Added in version 3.5.2.

El paquete de nuget.org es un entorno Python de tamaño reducido
destinado a usarse en sistemas de integración continua y compilación
que no posean una instalación de Python a nivel de sistema. Si bien
nuget es "el administrador de paquetes para .NET", también funciona
perfectamente para paquetes que contienen herramientas de tiempo de
compilación.

Visite nuget.org para obtener la información más actualizada sobre
cómo usar nuget. Lo que sigue es un resumen que es suficiente para
desarrolladores Python.

La herramienta de línea de comandos "nuget.exe" puede ser descargada
directamente desde "https://aka.ms/nugetclidl", por ejemplo usando
curl o PowerShell. Con esta herramienta, la última versión de Python
para máquinas de 64 o 32 bit se instala con:

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

Para seleccionar una versión en particular, agregue un "-Version
3.x.y". El directorio de salida se puede cambiar de "." y el paquete
se instalará en un subdirectorio. De forma predeterminada, el
subdirectorio tiene el mismo nombre que el paquete y, sin la opción
"-ExcludeVersion", este nombre incluirá la versión específica
instalada. Dentro del subdirectorio hay un directorio "tools" que
contiene la instalación de 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 general, los paquetes nuget no son actualizables, y versiones más
nuevas deben ser instaladas en paralelo y referenciadas usando la ruta
completa. Otra opción es borrar el directorio del paquete de forma
manual e instalarlo de nuevo. Muchos sistemas de CI harán esto
automáticamente si no mantienen archivos entre compilaciones.

Junto al directorio "tools" está el directorio "build\native". Este
contiene un archivo de propiedades MSBuild "Python.props" que puede
ser usado en un proyecto C++ para referenciar la instalación de
Python. Al incluir las configuraciones, automáticamente se usarán los
encabezados y se importarán las bibliotecas en la compilación.

Las páginas de información del paquete en nuget.org son
www.nuget.org/packages/python para la versión de 64 bit y
www.nuget.org/packages/pythonx86 para la versión de 32 bit.


4.4. El paquete incrustable
===========================

Added in version 3.5.

La distribución incrustable consiste en un archivo ZIP que contiene un
mínimo entorno de Python. Está destinado a ser usado como parte de
otra aplicación, en lugar de ser accedido directamente por los
usuarios finales.

Al ser extraída, la distribución incrustable está (casi) completamente
aislada del sistema del usuario, incluyendo variables de entorno,
configuraciones del registro del sistema y paquetes instalados. La
biblioteca estándar se incluye como archivos ".pyc" precompilados y
optimizados dentro de un ZIP, y "python3.dll", "python37.dll",
"python.exe" y "pythonw.exe" están todos proporcionados. Tcl/tk
(incluidas sus dependencias, como Idle), pip y la documentación de
Python no están incluidos.

Nota:

  La distribución integrada no incluye la Microsoft C Runtime y es
  responsabilidad del instalador de la aplicación proporcionarlo. Es
  posible que la biblioteca runtime ya se haya instalado en el sistema
  de un usuario previamente o automáticamente a través de Windows
  Update, y se puede detectar al encontrar "ucrtbase.dll" en el
  directorio del sistema.

Los paquetes de terceros deben ser instalados por el instalador de la
aplicación junto a la distribución incrustada. El uso de pip para
administrar dependencias como en una instalación de Python regular no
es soportado por esta distribución, aunque con cierto cuidado es
posible incluir y usar pip para automatizar las actualizaciones. En
general, los paquetes de terceros deben ser tratados como parte de la
aplicación ("vendoring") para que el desarrollador pueda asegurar la
compatibilidad con las nuevas versiones antes de proporcionar
actualizaciones a los usuarios.

Los dos casos de uso recomendados para esta distribución se describen
a continuación.


4.4.1. Aplicación Python
------------------------

Una aplicación escrita en Python no necesariamente requiere que los
usuarios sean conscientes de ese hecho. La distribución incrustada
puede ser usada en este caso para incluir una versión privada de
Python en un paquete de instalación. Dependiendo de lo transparente
que deba ser (o por el contrario, de lo profesional que deba parecer),
hay dos opciones.

El uso de un ejecutable especializado como lanzador requiere algo de
código, pero proporciona la experiencia más transparente para los
usuarios. Con un lanzador personalizado, no hay indicadores obvios de
que el programa se ejecuta en Python: los íconos pueden ser
personalizados, se puede especificar información de la compañía y de
la versión, y las asociaciones de archivos se comportan correctamente.
En la mayoría de los casos, un lanzador personalizado debería
simplemente poder invocar "Py_Main" utilizando una línea de comandos
codificada.

El enfoque más simple es proporcionar un archivo por lotes o un acceso
directo generado que directamente invoque "python.exe" o "pythonw.exe"
con los argumentos de línea de comandos requeridos. En este caso, la
aplicación aparecerá como Python y no con su nombre real, y los
usuarios podrían tener problemas para distinguirla de otros procesos
Python en ejecución o asociaciones de archivos.

Con este último enfoque, los paquetes deben instalarse como
directorios junto al ejecutable de Python para asegurar su
disponibilidad en la ruta. Con el lanzador especializado, los paquetes
pueden encontrarse en otras ubicaciones ya que hay oportunidad de
especificar la ruta de búsqueda antes de iniciar la aplicación.


4.4.2. Incrustar Python
-----------------------

Las aplicaciones escritas en código nativo frecuentemente requieren
algún tipo de lenguaje de scripting, y la distribución de Python
incrustada puede ser utilizada con ese propósito. En general, la
mayoría de la aplicación utiliza código nativo, y alguna parte
invocará "python.exe" o usará "python3.dll" directamente. Para
cualquiera de estos casos, la extracción de la distribución
incrustable a un subdirectorio de la instalación de la aplicación es
suficiente para proporcionar un intérprete de Python invocable.

Al igual que con el uso de la aplicación, los paquetes pueden ser
instalados en cualquier ubicación, ya que existe la posibilidad de
especificar rutas de búsqueda antes de inicializar el intérprete. Más
allá de esto, no existen diferencias fundamentales entre el uso de la
distribución incrustada y una instalación normal.


4.5. Distribuciones alternativas
================================

Además de la distribución estándar de CPython, hay paquetes
modificados que incluyen funcionalidad adicional. La siguiente es una
lista de versiones populares y sus características clave:

ActivePython
   Instalador compatible con múltiples plataformas, documentación,
   PyWin32

Anaconda
   Módulos científicos populares (como numpy, scipy y pandas) y el
   gestor de paquetes "conda".

Enthought Deployment Manager
   "El administrador de paquetes y entorno de Python de próxima
   generación".

   Anteriormente, Enthought proporcionaba Canopy, pero llegó al final
   de su vida en2016.

WinPython
   Distribución específica para Windows con paquetes científicos
   precompilados y herramientas para construir paquetes.

Tenga en cuenta que estos paquetes pueden no incluir la última versión
de Python u otras bibliotecas, y no son mantenidos ni respaldados por
el equipo central de Python.


4.6. Configuración de Python
============================

Para ejecutar Python convenientemente desde el símbolo del sistema,
puede considerar cambiar algunas variables de entorno predeterminadas
de Windows. Si bien el instalador proporciona una opción para
configurar las variables PATH y PATHEXT, esto solo es confiable para
una única instalación en todo el sistema. Si utiliza varias versiones
de Python con regularidad, considere usar el Lanzador de Python para
Windows.


4.6.1. Excurso: configurar variables de entorno
-----------------------------------------------

Windows permite configurar las variables de entorno de forma
permanente a nivel de usuario y a nivel de sistema, o temporalmente en
el símbolo del sistema.

Para configurar una variable de entorno temporal, abra el símbolo del
sistema y utilice el comando **set**:

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

Estos cambios serán aplicados a cualquier comando que de aquí en más
se ejecute en esa consola, y serán heredados por cualquier aplicación
iniciada desde esa consola.

Si se incluye el nombre de la variable entre signos de porcentaje,
esta se expande al valor existente, permitiendo agregar un nuevo valor
tanto al principio como al final. Modificar "PATH" agregando el
directorio que contiene **python.exe** al comienzo es una forma común
de asegurar que se ejecuta la versión correcta de Python.

Para modificar permanentemente las variables de entorno
predeterminadas, haga click en Inicio y busque 'editar las variables
de entorno', o abra Sistema, Configuración avanzada del sistema y haga
click en el botón Variables de entorno. En este diálogo, se pueden
agregar o modificar variables del usuario o del sistema. Para cambiar
variables del sistema, se necesita acceso no restringido al equipo
(por ej. con credenciales de administrador).

Nota:

  Windows concatenará las variables de usuario *luego* de las
  variables del sistema, lo cual puede causar resultados inesperados
  cuando se modifica "PATH".Todas las versiones de Python utilizan la
  variable "PYTHONPATH", por lo que no debe configurarla de forma
  permanente a menos que las rutas enumeradas solo incluyan código
  compatible con todas las versiones de Python instaladas.

Ver también:

  https://docs.microsoft.com/en-us/windows/win32/procthread
  /environment-variables
     Descripción general de las variables de entorno en Windows

  https://docs.microsoft.com/en-us/windows-server/administration
  /windows-commands/set_1
     El comando "set", para modificar temporalmente las variables de
     entorno

  https://docs.microsoft.com/en-us/windows-server/administration
  /windows-commands/setx
     El comando "setx", para modificar permanentemente las variables
     de entorno


4.6.2. Encontrar el ejecutable de Python
----------------------------------------

Distinto en la versión 3.5.

Además de utilizar la entrada para el intérprete de Python creada
automáticamente en el menú de Inicio, es posible que desee iniciar
Python desde el símbolo del sistema. El instalador posee una opción
para realizar esa configuración.

En la primera página del instalador, la opción llamada "Add Python to
PATH" puede ser seleccionada para que el instalador agregue la
ubicación de instalación a "PATH". La ubicación del directorio
"Scripts\" también es agregada. Esto permite escribir **python** para
iniciar el intérprete, y **pip** para el instalador de paquetes. De
esta manera los scripts también pueden ser ejecutados con opciones de
línea de comandos, consulte la documentación de Línea de comando.

Si no se activa esta opción durante la instalación, en cualquier
momento se puede ejecutar nuevamente el instalador, seleccionar
Modify, y activarla. Otra alternativa es modificar "PATH" manualmente
siguiendo las instrucciones en Excurso: configurar variables de
entorno. Se necesita configurar la variable de entorno "PATH" para que
incluya el directorio de instalación de Python, separándolo con punto
y coma (;) de las otras entradas. Una variable de ejemplo pude verse
así (suponiendo que las dos primeras entradas ya existían):

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


4.7. Modo UTF-8
===============

Added in version 3.7.

Windows todavía usa codificaciones heredadas para la codificación del
sistema (la página de códigos ANSI). Python lo usa para la
codificación predeterminada de archivos de texto (por ejemplo,
"locale.getencoding()").

Esto puede causar problemas porque UTF-8 es ampliamente utilizado en
internet y en la mayoría de los sistemas Unix, incluido WSL
(subsistema de Windows para Linux).

Se puede utilizar el modo UTF-8 para cambiar la codificación
predeterminada a UTF-8. El modo UTF-8 se puede activar mediante la
opción de línea de comandos "-X utf-8", o con la variable de entorno
"PYTHONUTF8=1". Consulte "PYTHONUTF8" para activar el modo UTF-8, y
Excurso: configurar variables de entorno para saber cómo modificar las
variables de entorno.

Cuando el modo UTF-8 de Python es activado, usted puede seguir usando
la codificación del sistema (La página de código ANSI) a través del
códec "mbcs".

Tenga en cuenta que agregar "PYTHONUTF8=1" a las variables de entorno
predeterminadas afectará a todas las aplicaciones de Python 3.7+ en el
sistema. Si utiliza alguna aplicación de Python 3.7+ que depende de la
codificación heredada del sistema, se recomienda que se configure la
variable de entorno solo temporalmente o se use la opción de línea de
comandos "-X utf8".

Nota:

  Aún con el modo UTF-8 desactivado, Python utiliza UTF-8 de forma
  predeterminada en Windows para:

  * E/S de consola, incluida la E/S estándar (consultar **PEP 528**
    para más detalles).

  * La *codificación del sistema* (vea **PEP 529** para más detalles).


4.8. Lanzador de Python para Windows
====================================

Added in version 3.3.

El lanzador de Python para Windows es una utilidad que ayuda en la
ubicación y ejecución de diferentes versiones de Python. Este permite
que los scripts (o la línea de comandos) indiquen preferencia por una
versión específica de Python, y ubicará y ejecutará esa versión.

A diferencia de la variable "PATH", el lanzador seleccionará
correctamente la versión más apropiada de Python. Priorizará
instalaciones del usuario por sobre instalaciones de todo el sistema,
y ordenará por versión del lenguaje en lugar de utilizar la más
recientemente instalada.

El lanzador se especificó originalmente en **PEP 397**.


4.8.1. Comenzar
---------------


4.8.1.1. Desde la línea de comandos
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Distinto en la versión 3.6.

Las instalaciones de todo el sistema de Python 3.3 y versiones
posteriores colocarán el lanzador en su "PATH". El lanzador es
compatible con todas las versiones disponibles de Python, por lo que
no importa qué versión esté instalada. Para comprobar que el lanzador
está disponible, ejecute el siguiente comando en el símbolo del
sistema:

   py

Debería suceder que se inicia la última versión de Python instalada -
se puede cerrar normalmente, y todo argumento adicional especificado
por línea de comandos será enviado directamente a Python.

Si tiene varias versiones de Python instaladas (por ejemplo, 3.7 y
3.12), habrá notado que Python 3.12 se inició: para iniciar Python
3.7, pruebe el comando:

   py -3.7

Si quieres la última versión de Python 2 que tienes instalada, prueba
el comando:

   py -2

Si ve el siguiente error, no tiene instalado el lanzador:

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

El comando:

   py --list

muestra la(s) versión(es) actualmente instalada(s) de Python.

El argumento "-x.y" es la forma corta del argumento
"-V:Compañía/Etiqueta", que permite seleccionar un entorno de
ejecución Python específico, incluidos aquellos que pueden haber
provenido de lugares diferentes a python.org. Cualquier entorno
registrado siguiendo el **PEP 514** será detectable. El comando "--
list" muestra todos los entornos disponibles usando el formato "-V:".

Al usar el argumento "-V:", especificar la Compañía limitará la
selección a entornos de ese proveedor, mientras que especificar solo
la Etiqueta seleccionará de todos los proveedores. Tenga en cuenta que
omitir la barra implica una etiqueta:

   # 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

La forma corta del argumento ("-3") solo selecciona de las versiones
principales de Python y no de otras distribuciones. Sin embargo, la
forma más larga ("-V:3") seleccionará de cualquiera.

La Compañía se compara con la cadena completa, sin distinguir entre
mayúsculas y minúsculas. La Etiqueta se compara ya sea con la cadena
completa o con un prefijo, siempre que el siguiente carácter sea un
punto o un guión. Esto permite que "-V:3.1" coincida con "3.1-32",
pero no con "3.10". Las etiquetas se ordenan numéricamente("3.10" es
más reciente que "3.1"), pero se comparan usando texto ("-V:3.01" no
coincide con "3.1").


4.8.1.2. Entornos virtuales
~~~~~~~~~~~~~~~~~~~~~~~~~~~

Added in version 3.5.

Si el lanzador es ejecutado sin explícita especificación de la versión
de Python, y un entorno virtual se encuentra activo (creado con el
módulo "venv" de la biblioteca estándar o con la herramienta externa
"virtualenv"), el lanzador ejecutará el intérprete del entorno virtual
en lugar del global. Para ejecutar el intérprete global, desactive el
entorno virtual o especifique explícitamente la versión global de
Python.


4.8.1.3. Desde un script
~~~~~~~~~~~~~~~~~~~~~~~~

Vamos a crear un script de Python para una prueba - cree un archivo
llamado "hello.py" con el siguiente contenido

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

Desde el directorio en el que vive hello.py, ejecute el comando:

   py hello.py

Debería notar que se imprime el número de versión de la última
instalación de Python 2.x. Ahora pruebe cambiando la primera línea
por:

   #! python3

Volver a ejecutar el comando ahora debería imprimir la información más
reciente de Python 3.x. Al igual que con los ejemplos de línea de
comandos anteriores, puede especificar un calificador de versión más
explícito. Suponiendo que tiene instalado Python 3.7, intente cambiar
la primera línea a "#! python3.7" y debería encontrar la información
de la versión 3.7 impresa.

Tenga en cuenta que a diferencia del uso interactivo, el comando
"python" (a secas) utilizará la última versión de Python 2.x que esté
instalada. Esto es así por compatibilidad con versiones anteriores y
por compatibilidad con Unix, donde el comando "python" usualmente
refiere a Python 2.


4.8.1.4. Desde asociaciones de archivos
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

El lanzador debería haber sido asociado con archivos de Python (por
ej. archivos ".py", ".pyw" y ".pyc") cuando fue instalado. Esto
significa que cuando se haga doble click sobre alguno de estos
archivos desde el explorador de Windows se utilizará el lanzador, por
lo que se pueden utilizar las mismas funciones descritas anteriormente
para que el script especifique la versión que debería usarse.

El beneficio clave de esto es que un único lanzador puede soportar
múltiples versiones de Python al mismo tiempo dependiendo del
contenido de la primera línea.


4.8.2. Líneas shebang
---------------------

Si la primera línea de un script comienza con "#!", esta se denomina
línea "shebang". Linux y otros sistemas operativos tipo Unix soportan
de forma nativa este tipo de líneas y son comúnmente utilizadas en
dichos sistemas para indicar cómo debería ser ejecutado un script.
Este lanzador permite que la misma funcionalidad pueda ser utilizada
con scripts de Python en Windows, y los ejemplos anteriores demuestran
su uso.

Para permitir que las líneas shebang de scripts de Python sean
trasladables entre Unix y Windows, este lanzador soporta varios
comandos 'virtuales' para especificar qué intérprete utilizar. Los
comandos virtuales soportados son:

* "/usr/bin/env"

* "/usr/bin/python"

* "/usr/local/bin/python"

* "python"

Por ejemplo, si la primera línea del script comienza con

   #! /usr/bin/python

La versión de Python predeterminada será ubicada y utilizada. Como
muchos scripts de Python escritos para funcionar en Unix tienen esta
línea, debería suceder que estos scripts pueden ser utilizados por el
lanzador sin modificaciones. Si está escribiendo un nuevo script en
Windows que espera que sea útil en Unix, debería utilizar una de las
líneas shebang que comienza con "/usr".

Cualquiera de los comandos virtuales anteriores puede tener como
sufijo una versión explícita (ya sea solo la versión principal o la
versión principal y secundaria). Además, la versión de 32 bits se
puede solicitar agregando "-32" después de la versión secundaria. Es
decir. "/usr/bin/python3.7-32" solicitará el uso de Python 3.7 de 32
bits.

Added in version 3.7: Desde la versión 3.7 del lanzador de Python es
posible solicitar la versión de 64 bit con el sufijo "-64". Además es
posible especificar una versión mayor y la arquitectura sin la versión
menor (por ej. "/usr/bin/python3-64").

Distinto en la versión 3.11: El sufijo "-64" está en desuso y ahora
implica "cualquier arquitectura que comprobable no sea i386/32 bits".
Para solicitar un entorno específico, use el nuevo argumento
"-V:*TAG*" con la etiqueta completa.

La forma "/usr/bin/env" de la línea shebang tiene otra propiedad
especial adicional. Antes de buscar intérpretes de Python instalados,
esta forma buscará en el "PATH" de ejecución un ejecutable de Python
que coincida con el nombre proporcionado como primer argumento. Esto
corresponde al comportamiento del programa Unix "env", que realiza una
búsqueda en "PATH". Si no se puede encontrar un ejecutable que
coincida con el primer argumento después del comando "env" pero el
argumento comienza con "python", será manejado como se describe para
los otros comandos virtuales. La variable de entorno
"PYLAUNCHER_NO_SEARCH_PATH" puede ser establecida (a cualquier valor)
para omitir esta búsqueda en "PATH".

Las líneas shebang que no coincidan con ninguno de estos patrones se
buscan en la sección "[commands]" del archivo .INI del lanzador. Esto
se puede usar para manejar ciertos comandos de una manera que tenga
sentido para tu sistema. El nombre del comando debe ser un único
argumento (sin espacios en el ejecutable shebang), y el valor
sustituido es la ruta completa al ejecutable (los argumentos
adicionales especificados en el .INI se citarán como parte del nombre
del archivo).

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

Cualquier comando que no se encuentre en el archivo .INI se trata como
rutas ejecutables de **Windows** que son absolutas o relativas al
directorio que contiene el archivo de script. Esto es una comodidad
para los scripts solo para Windows, como aquellos generados por un
instalador, ya que el comportamiento no es compatible con los shells
al estilo Unix. Estas rutas pueden estar entre comillas y pueden
incluir varios argumentos, tras los cuales se añadirá la ruta al
script y cualquier argumento adicional.


4.8.3. Argumentos en líneas shebang
-----------------------------------

Las líneas shebang también pueden especificar opciones adicionales
para que sean pasadas al intérprete de Python. Por ej. si se tiene
esta línea shebang:

   #! /usr/bin/python -v

Entonces Python se iniciará con la opción "-v"


4.8.4. Personalización
----------------------


4.8.4.1. Personalización con archivos INI
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

El lanzador buscará dos archivos .ini - "py.ini" en el directorio de
datos de aplicación del usuario actual ("%LOCALAPPDATA%" o
"$env:LocalAppData") y "py.ini" en el mismo directorio que el
lanzador. Los mismos archivos .ini son utilizados tanto para la
versión 'consola' del lanzador (es decir, py.exe) como para la version
'windows' (es decir pyw.exe).

La personalización especificada en el "directorio de aplicación"
tendrá precedencia por sobre la que esté junto al ejecutable, por lo
que un usuario, que podría no tener acceso de escritura al archivo
.ini que está junto al lanzador, puede sobrescribir comandos en ese
archivo .ini global.


4.8.4.2. Personalizar las versiones de Python predeterminadas
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

En algunos casos, un calificador de versión puede ser incluido en un
comando para dictar qué versión de Python será utilizada por dicho
comando. Un calificador de versión comienza con el número mayor de la
versión y pude ser seguido opcionalmente por un punto ('.') y el
número menor de la versión. Además es posible especificar si se
solicita una implementación de 32 o 64 bit agregando "-32" o "-64".

Por ejemplo, una línea shebang como "#!python" no posee calificador de
versión, mientras que "#!python3" sí tiene un calificador de versión
el cual especifica solo el número mayor de la versión.

Si no se encuentra un calificador de versión en el comando, la
variable de entorno "PY_PYTHON" puede configurarse para especificar un
calificador de versión predeterminado. Si esta no está configurada,
por defecto es "3". La variable puede especificar cualquier valor que
pueda ser pasado por línea de comandos, como "3", "3.7", "3.7-32" o
"3.7-64". (Tener en cuenta que la opción "-64" solo está disponible
con el lanzador incluido con Python 3.7 o versiones posteriores.)

Si no se encuentra ningún calificador de versión menor, la variable de
entorno "PY_PYTHON{major}" (donde "{major}" es el actual calificador
de versión mayor según lo determinado antes) puede ser configurada
para especificar la versión completa. Si dicha opción no se encuentra,
el lanzador enumerará las versiones de Python instaladas y utilizará
la última versión menor encontrada para la versión mayor, la cual es
probable, aunque no se garantiza, que sea la versión más recientemente
instalada de esa familia.

En un Windows de 64 bit con ambas implementaciones de 32 y 64 bit de
la misma versión (mayor.menor) de Python instaladas, la versión de 64
bit siempre tendrá precedencia. Esto se cumple para ambas
implementaciones de 32 y 64 bit del lanzador - un lanzador de 32 bit
priorizará ejecutar una instalación de Python de 64 bit de la versión
especificada si está disponible. Esto es así para que el
comportamiento del lanzador pueda ser predecible sabiendo solamente
qué versiones están instaladas en la PC y sin importar el orden en el
cual fueron instaladas (esto es, sin saber si una versión de Python de
32 o 64 bit y su correspondiente lanzador fue la última instalada).
Como se especificó antes, el sufijo "-32" o "-64" puede ser utilizado
en el especificador de versión para cambiar este comportamiento.

Ejemplos:

* Si no se configura ninguna opción relevante, los comandos "python" y
  "python2" utilizarán la última versión de Python 2.x instalada y el
  comando "python3" utilizará el último Python 3.x instalado.

* El comando "python3.7" no consultará ninguna opción ya que las
  versiones están completamente especificadas.

* Si "PY_PYTHON=3", los comandos "python" y "python3" utilizarán ambos
  la última versión instalada de Python 3.

* Si es "PY_PYTHON=3.7-32", el comando "python" usará la
  implementación de 32 bits de 3.7, mientras que el comando "python3"
  usará la última versión de Python instalada (PY_PYTHON no se
  consideró en absoluto porque se especificó una versión principal).

* Si "PY_PYTHON=3" y "PY_PYTHON3=3.7", los comandos "python" y
  "python3" usarán específicamente 3.7

Además de las variables de entorno, las mismas configuraciones pueden
realizarse desde el archivo .INI utilizado por el lanzador. La sección
en el archivo INI se llama "[defaults]" y el nombre de cada clave será
igual al de la variable de entorno pero sin el prefijo "PY_" (tenga en
cuenta que los nombres de clave en el archivo INI son indiferentes a
mayúsculas y minúsculas). El contenido de las variables de entorno
sobrescribirá los valores especificados en el archivo INI.

Por ejemplo:

* La configuración de "PY_PYTHON=3.7" es equivalente al archivo INI
  que contiene:

   [defaults]
   python=3.7

* La configuración de "PY_PYTHON=3" y "PY_PYTHON3=3.7" es equivalente
  al archivo INI que contiene:

   [defaults]
   python=3
   python3=3.7


4.8.5. Diagnóstico
------------------

Si se establece una variable de entorno "PYLAUNCHER_DEBUG" (en
cualquier valor), el lanzador imprimirá información de diagnóstico en
stderr (es decir, en la consola). Si bien esta información logra ser
simultáneamente detallada *and* concisa, debería permitirle ver qué
versiones de Python se ubicaron, por qué se eligió una versión en
particular y la línea de comando exacta utilizada para ejecutar el
Python de destino. Está destinado principalmente a pruebas y
depuración.


4.8.6. Ejecución en seco
------------------------

Si se establece una variable de entorno "PYLAUNCHER_DRYRUN" (en
cualquier valor), el lanzador generará el comando que habría
ejecutado, pero en realidad no iniciará Python. Esto puede ser útil
para las herramientas que desean usar el lanzador para detectar y
luego iniciar Python directamente. Tenga en cuenta que el comando
escrito en la salida estándar siempre se codifica con UTF-8 y es
posible que no se represente correctamente en la consola.


4.8.7. Instalación bajo demanda
-------------------------------

Si se establece una variable de entorno "PYLAUNCHER_ALLOW_INSTALL" (en
cualquier valor) y la versión de Python solicitada no está instalada
pero está disponible en Microsoft Store, el lanzador intentará
instalarla. Esto puede requerir la interacción del usuario para
completarse y es posible que deba ejecutar el comando nuevamente.

Una variable "PYLAUNCHER_ALWAYS_INSTALL" adicional hace que el
lanzador siempre intente instalar Python, incluso si se detecta. Esto
está diseñado principalmente para pruebas (y debe usarse con
"PYLAUNCHER_DRYRUN").


4.8.8. Códigos de retorno
-------------------------

El lanzador de Python puede retornar los siguientes códigos de salida.
Desafortunadamente, no hay forma de distinguirlos del código de salida
de Python.

Los nombres de los códigos son como se usan en las fuentes y son solo
para referencia. No hay forma de acceder a ellos o resolverlos aparte
de leer esta página. Las entradas se enumeran en orden alfabético de
nombres.

+---------------------+---------+-------------------------------------------------+
| Nombre              | Valor   | Descripción                                     |
|=====================|=========|=================================================|
| RC_BAD_VENV_CFG     | 107     | Se encontró un "pyvenv.cfg" pero está corrupto. |
+---------------------+---------+-------------------------------------------------+
| RC_CREATE_PROCESS   | 101     | No se pudo iniciar Python.                      |
+---------------------+---------+-------------------------------------------------+
| RC_INSTALLING       | 111     | Se inició una instalación, pero será necesario  |
|                     |         | volver a ejecutar el comando una vez que se     |
|                     |         | complete.                                       |
+---------------------+---------+-------------------------------------------------+
| RC_INTERNAL_ERROR   | 109     | Error inesperado. Por favor, informe de un      |
|                     |         | error.                                          |
+---------------------+---------+-------------------------------------------------+
| RC_NO_COMMANDLINE   | 108     | No se puede obtener la línea de comandos del    |
|                     |         | sistema operativo.                              |
+---------------------+---------+-------------------------------------------------+
| RC_NO_PYTHON        | 103     | No se puede encontrar la versión solicitada.    |
+---------------------+---------+-------------------------------------------------+
| RC_NO_VENV_CFG      | 106     | Se requería un "pyvenv.cfg" pero no se          |
|                     |         | encontró.                                       |
+---------------------+---------+-------------------------------------------------+


4.9. Encontrar módulos
======================

Estas notas complementan la descripción en La inicialización de la
ruta de búsqueda de módulo de sys.path con notas detalladas de
Windows.

Cuando no se encuentre ningún archivo "._pth", así es como "sys.path"
es completado en Windows:

* Se agrega una entrada vacía al comienzo, que corresponde al
  directorio actual.

* Si existe la variable de entorno "PYTHONPATH", de acuerdo a lo
  descrito en Variables de entorno, sus entradas se agregan a
  continuación. Tenga en cuenta que en Windows, las rutas en esta
  variable deben estar separadas por punto y coma (;), para
  distinguirlas de los dos puntos utilizados en los identificadores de
  disco ("C:\", etc.).

* Se pueden agregar al registro "rutas de aplicación" adicionales como
  subclaves de "\SOFTWARE\Python\PythonCore{version}\PythonPath" bajo
  los subárboles "HKEY_CURRENT_USER" y "HKEY_LOCAL_MACHINE". Las
  subclaves que contienen un valor por defecto compuesto por cadenas
  de ruta separadas por punto y coma causan que cada una de esas rutas
  sea agregada a "sys.path". (Tenga en cuenta que todos los
  instaladores conocidos solo utilizan HKLM, por lo que HKCU
  comúnmente se encuentra vacío.)

* Si se configura la variable de entorno "PYTHONHOME", es asumida como
  el "Python Home" (el directorio de origen de Python). De lo
  contrario, la ruta del ejecutable principal de Python es utilizada
  para ubicar un "archivo de referencia" (ya sea "Lib\os.py" o
  "pythonXY.zip") para deducir el "Python Home". Si el directorio de
  origen de Python es encontrado, los subdirectorios relevantes que se
  agregan a "sys.path" ("Lib", "plat-win", etc.) se basan en ese
  directorio. Por el contrario, la ruta principal de Python se
  construye a partir del PythonPath guardado en el registro.

* Si el Python Home no puede ser ubicado, "PYTHONPATH" no está
  especificado en el entorno y no se encuentra ninguna entrada en el
  registro, se usa una ruta predeterminada con entradas relativas (por
  ej. ".\Lib;.\plat-win", etc.).

Si se encuentra el archivo "pyvenv.cfg" junto al ejecutable principal
o en el directorio un nivel arriba del ejecutable, se aplica la
siguiente variación:

* Si "home" es una ruta absoluta y "PYTHONHOME" no está configurada,
  se usa esta ruta en lugar de la ruta al ejecutable principal para
  deducir la ubicación del directorio de origen.

El resultado final de todo esto es:

* Cuando se ejecuta "python.exe", o cualquier otro .exe en el
  directorio principal de Python (tanto la versión instalada como
  directamente desde el directorio PCbuild), se deduce la ruta
  principal, y se ignoran las rutas principales en el registro.
  Siempre se leen otras "rutas de aplicación" del registro.

* Cuando se aloja Python en otro .exe (distinto directorio, incrustado
  mediante COM, etc.), el "Python Home" no se deduce, y se utiliza la
  ruta principal del registro. Siempre se leen otras "rutas de
  aplicación" del registro.

* Si Python no puede encontrar su directorio de origen y no hay
  valores en el registro (un .exe congelado, una muy rara
  configuración de instalación) se obtiene una ruta relativa
  predeterminada.

Para aquellos que quieran incluir Python en su aplicación o
distribución, los siguientes consejos evitarán conflictos con otras
instalaciones:

* Incluya un archivo "._pth" junto al ejecutable, que contenga los
  directorios a incluir. Esto hará que se ignoren las rutas enumeradas
  en el registro y en las variables de entorno, y que también se
  ignore "site" a menos que se especifique "import site".

* Si se carga "python3.dll" o "python37.dll" desde un ejecutable
  propio, invocar explícitamente "Py_SetPath()" o (al menos)
  "Py_SetProgramName()" antes de "Py_Initialize()".

* Limpie y/o sobrescriba "PYTHONPATH" y configure "PYTHONHOME" antes
  de iniciar "python.exe" desde su aplicación.

* Si no se pueden utilizar las sugerencias previas (por ejemplo, en
  una distribución que permite a los usuarios ejecutar "python.exe"
  directamente), hay que asegurarse de que el archivo de referencia
  ("Lib\os.py") exista en el directorio de instalación. (Tener en
  cuenta que este no será detectado dentro de un archivo ZIP, pero si
  se detectará un ZIP correctamente nombrado.)

Esto asegura que los archivos de una instalación del sistema no
tendrán precedencia por sobre la copia de la biblioteca estándar
incluida en su aplicación. De otra manera, los usuarios podrían
experimentar problemas al utilizar su aplicación. Tenga en cuenta que
la primera sugerencia es la mejor, ya que las otras aún pueden ser
afectadas por rutas no estándar en el registro y en el site-packages
del usuario.

Distinto en la versión 3.6: Add "._pth" file support and removes
"applocal" option from "pyvenv.cfg".

Distinto en la versión 3.6: Add "python*XX*.zip" as a potential
landmark when directly adjacent to the executable.

Obsoleto desde la versión 3.6: Los módulos especificados en el
registro bajo "Modules" (no "PythonPath") pueden ser importados por
"importlib.machinery.WindowsRegistryFinder". Este buscador está
habilitado en Windows en la versión 3.6.0 y anteriores, pero es
posible que deba agregarse explícitamente a "sys.meta_path" en el
futuro.


4.10. Módulos adicionales
=========================

Aunque Python pretende ser portátil entre todas las plataformas, hay
características que son exclusivas de Windows. Existen un par de
módulos, de la biblioteca estándar y externos, y fragmentos de código
para utilizar estas funciones.

Los módulos estándar específicos para Windows se encuentran
documentados en Servicios Específicos para 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)

* Invocación de la API Win32

* Registro

* Registro de eventos

* Interfaces de usuario Microsoft Foundation Classes (MFC)

PythonWin es una aplicación MFC de muestra distribuida con PyWin32. Es
un IDE incrustable con depurador incorporado.

Ver también:

  Win32 How Do I...?
     por Tim Golden

  Python and COM
     por David y Paul Boddie


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

cx_Freeze envuelve scripts de Python en programas ejecutables de
Windows (archivos "***.exe").Cuando hayas hecho esto, puedes
distribuir tu aplicación sin requerir que tus usuarios instalen
Python.


4.11. Compilar Python en Windows
================================

Si desea compilar CPython usted mismo, lo primero que debe hacer es
obtener el source. Puede descargar la fuente de la última versión o
simplemente obtener un checkout nuevo.

El árbol fuente contiene una solución de compilación y archivos de
proyecto para Microsoft Visual Studio, que es el compilador que se usa
para compilar las versiones oficiales de Python. Estos archivos están
en el directorio "PCbuild".

Consulte "PCbuild/readme.txt" para obtener información general acerca
del proceso de compilación.

Para módulos de extensión, consulte Creación de extensiones C y C++ en
Windows.


4.12. Otras plataformas
=======================

Con el continuo desarrollo de Python, algunas plataformas que solían
ser compatibles ya no lo son (debido a la falta de usuarios o
desarrolladores). Consulte **PEP 11** para detalles sobre las
plataformas no soportadas.

* Windows CE es no longer supported desde Python 3 (si alguna vez lo
  fue).

* El instalador Cygwin ofrece instalar también el Python interpreter

Para obtener información detallada acerca de las plataformas con
instaladores precompilados consulte Python for Windows.
