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.

A diferencia de la mayoría de sistemas y servicios Unix, Windows no
incluye una instalación de Python soportada por el sistema. Para hacer
que Python esté disponible, el equipo de CPython ha compilado
instaladores de Windows (paquetes MSI) con cada lanzamiento durante
muchos años. Estos instaladores están destinados principalmente a
agregar una instalación de Python para cada usuario, con el intérprete
principal y la biblioteca para ser usados por un solo usuario. El
instalador también es capaz de hacer la instalación para todos los
usuarios de una única máquina, y un archivo ZIP separado está
disponible para distribuciones locales (específicas) para cada
aplicación.

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.10 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 is a simple installation of Python that is
suitable for running scripts and packages, and using IDLE or other
development environments. It requires Windows 10 and above, but can be
safely installed without corrupting other programs. It also provides
many convenient commands for launching Python and its tools.

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.10 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 devuelvan 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.

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

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                 | Agregar directorios de instalación y   | 0                          |
|                             | Scripts a "PATH" y ".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                 | Install developer headers and          | 1                          |
|                             | libraries. Omitting this may lead to   |                            |
|                             | an unusable installation.              |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Include_exe                 | Install "python.exe" and related       | 1                          |
|                             | files. Omitting this may lead to an    |                            |
|                             | unusable installation.                 |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Include_launcher            | Instalar Lanzador de Python para       | 1                          |
|                             | Windows.                               |                            |
+-----------------------------+----------------------------------------+----------------------------+
| InstallLauncherAllUsers     | Installs the launcher for all users.   | 1                          |
|                             | Also requires "Include_launcher" to be |                            |
|                             | set to 1                               |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Include_lib                 | Install standard library and extension | 1                          |
|                             | modules. Omitting this may lead to an  |                            |
|                             | unusable installation.                 |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Include_pip                 | Instalar los paquetes pip y setuptools | 1                          |
+-----------------------------+----------------------------------------+----------------------------+
| Include_symbols             | Install debugging symbols ("*.pdb")    | 0                          |
+-----------------------------+----------------------------------------+----------------------------+
| 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
===============================

Nuevo en la versión 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.10" 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.10). 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. Known issues
-------------------


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

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

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

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

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

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

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

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

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

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

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
============================

Nuevo en la versión 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 .

To select a particular version, add a "-Version 3.x.y". The output
directory may be changed from ".", and the package will be installed
into a subdirectory. By default, the subdirectory is named the same as
the package, and without the "-ExcludeVersion" option this name will
include the specific version installed. Inside the subdirectory is a
"tools" directory that contains the Python installation:

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

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

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
===========================

Nuevo en la versión 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
(incluidos sus dependientes, como Idle), pip y la documentación de
Python no están incluidos.

Nota:

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

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
   "The Next Generation Python Environment and Package Manager".

   Previously Enthought provided Canopy, but it reached end of life in
   2016.

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".The "PYTHONPATH" variable is used by all
  versions of Python, so you should not permanently configure it
  unless the listed paths only include code that is compatible with
  all of your installed Python versions.

Ver también:

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

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

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


4.6.2. 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
===============

Nuevo en la versión 3.7.

Windows aún utiliza codificación heredada para la codificación del
sistema (la página de códigos ANSI). Python la utiliza para la
codificación por defecto de archivos de texto (por ej.
"locale.getpreferredencoding()").

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
====================================

Nuevo en la versión 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.

System-wide installations of Python 3.3 and later will put the
launcher on your "PATH". The launcher is compatible with all available
versions of Python, so it does not matter which version is installed.
To check that the launcher is available, execute the following command
in Command Prompt:

   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.

If you have multiple versions of Python installed (e.g., 3.7 and 3.10)
you will have noticed that Python 3.10 was started - to launch Python
3.7, try the command:

   py -3.7

If you want the latest version of Python 2 you have installed, try the
command:

   py -2

You should find the latest version of Python 3.x starts.

If you see the following error, you do not have the launcher
installed:

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

Las instalaciones por usuario de Python no agregan la ubicación del
lanzador a "PATH" a menos que la opción haya sido seleccionada durante
la instalación.

The command:

   py --list

displays the currently installed version(s) of Python.


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

Nuevo en la versión 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,))

From the directory in which hello.py lives, execute the command:

   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

Re-executing the command should now print the latest Python 3.x
information. As with the above command-line examples, you can specify
a more explicit version qualifier.  Assuming you have Python 3.7
installed, try changing the first line to "#! python3.7" and you
should find the 3.7 version information printed.

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

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

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

Nuevo en la versión 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").

La forma "/usr/bin/env" de la línea shebang tiene un significado
especial más. Antes de buscar intérpretes de Python instalados, esta
forma buscará el ejecutable de Python en "PATH". Esto se corresponde
con el comportamiento en Unix del programa "env", el cual realiza una
búsqueda en "PATH".


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 (esto es el directorio
retornado por el llamado a la función de Windows "SHGetFolderPath" con
"CSIDL_LOCAL_APPDATA") y "py.ini" en el directorio del lanzador. Los
mismos archivos .ini son usados por la versión 'consola' del lanzador
(py.exe) y por la versión 'ventana' (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.

* The command "python3.7" will not consult any options at all as the
  versions are fully specified.

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

* If "PY_PYTHON=3.7-32", the command "python" will use the 32-bit
  implementation of 3.7 whereas the command "python3" will use the
  latest installed Python (PY_PYTHON was not considered at all as a
  major version was specified.)

* If "PY_PYTHON=3" and "PY_PYTHON3=3.7", the commands "python" and
  "python3" will both use specifically 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:

* Setting "PY_PYTHON=3.7" is equivalent to the INI file containing:

   [defaults]
   python=3.7

* Setting "PY_PYTHON=3" and "PY_PYTHON3=3.7" is equivalent to the INI
  file containing:

   [defaults]
   python=3
   python3=3.7


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

Si se configura la variable de entorno "PYLAUNCH_DEBUG" (con cualquier
valor), el lanzador imprimirá información de diagnóstico a stderr (en
la consola). Aunque esta información es a la vez detallada y concisa,
debería permitirle ver qué versiones de Python fueron encontradas, por
qué se eligió una versión particular y la línea de comandos exacta que
fue utilizada para ejecutar el Python escogido.


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

Python generalmente almacena su biblioteca (y por lo tanto el
directorio site-packages) en el directorio de instalación. Por lo
tanto si Python fue instalado en "C:\Python\", la biblioteca
predeterminada residirá en "C:\Python\Lib\" y los módulos de terceros
deberían almacenarse en "C:\Python\Lib\site-packages\".

Para sobrescribir "sys.path" completamente, crear un archivo "._pth"
con el mismo nombre que la DLL ("python37._pth") o el ejecutable
("python._pth") y especificar una línea por cada ruta a agregar a
"sys.path". El archivo basado en el nombre de la DLL tiene precedencia
sobre el basado en el ejecutable, lo que permite restringir las rutas
para cualquier programa que cargue el tiempo de ejecución si se desea.

Cuando el archivo existe, se ignoran todas las variables de entorno y
del registro, se activa el modo aislado, y no se importa "site" a
menos que una línea en el archivo especifique "import site". Rutas en
blanco y líneas que comiencen con "#" son ignoradas. Cada ruta puede
ser absoluta o relativa a la ubicación del archivo. No se permiten
declaraciones de importación más que la de "site", y no se puede
especificar código arbitrario.

Tenga en cuenta que los archivos ".pth" (sin guion bajo al inicio)
serán procesados normalmente por el módulo "site" cuando "import site"
haya sido especificado.

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:

   * Agrega soporte para archivos "._pth" y elimina la opción
     "applocal" de "pyvenv.cfg".

   * Agrega "pythonXX.zip" como un potencial archivo de referencia
     cuando se encuentra junto al ejecutable.

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

El módulo PyWin32 de Mark Hammond es una colección de módulos para
soporte avanzado específico para Windows. Este incluye utilidades
para:

* Component Object Model (COM)

* Invocación de la API Win32

* Registro

* Registro de eventos

* Microsoft Foundation Classes (MFC) user interfaces

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 es una extensión de "distutils" (ver Extendiendo Distutils)
que empaqueta scripts de Python en programas ejecutables de Windows
(archivos "***.exe" ). Al hacer esto, se puede distribuir una
aplicación sin que los usuarios necesiten instalar Python.


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

If you want to compile CPython yourself, first thing you should do is
get the source. You can download either the latest release's source or
just grab a fresh checkout.

The source tree contains a build solution and project files for
Microsoft Visual Studio, which is the compiler used to build the
official Python releases. These files are in the "PCbuild" directory.

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 is no longer supported since Python 3 (if it ever was).

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

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