4. Utilizando Python no Windows
*******************************

Este documento pretende dar uma visão geral do comportamento
específico do Windows que você deve conhecer quando fores utilizar o
Python no sistema operacional Microsoft Windows.

Ao contrário da maioria dos sistemas e serviços Unix, o Windows não
inclui uma instalação do Python com suporte no sistema. Em vez disso,
o Python pode ser obtido de diversos distribuidores, inclusive
diretamente da equipe do CPython. Cada distribuição do Python terá
suas próprias vantagens e desvantagens; no entanto, a consistência com
outras ferramentas que você usa geralmente é um benefício valioso.
Antes de se comprometer com o processo descrito aqui, recomendamos
verificar suas ferramentas existentes para ver se elas podem fornecer
Python diretamente.

Para obter o Python da equipe do CPython, use o Python Install Manager
(gerenciador de instalação do Python). Esta é uma ferramenta autônoma
que disponibiliza o Python como comandos globais na sua máquina
Windows, integra-se ao sistema e suporta atualizações ao longo do
tempo. Você pode baixar o Python Install Manager. em
python.org/downloads ou pelo aplicativo da Microsoft Store.

Após instalar o Python Install Manager, o comando global "python" pode
ser usado em qualquer terminal para iniciar a versão mais recente do
Python. Essa versão pode mudar com o tempo, conforme você adiciona ou
remove versões diferentes, e o comando "py list" mostrará qual é a
atual.

Em geral, recomendamos que você crie um ambiente virtual para cada
projeto e execute "<env>\Scripts\Activate" no seu terminal para
usá-lo. Isso proporciona isolamento entre projetos, consistência ao
longo do tempo e garante que comandos adicionais adicionados por
pacotes também estejam disponíveis na sua sessão. Crie um ambiente
virtual usando "python -m venv <caminho do ambiente>".

Se os comandos "python" ou "py" não estiverem funcionando, consulte a
seção Solução de problemas abaixo. Às vezes, são necessárias etapas
manuais adicionais para configurar seu PC.

Além de usar o gerenciador de instalação do Python, o Python também
pode ser obtido como pacotes NuGet. Veja Os pacotes nuget.org abaixo
para mais informações sobre esses pacotes.

As distribuições incorporáveis são pacotes mínimos do Python adequados
para incorporação em aplicações maiores. Elas podem ser instaladas
usando o gerenciador de instalação do Python. Consulte O pacote
embutível abaixo para obter mais informações sobre esses pacotes.


4.1. Gerenciador de instalação do Python
========================================


4.1.1. Instalação
-----------------

O gerenciador de instalação do Python pode ser instalado a partir da
aplicação da Microsoft Store ou baixado e instalado de
python.org/downloads. As duas versões são idênticas.

Para instalar pela Store, basta clicar em "Install". Após a conclusão,
abra um terminal e digite "python" para começar.

Para instalar o arquivo baixado de python.org, clique duas vezes e
selecione "Install" ou execute "Add-AppxPackage <caminho para MSIX>"
no Windows Powershell.

Após a instalação, os comandos "python", "py" e "pymanager" devem
estar disponíveis. Se você já possui instalações do Python ou
modificou a variável "PATH", pode ser necessário removê-las ou
desfazer as modificações. Consulte Troubleshooting para obter mais
ajuda sobre como corrigir comandos que não funcionam.

Ao instalar um ambiente de execução pela primeira vez, você
provavelmente será solicitado a adicionar um diretório ao seu "PATH".
Isso é opcional se você preferir usar o comando "py", mas é oferecido
para aqueles que preferem que todos os apelidos (como
"python3.14.exe") estejam disponíveis. O diretório será
"%LocalAppData%\Python\bin" por padrão, mas pode ser personalizado por
um administrador. Clique em Iniciar e pesquise "Editar as variáveis de
ambiente para sua conta" na página de configurações do sistema para
adicionar o caminho.

Cada ambiente de execução do Python que você instalar terá seu próprio
diretório para scripts. Estes também precisam ser adicionados a "PATH"
se você quiser usá-los.

O gerenciador de instalação do Python será atualizado automaticamente
para novas versões. Isso não afeta nenhuma instalação de ambientes de
execução do Python. Desinstalar o gerenciador de instalação do Python
não desinstala nenhum ambiente de execução do Python.

Se você não conseguir instalar um MSIX no seu contexto, por exemplo,
se estiver usando um software de implantação automatizada que não
oferece suporte a isso ou se estiver mirando o Windows Server 2019,
consulte Advanced Installation abaixo para obter mais informações.


4.1.2. Uso básico
-----------------

O comando recomendado para iniciar o Python é "python", que iniciará a
versão solicitada pelo script em execução, um ambiente virtual ativo
ou a versão padrão instalada, que será a versão estável mais recente,
a menos que configurado de outra forma. Se nenhuma versão for
solicitada especificamente e nenhum ambiente de execução estiver
instalado, a versão mais recente será instalada automaticamente.

Para todos os cenários que envolvem múltiplas versões de ambientes de
execução do antigo inicializador "py.exe". Por padrão, "py"
corresponde ao comportamento de "python", mas também permite opções de
linha de comando para selecionar uma versão específica, bem como
subcomandos para gerenciar instalações. Estes são detalhados abaixo.

Como o comando "py" pode já estar sendo executado pela versão
anterior, há também um comando "pymanager" inequívoco. Instalações com
script que pretendem usar o gerenciador de instalação Python devem
considerar o uso de "pymanager", devido à menor chance de conflito com
instalações existentes. A única diferença entre os dois comandos é
que, quando executados sem argumentos, "py" instalará e iniciará seu
interpretador padrão, enquanto "pymanager" exibirá ajuda ("pymanager
exec ..." oferece comportamento equivalente a "py ...").

Cada um desses comandos também possui uma versão em janela que evita a
criação de uma janela de console. São eles "pyw", "pythonw" e
"pymanagerw". Um comando "python3" também está incluído, imitando o
comando "python". Ele visa detectar usos acidentais do comando POSIX
típico no Windows, mas não se destina a ser amplamente utilizado ou
recomendado.

Para iniciar seu ambiente de execução padrão, execute "python" ou "py"
com os argumentos que você deseja passar para o ambiente de execução
(como arquivos de script ou o módulo a ser iniciado):

   $> py
   ...
   $> python meu-script.py
   ...
   $> py -m this
   ...

O ambiente de execução padrão pode ser substituído pela variável de
ambiente "PYTHON_MANAGER_DEFAULT" ou por um arquivo de configuração.
Consulte Configuração para obter informações sobre as configurações.

Para iniciar um ambiente de execução específico, o comando "py" aceita
a opção "-V:<TAG>". Esta opção deve ser especificada antes de
quaisquer outras. A tag é parte ou todo o identificador do ambiente;
para aqueles da equipe do CPython, parece a versão, potencialmente com
a plataforma. Para compatibilidade, o "V:" pode ser omitido nos casos
em que a tag se refere a uma versão oficial e começa com "3".

   $> py -V:3.14 ...
   $> py -V:3-arm64 ...

Ambientes de execução de outros distribuidores podem exigir a inclusão
da *company* também. Esta deve ser separada da tag por uma barra e
pode ser um prefixo. Especificar a empresa é opcional quando se trata
de "PythonCore", e especificar a tag é opcional (mas não a barra)
quando se deseja a versão mais recente de uma empresa específica.

   $> py -V:Distribuidor\1.0 ...
   $> py -V:distrib/ ...

Se nenhuma versão for especificada, mas um arquivo de script for
passado, o script será inspecionado em busca de uma *linha de
shebang*. Este é um formato especial para a primeira linha de um
arquivo que permite a substituição do comando. Consulte Shebang lines
para obter mais informações. Quando não houver uma linha shebang ou o
problema não puder ser resolvido, o script será iniciado com o
ambiente de execução padrão.

Se você estiver executando em um ambiente virtual ativo, não tiver
solicitado uma versão específica e não houver uma linha shebang, o
ambiente de execução padrão será o ambiente virtual em questão. Nesse
cenário, o comando "python" provavelmente já foi substituído e nenhuma
dessas verificações ocorreu. No entanto, esse comportamento garante
que o comando "py" possa ser usado de forma intercambiável.

Ao iniciar "python" ou "py", mas não tiver nenhum ambiente de execução
instalado, e a versão solicitada for a padrão, ele será instalado
automaticamente e, em seguida, executado. Caso contrário, a versão
solicitada será instalada se a instalação automática estiver
configurada (provavelmente definindo
"PYTHON_MANAGER_AUTOMATIC_INSTALL" como "true") ou se as formas "py
exec" ou "pymanager exec" do comando tiverem sido utilizadas.


4.1.3. Comando help
-------------------

O comando "py help" exibirá a lista completa de comandos suportados,
juntamente com suas opções. Qualquer comando pode receber a opção "-?"
para exibir sua ajuda, ou seu nome pode ser passado para "py help".

   $> py help
   $> py help install
   $> py install /?

Todos os comandos oferecem suporte a algumas opções comuns, que serão
exibidas por "py help". Essas opções devem ser especificadas após
qualquer subcomando. Especificar "-v" ou "--verbose" aumentará a
quantidade de saída exibida, e "-vv" aumentará ainda mais para fins de
depuração. Passar "-q" ou "--quiet" reduzirá a saída, e "-qq" a
reduzirá ainda mais.

A opção "--config=<PATH>" permite especificar um arquivo de
configuração para substituir várias configurações simultaneamente.
Consulte Configuração abaixo para obter mais informações sobre esses
arquivos.


4.1.4. Listando ambientes de execução
-------------------------------------

   $> py list [-f=|--format=<FMT>] [-1|--one] [--online|-s=|--source=<URL>] [<TAG>...]

A lista de ambientes de execução instalados pode ser visualizada
usando "py list". Um filtro pode ser adicionado na forma de uma ou
mais tags (com ou sem especificador de empresa), e cada uma pode
incluir um prefixo "<", "<=", ">=" ou ">" para restringir a um
intervalo.

Vários formatos são suportados e podem ser passados como a opção "--
format=<FMT>" ou "-f <FMT>". Os formatos incluem "table" (uma
visualização de tabela amigável), "csv" (tabela separada por
vírgulas), "json" (um único blob JSON), "jsonl" (um blob JSON por
resultado), "exe" (apenas o caminho do executável), "prefix" (apenas o
caminho do prefixo).

A opção "--one" ou "-1" exibe apenas um único resultado. Se o ambiente
de execução padrão estiver incluído, será ele. Caso contrário, o
"melhor" resultado será exibido ("melhor" é definido de forma
deliberadamente vaga, mas geralmente será a versão mais recente). O
resultado exibido por "py list --one <TAG>" corresponderá ao ambiente
de execução que seria iniciado por "py -V:<TAG>".

A opção "--only-managed" exclui resultados que não foram instalados
pelo gerenciador de instalação do Python. Isso é útil para determinar
quais ambientes de execução podem ser atualizados ou desinstalados por
meio do comando "py".

A opção "--online" é uma abreviação de "--source=<URL>" com a fonte
padrão. Passar qualquer uma dessas opções pesquisará no índice online
os ambientes de execução que podem ser instalados. O resultado exibido
por "py list --online --one <TAG>" corresponderá ao ambiente de
execução que seria instalado por "py install <TAG>".

   $> py list --online 3.14

Para compatibilidade com o inicializador antigo, os comandos "--list",
"--list-paths", "-0" e "-0p" (por exemplo, "py -0p") foram mantidos.
Eles não permitem opções adicionais e produzirão uma saída com o
formato antigo.


4.1.5. Instalando ambientes de execução
---------------------------------------

   $> py install [-s=|--source=<URL>] [-f|--force] [-u|--update] [--dry-run] [<TAG>...]

Novas versões de ambientes de execução podem ser adicionadas usando
"py install". Uma ou mais tags podem ser especificadas, e a tag
especial "default" pode ser usada para selecionar o padrão. Intervalos
não são suportados para instalação.

A opção "--source=<URL>" permite substituir o índice online usado para
obter ambientes de execução. Isso pode ser usado com um índice
offline, como mostrado em Instalações offline.

Passar "--force" ignorará quaisquer arquivos em cache e removerá
qualquer instalação existente para substituí-la pela especificada.

Passar "--update" substituirá as instalações existentes se a nova
versão for mais recente. Caso contrário, elas serão mantidas. Se
nenhuma tag for fornecida com "--update", todas as instalações
gerenciadas pelo gerenciador de instalação do Python serão atualizadas
se versões mais recentes estiverem disponíveis. As atualizações
removerão quaisquer modificações feitas na instalação, incluindo
pacotes instalados globalmente, mas os ambientes virtuais continuarão
funcionando.

Passar "--dry-run" gerará saída e logs, mas não modificará nenhuma
instalação.

Além das opções acima, a opção "--target" extrairá o ambiente de
execução para o diretório especificado em vez de realizar uma
instalação normal. Isso é útil para incorporar ambientes de aplicação
em aplicações maiores.

   $> py install ... [-t=|--target=<PATH>] <TAG>


4.1.6. Instalações offline
--------------------------

Para executar instalações offline do Python, você precisará primeiro
criar um índice offline em uma máquina que tenha acesso à rede.

   $> py install --download=<PATH> ... <TAG>...

A opção "--download=<PATH>" baixará os pacotes para as tags listadas e
criará um diretório contendo-os e um arquivo "index.json" adequado
para instalação posterior. Todo esse diretório pode ser movido para a
máquina offline e usado para instalar um ou mais dos ambientes de
execução incluídos:

   $> py install --source="<PATH>\index.json" <TAG>...

O gerenciador de instalação do Python pode ser instalado baixando seu
instalador e movendo-o para outra máquina antes da instalação.

Como alternativa, os arquivos ZIP em um diretório de índice offline
podem ser simplesmente transferidos para outra máquina e extraídos.
Isso não registrará a instalação de forma alguma e, portanto, ela deve
ser iniciada referenciando diretamente os executáveis no diretório
extraído, mas às vezes é uma abordagem preferível em casos em que a
instalação do gerenciador de instalação do Python não é possível ou
conveniente.

Dessa forma, os ambientes de execução do Python podem ser instalados e
gerenciados em uma máquina sem acesso à internet.


4.1.7. Desinstalando ambientes de execução
------------------------------------------

   $> py uninstall [-y|--yes] <TAG>...

Ambientes de execução pode ser removidos com o uso do comando "py
uninstall". Uma ou mais tags devem ser especificadas. Não há suporte
para intervalos aqui.

The "--yes" option bypasses the confirmation prompt before
uninstalling.

Em vez de passar as tags individualmente, a opção "--purge" pode ser
especificada. Isso removerá todos os ambientes de execução gerenciados
pelo gerenciador de instalação do Python, incluindo a limpeza do menu
Iniciar, do registro e de quaisquer caches de download. Ambientes de
execução que não foram instalados pelo gerenciador de instalação do
Python não serão afetados, nem os arquivos de configuração criados
manualmente.

   $> py uninstall [-y|--yes] --purge

O gerenciador de instalação do Python pode ser desinstalado por meio
da página de configurações "Aplicativos instalados" do Windows. Isso
não remove nenhum ambiente de execução, e eles ainda poderão ser
usados, embora o "python" global e o comando "py" sejam removidos. A
reinstalação do gerenciador de instalação do Python permitirá que você
gerencie esses ambientes de execução novamente. Para limpar
completamente todos os ambientes de execução do Python, execute o "--
purge" antes de desinstalar o gerenciador de instalação do Python.


4.1.8. Configuração
-------------------

Python install manager is configured with a hierarchy of configuration
files, environment variables, command-line options, and registry
settings. In general, configuration files have the ability to
configure everything, including the location of other configuration
files, while registry settings are administrator-only and will
override configuration files. Command-line options override all other
settings, but not every option is available.

This section will describe the defaults, but be aware that modified or
overridden installs may resolve settings differently.

A global configuration file may be configured by an administrator, and
would be read first. The user configuration file is stored at
"%AppData%\Python\pymanager.json" (by default) and is read next,
overwriting any settings from earlier files. An additional
configuration file may be specified as the "PYTHON_MANAGER_CONFIG"
environment variable or the "--config" command line option (but not
both).

The following settings are those that are considered likely to be
modified in normal use. Later sections list those that are intended
for administrative customization.

-[ Standard configuration options ]-

+-----------------------------------+-----------------------------------+-----------------------------------+
| Config Key                        | Environment Variable              | Descrição                         |
|===================================|===================================|===================================|
| "default_tag"                     | PYTHON_MANAGER_DEFAULT            | The preferred default version to  |
|                                   |                                   | launch or install. By default,    |
|                                   |                                   | this is interpreted as the most   |
|                                   |                                   | recent non-prerelease version     |
|                                   |                                   | from the CPython team.            |
+-----------------------------------+-----------------------------------+-----------------------------------+
| "default_platform"                | "PYTHON_MANAGER_DEFAULT_PLATFORM" | The preferred default platform to |
|                                   |                                   | launch or install. This is        |
|                                   |                                   | treated as a suffix to the        |
|                                   |                                   | specified tag, such that "py      |
|                                   |                                   | -V:3.14" would prefer an install  |
|                                   |                                   | for "3.14-64" if it exists (and   |
|                                   |                                   | "default_platform" is "-64"), but |
|                                   |                                   | will use "3.14" if no tagged      |
|                                   |                                   | install exists.                   |
+-----------------------------------+-----------------------------------+-----------------------------------+
| "logs_dir"                        | "PYTHON_MANAGER_LOGS"             | The location where log files are  |
|                                   |                                   | written. By default, "%TEMP%".    |
+-----------------------------------+-----------------------------------+-----------------------------------+
| "automatic_install"               | "PYTHON_MANAGER_AUTOMATIC_INSTAL  | Verdadeiro para permitir          |
|                                   | L"                                | instalações automáticas ao        |
|                                   |                                   | especificar um ambiente de        |
|                                   |                                   | execução específico para iniciar. |
|                                   |                                   | Por padrão, verdadeiro.           |
+-----------------------------------+-----------------------------------+-----------------------------------+
| "include_unmanaged"               | "PYTHON_MANAGER_INCLUDE_UNMANAGE  | Verdadeiro para permitir a        |
|                                   | D"                                | listagem e a execução de          |
|                                   |                                   | ambientes que não foram           |
|                                   |                                   | instalados pelo gerenciador de    |
|                                   |                                   | instalação do Python, ou falso    |
|                                   |                                   | para excluí-los. Por padrão,      |
|                                   |                                   | verdadeiro.                       |
+-----------------------------------+-----------------------------------+-----------------------------------+
| "shebang_can_run_anything"        | "PYTHON_MANAGER_SHEBANG_CAN_RUN_  | Verdadeiro para permitir que      |
|                                   | ANYTHING"                         | shebangs em arquivos ".py"        |
|                                   |                                   | iniciem aplicação que não sejam   |
|                                   |                                   | ambientes de execução do Python,  |
|                                   |                                   | ou falso para evitar isso. Por    |
|                                   |                                   | padrão, verdadeiro.               |
+-----------------------------------+-----------------------------------+-----------------------------------+
| "log_level"                       | "PYMANAGER_VERBOSE",              | Set the default level of output   |
|                                   | "PYMANAGER_DEBUG"                 | (0-50). By default, 20. Lower     |
|                                   |                                   | values produce more output. The   |
|                                   |                                   | environment variables are         |
|                                   |                                   | boolean, and may produce          |
|                                   |                                   | additional output during startup  |
|                                   |                                   | that is later suppressed by other |
|                                   |                                   | configuration.                    |
+-----------------------------------+-----------------------------------+-----------------------------------+
| "confirm"                         | "PYTHON_MANAGER_CONFIRM"          | True to confirm certain actions   |
|                                   |                                   | before taking them (such as       |
|                                   |                                   | uninstall), or false to skip the  |
|                                   |                                   | confirmation. By default, true.   |
+-----------------------------------+-----------------------------------+-----------------------------------+
| "install.source"                  | "PYTHON_MANAGER_SOURCE_URL"       | Override the index feed to obtain |
|                                   |                                   | new installs from.                |
+-----------------------------------+-----------------------------------+-----------------------------------+
| "list.format"                     | "PYTHON_MANAGER_LIST_FORMAT"      | Specify the default format used   |
|                                   |                                   | by the "py list" command. By      |
|                                   |                                   | default, "table".                 |
+-----------------------------------+-----------------------------------+-----------------------------------+

Dotted names should be nested inside JSON objects, for example,
"list.format" would be specified as "{"list": {"format": "table"}}".


4.1.9. Shebang lines
--------------------

If the first line of a script file starts with "#!", it is known as a
"shebang" line.  Linux and other Unix like operating systems have
native support for such lines and they are commonly used on such
systems to indicate how a script should be executed. The "python" and
"py" commands allow the same facilities to be used with Python scripts
on Windows.

To allow shebang lines in Python scripts to be portable between Unix
and Windows, a number of 'virtual' commands are supported to specify
which interpreter to use.  The supported virtual commands are:

* "/usr/bin/env <ALIAS>"

* "/usr/bin/env -S <ALIAS>"

* "/usr/bin/<ALIAS>"

* "/usr/local/bin/<ALIAS>"

* "<ALIAS>"

Por exemplo, se a primeira linha do seu script começa com

   #! /usr/bin/python

O Python padrão ou um ambiente virtual ativo será localizado e
utilizado. Como muitos scripts Python escritos para funcionar no Unix
já terão essa linha, você deve perceber que esses scripts podem ser
usados pelo inicializador sem modificação. Se você está escrevendo um
novo script no Windows que você espera que seja útil no Unix, você
deve usar uma dessas linhas shebang começando com "/usr".

Qualquer um dos comandos virtuais acima pode ter o "<ALIAS>"
substituído por um apelido de um ambiente de execução instalado. Ou
seja, qualquer comando gerado no diretório global de apelidos (que
você pode ter adicionado à sua variável de ambiente "PATH") pode ser
usado em uma shebang, mesmo que não esteja no seu "PATH". Isso permite
o uso de shebangs como "/usr/bin/python3.12" para selecionar um
determinado ambiente de execução.

Se nenhum ambiente de execução estiver instalado ou se a instalação
automática estiver ativada, o ambiente de execução solicitado será
instalado, se necessário. Consulte Configuração para obter informações
sobre as definições de configuração.

The "/usr/bin/env" form of shebang line will also search the "PATH"
environment variable for unrecognized commands. This corresponds to
the behaviour of the Unix "env" program, which performs the same
search, but prefers launching known Python commands. A warning may be
displayed when searching for arbitrary executables, and this search
may be disabled by the "shebang_can_run_anything" configuration
option.

Shebang lines that do not match any of patterns are treated as
*Windows* executable paths that are absolute or relative to the
directory containing the script file. This is a convenience for
Windows-only scripts, such as those generated by an installer, since
the behavior is not compatible with Unix-style shells. These paths may
be quoted, and may include multiple arguments, after which the path to
the script and any additional arguments will be appended. This
functionality may be disabled by the "shebang_can_run_anything"
configuration option.

Nota:

  The behaviour of shebangs in the Python install manager is subtly
  different from the previous "py.exe" launcher, and the old
  configuration options no longer apply. If you are specifically
  reliant on the old behaviour or configuration, we recommend keeping
  the legacy launcher. It may be downloaded independently and
  installed on its own. The legacy launcher's "py" command will
  override PyManager's one, and you will need to use "pymanager"
  commands for installing and uninstalling.


4.1.10. Advanced Installation
-----------------------------

For situations where an MSIX cannot be installed, such as some older
administrative distribution platforms, there is an MSI available from
the python.org downloads page. This MSI has no user interface, and can
only perform per-machine installs to its default location in Program
Files. It will attempt to modify the system "PATH" environment
variable to include this install location, but be sure to validate
this on your configuration.

Nota:

  Windows Server 2019 is the only version of Windows that CPython
  supports that does not support MSIX. For Windows Server 2019, you
  should use the MSI.

Esteja ciente que o pacote MSI não inclui nenhum ambiente de execução
e, portanto, não é adequado para instalações em ambientes off-line sem
criar também um indíce para instalação off-line. Consulte Instalações
offline e Administrative Configuration para obter informações sobre
como lidar com esses cenários.

Ambientes de execução instalados pelo MSI são compartilhados com os
instalados pelo MSIX e são todos apenas por usuário. O gerenciador de
instalação do Python não permite a instalação de ambientes de execução
por máquina. Para emular uma instalação por máquina, você pode usar o
"py install --target=<shared location>" como administrador e adicionar
suas próprias modificações em todo o sistema ao "PATH", ao registro ou
ao menu Iniciar.

When the MSIX is installed, but commands are not available in the
"PATH" environment variable, they can be found under "%LocalAppData%\
Microsoft\WindowsApps\PythonSoftwareFoundation.PythonManager_3847v3x7
pw1km" or "%LocalAppData%\Microsoft\WindowsApps\PythonSoftwareFoundat
ion.PythonManager_qbz5n2kfra8p0", depending on whether it was
installed from python.org or through the Windows Store. Attempting to
run the executable directly from Program Files is not recommended.

To programmatically install the Python install manager, it is easiest
to use WinGet, which is included with all supported versions of
Windows:

   $> winget install 9NQ7512CXL7T -e --accept-package-agreements --disable-interactivity

   # Optionally run the configuration checker and accept all changes
   $> py install --configure -y

To download the Python install manager and install on another machine,
the following WinGet command will download the required files from the
Store to your Downloads directory (add "-d <location>" to customize
the output location). This also generates a YAML file that appears to
be unnecessary, as the downloaded MSIX can be installed by launching
or using the commands below.

   $> winget download 9NQ7512CXL7T -e --skip-license --accept-package-agreements --accept-source-agreements

To programmatically install or uninstall an MSIX using only
PowerShell, the Add-AppxPackage and Remove-AppxPackage PowerShell
cmdlets are recommended:

   $> Add-AppxPackage C:\Downloads\python-manager-25.0.msix
   ...
   $> Get-AppxPackage PythonSoftwareFoundation.PythonManager | Remove-AppxPackage

The latest release can be downloaded and installed by Windows by
passing the AppInstaller file to the Add-AppxPackage command. This
installs using the MSIX on python.org, and is only recommended for
cases where installing via the Store (interactively or using WinGet)
is not possible.

   $> Add-AppxPackage -AppInstallerFile https://www.python.org/ftp/python/pymanager/pymanager.appinstaller

Other tools and APIs may also be used to provision an MSIX package for
all users on a machine, but Python does not consider this a supported
scenario. We suggest looking into the PowerShell Add-
AppxProvisionedPackage cmdlet, the native Windows PackageManager
class, or the documentation and support for your deployment tool.

Regardless of the install method, users will still need to install
their own copies of Python itself, as there is no way to trigger those
installs without being a logged in user. When using the MSIX, the
latest version of Python will be available for all users to install
without network access.

Note that the MSIX downloadable from the Store and from the Python
website are subtly different and cannot be installed at the same time.
Wherever possible, we suggest using the above WinGet commands to
download the package from the Store to reduce the risk of setting up
conflicting installs. There are no licensing restrictions on the
Python install manager that would prevent using the Store package in
this way.


4.1.11. Administrative Configuration
------------------------------------

There are a number of options that may be useful for administrators to
override configuration of the Python install manager. These can be
used to provide local caching, disable certain shortcut types,
override bundled content. All of the above configuration options may
be set, as well as those below.

Configuration options may be overridden in the registry by setting
values under "HKEY_LOCAL_MACHINE\Software\Policies\Python\PyManager",
where the value name matches the configuration key and the value type
is "REG_SZ". Note that this key can itself be customized, but only by
modifying the core config file distributed with the Python install
manager. We recommend, however, that registry values are used only to
set "base_config" to a JSON file containing the full set of overrides.
Registry key overrides will replace any other configured setting,
while "base_config" allows users to further modify settings they may
need.

Note that most settings with environment variables support those
variables because their default setting specifies the variable. If you
override them, the environment variable will no longer work, unless
you override it with another one. For example, the default value of
"confirm" is literally "%PYTHON_MANAGER_CONFIRM%", which will resolve
the variable at load time. If you override the value to "yes", then
the environment variable will no longer be used. If you override the
value to "%CONFIRM%", then that environment variable will be used
instead.

Configuration settings that are paths are interpreted as relative to
the directory containing the configuration file that specified them.

-[ Administrative configuration options ]-

+----------------------------------------------------+----------------------------------------------------+
| Config Key                                         | Descrição                                          |
|====================================================|====================================================|
| "base_config"                                      | The highest priority configuration file to read.   |
|                                                    | Note that only the built-in configuration file and |
|                                                    | the registry can modify this setting.              |
+----------------------------------------------------+----------------------------------------------------+
| "user_config"                                      | The second configuration file to read.             |
+----------------------------------------------------+----------------------------------------------------+
| "additional_config"                                | The third configuration file to read.              |
+----------------------------------------------------+----------------------------------------------------+
| "registry_override_key"                            | Registry location to check for overrides. Note     |
|                                                    | that only the built-in configuration file can      |
|                                                    | modify this setting.                               |
+----------------------------------------------------+----------------------------------------------------+
| "bundled_dir"                                      | Read-only directory containing locally cached      |
|                                                    | files.                                             |
+----------------------------------------------------+----------------------------------------------------+
| "install.fallback_source"                          | Path or URL to an index to consult when the main   |
|                                                    | index cannot be accessed.                          |
+----------------------------------------------------+----------------------------------------------------+
| "install.enable_shortcut_kinds"                    | Comma-separated list of shortcut kinds to allow    |
|                                                    | (e.g. ""pep514,start""). Enabled shortcuts may     |
|                                                    | still be disabled by "disable_shortcut_kinds".     |
+----------------------------------------------------+----------------------------------------------------+
| "install.disable_shortcut_kinds"                   | Comma-separated list of shortcut kinds to exclude  |
|                                                    | (e.g. ""pep514,start""). Disabled shortcuts are    |
|                                                    | not reactivated by "enable_shortcut_kinds".        |
+----------------------------------------------------+----------------------------------------------------+
| "pep514_root"                                      | Registry location to read and write PEP 514        |
|                                                    | entries into. By default,                          |
|                                                    | "HKEY_CURRENT_USER\Software\Python".               |
+----------------------------------------------------+----------------------------------------------------+
| "start_folder"                                     | Start menu folder to write shortcuts into. By      |
|                                                    | default, "Python". This path is relative to the    |
|                                                    | user's Programs folder.                            |
+----------------------------------------------------+----------------------------------------------------+
| "virtual_env"                                      | Path to the active virtual environment. By         |
|                                                    | default, this is "%VIRTUAL_ENV%", but may be set   |
|                                                    | empty to disable venv detection.                   |
+----------------------------------------------------+----------------------------------------------------+
| "shebang_can_run_anything_silently"                | Verdadeiro para suprimir avisos visíveis quando um |
|                                                    | shebang executa uma aplicação que não seja um      |
|                                                    | ambiente de execução Python.                       |
+----------------------------------------------------+----------------------------------------------------+


4.1.12. Instalando binários com threads livres
----------------------------------------------

Adicionado na versão 3.13: (Experimental)

Nota:

  Tudo descrito nesta seção é considerado experimental e espera-se que
  mude em versões futuras.

Pre-built distributions of the experimental free-threaded build are
available by installing tags with the "t" suffix.

   $> py install 3.14t
   $> py install 3.14t-arm64
   $> py install 3.14t-32

Ele será instalado e registrado normalmente. Se você não tiver outro
ambiente de execução instalado, "python" iniciará este. Caso
contrário, você precisará usar "py -V:3.14t ..." ou, se tiver
adicionado o diretório global de apelidos à sua variável de ambiente
"PATH", o comando "python3.14t.exe".


4.1.13. Troubleshooting
-----------------------

If your Python install manager does not seem to be working correctly,
please work through these tests and fixes to see if it helps. If not,
please report an issue at our bug tracker, including any relevant log
files (written to your "%TEMP%" directory by default).

-[ Troubleshooting ]-

+----------------------------------------------------+----------------------------------------------------+
| Symptom                                            | Things to try                                      |
|====================================================|====================================================|
| "python" gives me a "command not found" error or   | Did you install the Python install manager?        |
| opens the Store app when I type it in my terminal. |                                                    |
+----------------------------------------------------+----------------------------------------------------+
|                                                    | Click Start, open "Manage app execution aliases",  |
|                                                    | and check that the aliases for "Python (default)"  |
|                                                    | are enabled. If they already are, try disabling    |
|                                                    | and re-enabling to refresh the command. The        |
|                                                    | "Python (default windowed)" and "Python install    |
|                                                    | manager" commands may also need refreshing.        |
+----------------------------------------------------+----------------------------------------------------+
|                                                    | Check that the "py" and "pymanager" commands work. |
+----------------------------------------------------+----------------------------------------------------+
| "py" gives me a "command not found" error when I   | Did you install the Python install manager?        |
| type it in my terminal.                            |                                                    |
+----------------------------------------------------+----------------------------------------------------+
|                                                    | Click Start, open "Manage app execution aliases",  |
|                                                    | and check that the aliases for "Python (default)"  |
|                                                    | are enabled. If they already are, try disabling    |
|                                                    | and re-enabling to refresh the command. The        |
|                                                    | "Python (default windowed)" and "Python install    |
|                                                    | manager" commands may also need refreshing.        |
+----------------------------------------------------+----------------------------------------------------+
| "py" gives me a "can't open file" error when I     | This usually means you have the legacy launcher    |
| type commands in my terminal.                      | installed and it has priority over the Python      |
|                                                    | install manager. To remove, click Start, open      |
|                                                    | "Installed apps", search for "Python launcher" and |
|                                                    | uninstall it.                                      |
+----------------------------------------------------+----------------------------------------------------+
| "python" não inicia o mesmo ambiente de execução   | Clique em Iniciar, abra "Aplicativos instalados",  |
| que "py"                                           | procure por qualquer ambiente de execução do       |
|                                                    | Python existente e remova-o ou modifique e         |
|                                                    | desative as opções de "PATH".                      |
+----------------------------------------------------+----------------------------------------------------+
|                                                    | Click Start, open "Manage app execution aliases",  |
|                                                    | and check that your "python.exe" alias is set to   |
|                                                    | "Python (default)"                                 |
+----------------------------------------------------+----------------------------------------------------+
| "python" e "py" não iniciam o ambiente de execução | Check your "PYTHON_MANAGER_DEFAULT" environment    |
| que eu esperava                                    | variable or "default_tag" configuration. The "py   |
|                                                    | list" command will show your default based on      |
|                                                    | these settings.                                    |
+----------------------------------------------------+----------------------------------------------------+
|                                                    | As instalações gerenciadas pelo gerenciador de     |
|                                                    | instalação do Python serão escolhidas antes das    |
|                                                    | instalações não gerenciadas. Use "py install" para |
|                                                    | instalar o ambiente de execução que você espera ou |
|                                                    | configure sua tag padrão.                          |
+----------------------------------------------------+----------------------------------------------------+
|                                                    | As instalações de pré-lançamento e experimentais   |
|                                                    | que não são gerenciadas pelo gerenciador de        |
|                                                    | instalação Python podem ser escolhidas antes das   |
|                                                    | instalações estáveis. Configure sua tag padrão ou  |
|                                                    | desinstale a versão do ambiente de execução de     |
|                                                    | pré-lançamento e reinstale usando "py install".    |
+----------------------------------------------------+----------------------------------------------------+
| "pythonw" ou "pyw" não iniciam o mesmo ambiente de | Click Start, open "Manage app execution aliases",  |
| execução que "python" ou "py"                      | and check that your "pythonw.exe" and "pyw.exe"    |
|                                                    | aliases are consistent with your others.           |
+----------------------------------------------------+----------------------------------------------------+
| "pip" gives me a "command not found" error when I  | Have you activated a virtual environment? Run the  |
| type it in my terminal.                            | ".venv\Scripts\activate" script in your terminal   |
|                                                    | to activate.                                       |
+----------------------------------------------------+----------------------------------------------------+
|                                                    | O pacote pode estar disponível, mas sem o          |
|                                                    | executável gerado. Recomendamos usar o comando     |
|                                                    | "python -m pip" ou, alternativamente, "python -m   |
|                                                    | pip install --force pip" recriará os executáveis e |
|                                                    | mostrará o caminho a ser adicionado ao "PATH".     |
|                                                    | Esses scripts são separados para cada ambiente de  |
|                                                    | execução e, portanto, talvez seja necessário       |
|                                                    | adicionar vários caminhos.                         |
+----------------------------------------------------+----------------------------------------------------+


4.2. O pacote embutível
=======================

Adicionado na versão 3.5.

A distribuição embutida é um arquivo ZIP contendo um ambiente Python
mínimo. Ela foi criada para atuar como parte de outra aplicação, ao
invés de ser diretamente acessada por usuários finais.

To install an embedded distribution, we recommend using "py install"
with the "--target" option:

   $> py install 3.14-embed --target=runtime

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

A default "._pth" file is included, which further restricts the
default search paths (as described below in Encontrando módulos). This
file is intended for embedders to modify as necessary.

Pacotes de terceiros devem ser instalados pelo instalador da aplicação
juntamente com a distribuição embutida. Usar o pip para gerenciar as
dependências como em uma instalação regular do Python não é suportado
nessa distribuição, apesar de que com algum cuidado pode ser possível
incluir e usar o pip para atualizações automáticas. Em geral, pacotes
de terceiros devem ser tratados como parte da aplicação ("vendoring")
para que o desenvolvedor consiga garantir compatibilidade com versões
mais recentes antes de fornecer atualizações para os usuários.

Os dois casos de uso recomendados para essa distribuição são descritos
abaixo.


4.2.1. Aplicação Python
-----------------------

Uma aplicação escrita em Python não requer necessariamente que os
usuários estejam cientes deste fato. A distribuição embutida pode ser
usada neste caso para incluir uma versão privada do pacote de
instalação do Python. Dependendo de quão transparente deve ser (ou
pelo contrário, quão profissional deve parecer), existem duas opções.

Usar um executável especializado como inicializador requer um pouco de
código, mas fornece a experiência mais transparente para os usuários.
Com um inicializador personalizado, não existem indicações óbvias que
o programa está rodando em Python: ícones podem ser personalizados,
informações da empresa e versão podem ser especificadas, e associações
de arquivo se comportam de forma apropriada. Na maioria dos casos, um
inicializador personalizado deve simplesmente ser capaz de chamar
"Py_Main" com uma linha de comando predefinida (hard-coded).

A abordagem mais simples é fornecer um arquivo batch ou um atalho
gerado que chama diretamente o "python.exe" ou "pythonw.exe" com os
argumentos de linha de comando necessários. Neste caso, a aplicação
irá aparecer como Python e não seu nome real, e os usuários podem ter
problemas em distinguir ela de outros processos ou associações de
arquivo em Python.

Com a abordagem anterior, pacotes devem ser instalados como diretórios
juntamente do executável do Python para garantir que estarão
disponíveis no caminho do ambiente. Com o instalador especializado,
pacotes podem ser armazenados em outras localidades já que há uma
oportunidade de especificar o caminho de busca antes de executar a
aplicação.


4.2.2. Incorporando Python
--------------------------

Aplicações escritas em código nativo frequentemente precisam de alguma
forma de linguagem de script, e a distribuição embutida do Python pode
ser usada para esse propósito. Em geral, a maior parte da aplicação é
em código nativo, e uma parte irá ou invocar "python.exe" ou usar
diretamente "python3.dll". Para ambos os casos, extrair a distribuição
embutida em um subdiretório da instalação da aplicação é suficiente
para providenciar um interpretador Python carregável.

Para uso da aplicação, pacotes podem ser instalados em qualquer local
já que há uma oportunidade de especificar caminhos de busca antes de
inicializar o interpretador. De outra forma, não existem diferenças
fundamentais entre usar a distribuição embutida ou a instalação
regular.


4.3. Os pacotes nuget.org
=========================

Adicionado na versão 3.5.2.

O pacote nuget.org é um ambiente Python de tamanho reduzido criado
para uso em integração contínua e construção de sistemas que não
precisam de uma instalação de Python por todo o sistema da máquina.
Enquanto nuget é o "gerenciador de pacotes para .NET", ele também
funciona perfeitamente bem para pacotes contendo ferramentas em tempo
de construção.

Visite nuget.org para informações mais atualizadas sobre utilização do
nuget. A seguir está um sumário que é suficiente para desenvolvedores
Python.

A ferramenta de linha de comando "nuget.exe" pode ser baixada
diretamente de "https://aka.ms/nugetclidl", por exemplo, usando o curl
ou PowerShell. Com a ferramenta, a versão mais recente do Python para
máquinas 64-bit ou 32-bit é instalada usando:

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

Para selecionar uma versão específica, adicione "-Version 3.x.y". O
diretório de saída pode ser mudado de ".", e o pacote será instalado
em um subdiretório. Por padrão, o subdiretório é nomeado igual ao
pacote, e sem a opção "-ExcludeVersion" esse nome irá incluir a versão
específica instalada. Dentro do subdiretório está um diretório "tools"
que contém a instalação do Python:

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

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

Em geral, pacotes nuget não são atualizáveis, e novas versões devem
ser instaladas lado-a-lado e referenciadas usando o caminho completo.
Alternativamente, delete o diretório do pacote manualmente e instale
novamente. Muitos sistemas CI irão fazer isso automaticamente se eles
não preservam arquivos entre construções de projetos.

Juntamente com o diretório "tools" está o diretório "build\native".
Ele contém um arquivo de propriedades MSBuild "python.props" que pode
ser usado em um projeto C++ para referenciar a instalação do Python.
Incluir as configurações irá automaticamente usar os cabeçalhos e
importar as bibliotecas na sua construção de projeto.

As páginas de informação dos pacotes em nuget.org são
www.nuget.org/packages/python para a versão 64 bits,
www.nuget.org/packages/pythonx86 para a versão 32 bits e
www.nuget.org/packages/pythonarm64 para a versão ARM64


4.3.1. Pacotes com threads livres
---------------------------------

Adicionado na versão 3.13: (Experimental)

Nota:

  Tudo descrito nesta seção é considerado experimental e espera-se que
  mude em versões futuras.

Pacotes contendo binários com threads livres são chamados python-
freethreaded para a versão de 64 bits, pythonx86-freethreaded para a
versão de 32 bits e pythonarm64-freethreaded para a versão ARM64.
Esses dois pacotes contêm os pontos de entrada "python3.13t.exe" e
"python.exe", os quais são executados com threads livres.


4.4. Pacotes Alternativos
=========================

À parte da distribuição padrão CPython, existem pacotes modificados
incluindo funcionalidades adicionais. A seguir está uma lista de
versões populares e seus recursos chave:

ActivePython
   Instalador com compatibilidade multi-plataforma, documentação,
   PyWin32

Anaconda
   Módulos científicos populares (como o numpy, scipy e pandas) e o
   gerenciador de pacotes "conda".

Enthought Deployment Manager
   "A próxima geração de ambiente Python e gerenciador de pacotes".

   Anteriormente, a Enthought fornecia Canopy, mas este chegou ao fim
   de vida em 2016.

WinPython
   Distribuição específica do Windows com pacotes científicos
   pré-construídos e ferramentas para construir pacotes.

Note que esses pacotes podem não incluir as últimas versões do Python
ou outras bibliotecas, e não são mantidos ou suportados pelo time do
núcleo do Python.


4.5. Supported Windows versions
===============================

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


4.6. Removendo a Limitação do MAX_PATH
======================================

O Windows historicamente tem limitado os comprimentos dos caminhos de
arquivos em 260 caracteres. Isso significava que caminhos maiores que
isso não seriam resolvidos e resultariam em erros.

In the latest versions of Windows, this limitation can be expanded to
over 32,000 characters. Your administrator will need to activate the
"Enable Win32 long paths" group policy, or set "LongPathsEnabled" to
"1" in the registry key
"HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\FileSystem".

Isso permite que a função "open()", o módulo "os" e a maior parte das
outras funcionalidades de caminho aceitem e retornem caminhos maiores
que 260 caracteres quando usando strings.

After changing the above option and rebooting, no further
configuration is required.


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

Adicionado na versão 3.7.

O Windows ainda usa codificações legadas para a codificação do sistema
(a Página de Código ANSI). O Python usa-o para a codificação padrão de
arquivos de texto (por exemplo, "locale.getencoding()").

Isso pode causar problemas, porque o UTF-8 é amplamente usado na
Internet e na maioria dos sistemas Unix, incluindo o WSL (Subsistema
Windows para Linux).

Você pode usar o Modo UTF-8 do Python para alterar a codificação de
texto padrão para UTF-8. Você pode habilitar Modo UTF-8 do Python
através da opção de linha de comando "-X utf8" ou da variável de
ambiente "PYTHONUTF8=1". Veja "PYTHONUTF8" para habilitar o modo
UTF-8, e Gerenciador de instalação do Python para saber como modificar
variáveis de ambiente.

Quando o Modo UTF-8 do Python está habilitado, você ainda pode usar a
codificação do sistema (a página de código ANSI) através do codec
"mbcs".

Observe que adicionar "PYTHONUTF8=1" às variáveis de ambiente padrão
afetará todas as aplicações Python 3.7+ em seu sistema. Se você tiver
aplicações Python 3.7+ que dependem da codificação do sistema legado,
é recomendável definir a variável de ambiente temporariamente ou usar
a opção de linha de comando "-X utf8".

Nota:

  Mesmo quando o modo UTF-8 está desativado, o Python usa o UTF-8 por
  padrão no Windows para:

  * E/S do console, incluindo E/S padrão (consulte **PEP 528** para
    detalhes).

  * A *codificação do sistema de arquivos* (veja a **PEP 529** para
    detalhes).


4.8. Encontrando módulos
========================

Estas notas complementam a descrição em A inicialização do caminho de
pesquisa de módulos sys.path com notas detalhadas do Windows.

Quando nenhum arquivo "._pth" é encontrado, assim é como "sys.path" é
populado no Windows:

* Uma entrada em branco é adicionada ao início, que corresponde ao
  diretório atual.

* Se a variável de ambiente "PYTHONPATH" existe, como descrito em
  Variáveis de ambiente, suas entradas são adicionadas em seguida.
  Note que no Windows, caminhos nessa variável devem ser separados por
  ponto e vírgula, para distinguir eles dos dois pontos usados nos
  identificadores de drivers ("C:\" etc.).

* "Caminhos da aplicação" adicionais podem ser adicionados ao registro
  como subchaves de "\SOFTWARE\Python\PythonCore{version}\PythonPath"
  sob ambas "HKEY_CURRENT_USER" e "HKEY_LOCAL_MACHINE". Subchaves que
  possuem string de caminhos delimitados por ponto e vírgula como seu
  valor padrão farão com que cada caminho seja adicionado ao
  "sys.path". (Note que todos os instaladores conhecidos usam apenas
  HKLM, portanto HKCU está tipicamente vazio.)

* Se a variável de ambiente "PYTHONHOME" está definida, ela é
  presumida como "Python Home". Caso contrário, o caminho do principal
  executável do Python é usado para localizar um "arquivo de
  referência" (ou "Lib\os.py" ou "pythonXY.zip") para deduzir o
  "Python Home". Se um Python Home é encontrado, os subdiretórios
  relevantes adicionados ao "sys.path" ("Lib", "plat-win", etc) são
  baseados naquela pasta. Se não, o caminho núcleo do Python é
  construído a partir do PythonPath armazenado no registro.

* Se o Python Home não puder ser localizado, nenhum "PYTHONPATH" está
  especificado no ambiente, e nenhuma entrada de registro pôde ser
  encontrada, um caminho padrão com entradas relativas é usado (por
  exemplo, ".\Lib;.\plat-win", etc).

Se um arquivo "pyvenv.cfg" for encontrado juntamente com o principal
executável ou no diretório um nível acima do executável, as seguintes
variações se aplicam:

* Se "home" é um caminho absoluto e "PYTHONHOME" não está definido, o
  caminho é usado ao invés do caminho ao principal executável quando
  deduzindo a localização do Home.

O resultado final de tudo isso é:

* Quando executando "python.exe", ou qualquer outro .exe no diretório
  principal do Python (ou uma versão instalada, ou diretamente do
  diretório PCbuild), o caminho núcleo é deduzido, e os caminhos
  núcleo no registro são ignorados. Outros "caminhos da aplicação" no
  registro são sempre lidos.

* Quando Python é hospedado em outro .exe (diretório diferente,
  embutido via COM, etc), o "Python Home" não será deduzido, então o
  caminho núcleo do registro é usado. Outros "caminhos da aplicação"
  no registro sempre são lidos.

* Se o Python não puder encontrar seu Home e não existem valores no
  registro (.exe imutáveis, algumas configurações de instalação bem
  estranhas) você recebe um caminho com alguns caminhos padrão, porém
  relativos.

Para aqueles que querem empacotar o Python em suas aplicações ou
distribuições, o seguinte conselho irá prevenir conflitos com outras
instalações:

* Inclua um arquivo "._pth" juntamente do executável contendo os
  diretórios a serem incluídos. Isso irá ignorar caminhos listados no
  registro e variáveis de ambiente, e também ignorar "sites" a não ser
  que "import site" seja listado.

* Se você estiver carregando "python3.dll" ou "python37.dll" em seu
  próprio executável, defina explicitamente
  "PyConfig.module_search_paths" antes de "Py_InitializeFromConfig()".

* Limpe e/ou sobrescreva "PYTHONPATH" e defina "PYTHONHOME" antes de
  iniciar o "python.exe" a partir da sua aplicação.

* Se você não puder usar as sugestões anteriores (por exemplo, você é
  uma distribuição que permite que as pessoas executem o arquivo
  "python.exe" diretamente), certifique-se de que o arquivo de
  referência ("Lib\os.py") existe no seu diretório de instalação.
  (Note que ele não será detectado dentro de um arquivo ZIP, mas um
  arquivo ZIP corretamente nomeado será detectado ao invés disso.)

Isso irá garantir que seus arquivos em uma instalação global no
sistema não terão precedência sobre uma cópia da biblioteca padrão
empacotada com a sua aplicação. Caso contrário, seus usuários podem
experienciar problemas usando sua aplicação. Note que a primeira
sugestão é a melhor, pois as outras podem ainda estar suscetíveis a
caminhos não-padrão no registro e no site-packages do usuário.

Alterado na versão 3.6: Adiciona suporte a arquivos "._pth" e remove a
opção "applocal" do "pyvenv.cfg".

Alterado na versão 3.6: Adiciona "python*XX*.zip" como uma possível
referência quando diretamente adjacente ao executável.

Descontinuado desde a versão 3.6: Módulos especificados no registro
sob "Modules" (não "PythonPath") podem ser importados por
"importlib.machinery.WindowsRegistryFinder". Este localizador está
ativo no Windows no 3.6.0 e anteriores, mas pode precisar ser
explicitamente adicionado ao "sys.meta_path" no futuro.


4.9. Módulos adicionais
=======================

Mesmo que o Python tenha como objetivo ser portável através de todas
as plataformas, existem recursos que são únicos para o Windows. Alguns
módulos, em ambas as bibliotecas padrão e externa, e trechos de código
existem para usar esses recursos.

Os módulos padrão específicos para Windows estão documentados em
Serviços Específicos do MS Windows.


4.9.1. PyWin32
--------------

O módulo PyWin32 de Mark Hammond é uma coleção de módulos para suporte
avançado específico para Windows. Isso inclui utilitários para:

* Component Object Model (COM)

* Chamadas à API Win32

* Registro

* Log de Eventos

* Interfaces de usuário Microsoft Foundation Classes (MFC)

PythonWin é uma aplicação MFC de exemplo enviada com o PyWin32. É uma
IDE embutível com um depurador embutido.

Ver também:

  Win32 How Do I...?
     por Tim Golden

  Python e COM
     by David and Paul Boddie


4.9.2. cx_Freeze
----------------

cx_Freeze encapsula scripts Python em programas executáveis do Windows
(arquivos "***.exe"). Quando você tiver feito isso, você pode
distribuir sua aplicação sem solicitar que os seus usuários instalem o
Python.


4.10. Compilando Python no Windows
==================================

Se você quer compilar o CPython por conta própria, a primeira coisa
que você precisa ter é a fonte. Você pode fazer o download tanto da
fonte da última versão quanto pegar um novo checkout.

A árvore de fontes contém uma solução de construção e arquivos de
projeto para o Microsoft Visual Studio, que é o compilador usado para
construir as versões do Python oficiais. Esses arquivos estão no
diretório "PCbuild".

Confira o "PCbuild/readme.txt" para informações gerais sobre o
processo de construção.

Para módulos de extensão, consulte Construindo Extensões C e C++ no
Windows.


4.11. The full installer (deprecated)
=====================================

Descontinuado desde a versão 3.14: This installer is deprecated since
3.14 and will not be produced for Python 3.16 or later. See
Gerenciador de instalação do Python for the modern installer.


4.11.1. Etapas de instalação
----------------------------

Quatro instaladores Python 3.14 estão disponíveis para download - dois
de cada para as versões 32-bit e 64-bit do interpretador. O
*instalador web* é um download inicial menor, e ele irá
automaticamente fazer o download dos componentes solicitados na medida
do necessário. O *instalador offline* inclui os componentes
necessários para uma instalação padrão e requer apenas uma conexão de
internet para recursos opcionais. Veja Instalando Sem Download para
outras formas de evitar o download durante a instalação.

Após iniciar o instalador, uma de duas opções deve ser selecionada:

[imagem]

Se você selecionar "Install Now":

* Você *não* precisará ser um administrador (a menos que uma
  atualização de sistema para a Biblioteca em Tempo de Execução C seja
  necessária ou que você instale o Gerenciador de instalação do Python
  para todos os usuários)

* Python será instalado dentro do seu diretório de usuário

* O Gerenciador de instalação do Python será instalado de acordo com a
  opção ao final da primeira página

* A biblioteca padrão, a suíte de testes, o inicializador e o pip
  serão instalados

* Se selecionado, o diretório de instalação será adicionado no seu
  "PATH"

* Atalhos serão visíveis apenas para o usuário atual

Selecionando "Customize installation" irá permitir que você selecione
os recursos a serem instalados, o local da instalação e outras opções
ou ações pós-instalação. Para instalar símbolos de depuração ou
binários, você precisará usar essa opção.

Para realizar uma instalação para todos os usuários, você deve
selecionar "Customize installation". Neste caso:

* Você pode ser solicitado a providenciar credenciais administrativas
  ou aprovação

* Python será instalado dentro do diretório Program Files (Arquivos de
  Programa)

* O Gerenciador de instalação do Python será instalado dentro do
  diretório Windows

* Recursos opcionais podem ser selecionados durante a instalação

* A biblioteca padrão pode ser pré-compilada em bytecode

* Se selecionado, o diretório de instalação será adicionado ao "PATH"
  do sistema

* Atalhos estão disponíveis para todos os usuários


4.11.2. Removendo a Limitação do MAX_PATH
-----------------------------------------

O Windows historicamente tem limitado os comprimentos dos caminhos de
arquivos em 260 caracteres. Isso significava que caminhos maiores que
isso não seriam resolvidos e resultariam em erros.

Nas últimas versões do Windows, essa limitação pode ser expandida para
aproximadamente 32.000 caracteres. Seu administrador irá precisar
ativar a política de grupo "Enable Win32 long paths", ou definir
"LongPathsEnabled" para "1" na chave de registro
"HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\FileSystem".

Isso permite que a função "open()", o módulo "os" e a maior parte das
outras funcionalidades de caminho aceitem e retornem caminhos maiores
que 260 caracteres quando usando strings.

Após alterar a opção acima, nenhuma configuração adicional é
necessária.

Alterado na versão 3.6: Suporte para caminhos longos foi ativado no
Python.


4.11.3. Instalando sem UI
-------------------------

Todas as opções disponíveis na IU do instalador também podem ser
especificadas a partir da linha de comando, permitindo que
instaladores por script repliquem uma instalação em várias máquinas
sem interação do usuário. Essas opções também podem ser definidas sem
suprimir a IU para alterar alguns dos padrões.

As seguintes opções (encontradas executando o instalador com "/?")
podem ser passadas para o instalador:

+-----------------------+----------------------------------------------------------+
| Nome                  | Descrição                                                |
|=======================|==========================================================|
| /passive              | para exibir o progresso sem exigir interação do usuário  |
+-----------------------+----------------------------------------------------------+
| /quiet                | para instalar/desinstalar sem exibir nenhuma UI          |
+-----------------------+----------------------------------------------------------+
| /simple               | para evitar a personalização do usuário                  |
+-----------------------+----------------------------------------------------------+
| /uninstall            | para remover o Python (sem exigir confirmação)           |
+-----------------------+----------------------------------------------------------+
| /layout [diretório]   | para pré-baixar todos os componentes                     |
+-----------------------+----------------------------------------------------------+
| /log [nome-de-        | para especificar a localização dos arquivos de log       |
| arquivo]              |                                                          |
+-----------------------+----------------------------------------------------------+

Todas as outras opções são passadas como "name=value", onde o valor é
usualmente "0" para desabilitar o recurso, "1" para ativar o recurso,
ou um caminho. A lista completa de opções disponíveis é mostrada
abaixo.

+-----------------------------+----------------------------------------+----------------------------+
| Nome                        | Descrição                              | Default (padrão)           |
|=============================|========================================|============================|
| InstallAllUsers (Instalar   | Execute uma instalação em todo o       | 0                          |
| para Todos usuários)        | sistema.                               |                            |
+-----------------------------+----------------------------------------+----------------------------+
| TargetDir (Diretório Alvo)  | O diretório de instalação              | Selecionado com base em    |
|                             |                                        | "Instalar para Todos os    |
|                             |                                        | Usuários"                  |
+-----------------------------+----------------------------------------+----------------------------+
| DefaultAllUsersTargetDir    | O diretório de instalação padrão para  | "%ProgramFiles%\Python     |
| (Diretório de Destino       | instalações de todos os usuários       | X.Y" or "%ProgramFiles(x8  |
| Padrão para Todos os        |                                        | 6)%\Python X.Y"            |
| usuários)                   |                                        |                            |
+-----------------------------+----------------------------------------+----------------------------+
| DefaultJustForMeTargetDir   | O diretório de instalação padrão para  | "%LocalAppData%\Programs\  |
| (Diretório Alvo Padrão      | instalações just-for-me                | Python\PythonXY" ou "%Loc  |
| Apenas Para Mim)            |                                        | alAppData%\Programs\Pytho  |
|                             |                                        | n\PythonXY-32" ou "%Local  |
|                             |                                        | AppData%\Programs\Python\  |
|                             |                                        | PythonXY-64"               |
+-----------------------------+----------------------------------------+----------------------------+
| DefaultCustomTargetDir      | Diretório de instalação personalizado  | (vazio)                    |
| (Diretório de destino       | padrão exibido na interface do usuário |                            |
| personalizado padrão)       |                                        |                            |
+-----------------------------+----------------------------------------+----------------------------+
| AssociateFiles (Arquivos    | Criar associações de arquivos se o     | 1                          |
| Associados)                 | launcher também estiver instalado.     |                            |
+-----------------------------+----------------------------------------+----------------------------+
| CompileAll (Compilar Tudo)  | Compile todos os arquivos ".py" para   | 0                          |
|                             | ".pyc".                                |                            |
+-----------------------------+----------------------------------------+----------------------------+
| PrependPath (path a ser     | Anexa os diretórios de instalação e    | 0                          |
| percorrido)                 | Scripts ao início de "PATH" e adiciona |                            |
|                             | ".PY" a "PATHEXT"                      |                            |
+-----------------------------+----------------------------------------+----------------------------+
| AppendPath                  | Anexa os diretórios de instalação e    | 0                          |
|                             | Scripts ao final de "PATH" e adiciona  |                            |
|                             | ".PY" a "PATHEXT"                      |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Shortcuts (atalhos)         | Crie atalhos para o interpretador,     | 1                          |
|                             | documentação e IDLE se instalado.      |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Include_doc                 | Install Python manual (Instalação      | 1                          |
|                             | Manual do Python)                      |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Include_debug (Incluir o    | Instalar binários de Depuração         | 0                          |
| Modo de Depuração)          |                                        |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Include_dev                 | Instala cabeçalhos e bibliotecas do    | 1                          |
|                             | desenvolvedor. Omitir isso pode levar  |                            |
|                             | a uma instalação inutilizável.         |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Include_exe                 | Instala "python.exe" e arquivos        | 1                          |
|                             | relacionados. Omitir isso pode levar a |                            |
|                             | uma instalação inutilizável.           |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Include_launcher            | Instalar Gerenciador de instalação do  | 1                          |
|                             | Python.                                |                            |
+-----------------------------+----------------------------------------+----------------------------+
| InstallLauncherAllUsers     | Instala o iniciador para todos os      | 1                          |
|                             | usuários. Também requer                |                            |
|                             | "Include_launcher" para ser definido   |                            |
|                             | como 1                                 |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Include_lib                 | Instala a biblioteca padrão e os       | 1                          |
|                             | módulos de extensão. Omitir isso pode  |                            |
|                             | levar a uma instalação inutilizável.   |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Include_pip                 | Instale o pacote pip e setuptools      | 1                          |
+-----------------------------+----------------------------------------+----------------------------+
| Include_symbols             | Instala símbolos de depuração          | 0                          |
|                             | ("*.pdb")                              |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Include_tcltk               | Instale o suporte Tcl/Tk e o IDLE      | 1                          |
+-----------------------------+----------------------------------------+----------------------------+
| Include_test                | Instalar o conjunto de testes da       | 1                          |
|                             | biblioteca padrão                      |                            |
+-----------------------------+----------------------------------------+----------------------------+
| Include_tools               | Instalar scripts com utilitários       | 1                          |
+-----------------------------+----------------------------------------+----------------------------+
| LauncherOnly                | Instala apenas o launcher. Isso        | 0                          |
|                             | substituirá a maioria das outras       |                            |
|                             | opções.                                |                            |
+-----------------------------+----------------------------------------+----------------------------+
| SimpleInstall               | Desativar a maioria das UIs de         | 0                          |
|                             | instalação                             |                            |
+-----------------------------+----------------------------------------+----------------------------+
| SimpleInstallDescription    | Uma mensagem personalizada para exibir | (vazio)                    |
|                             | quando a IU de instalação simplificada |                            |
|                             | é usada.                               |                            |
+-----------------------------+----------------------------------------+----------------------------+

Por exemplo, para instalar silenciosamente uma instalação de Python
padrão e em todo o sistema, você pode usar o seguinte comando (a
partir de um terminal de comando autorizado):

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

Para permitir que usuários instalem facilmente uma cópia do Python sem
a suíte de testes, você pode fornecer um atalho com o seguinte
comando. Isso irá exibir uma página inicial simplificado e bloquear a
personalização:

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

(Observe que omitir o inicializador também omite associações de
arquivos, e só é recomendado para instalações por usuários quando
também existe uma instalação por todo o sistema que inclui o
inicializador.)

As opções listadas acima também podem ser fornecidas em um arquivo
chamado "unattend.xml" juntamente com o executável. Esse arquivo
especifica uma lista de opções e valores. Quando um valor é fornecido
como um atributo, ele será convertido para um número se possível.
Valores fornecidos como elementos de texto são sempre deixados como
strings. Esse arquivo de exemplo define as mesmas opções que o exemplo
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.11.4. Instalando Sem Download
-------------------------------

Como alguns recursos do Python não estão inclusos no download inicial
do instalador, selecionar esses recursos pode exigir uma conexão com a
internet. Para evitar isso, todos os possíveis componentes podem ser
baixados sob demanda para criar um *layout* completo que não irá
precisar de uma conexão de internet independentemente dos recursos
selecionados. Note que este download pode ser maior que o necessário,
mas onde um grande número de instalações serão realizadas é bem útil
ter uma cópia em cache local.

Execute o seguinte comando a partir do Prompt de Comando para fazer o
download de todos os possíveis arquivos necessários. Lembre-se de
substituir "python-3.9.0.exe" pelo nome real do seu instalador, e de
criar layouts nos respectivos diretórios para evitar colisão entre
arquivos com o mesmo nome.

   python-3.9.0.exe /layout [diretório alvo opcional]

Você também pode especificar a opção "/quiet" para esconder o
acompanhamento de progresso.


4.11.5. Modificando uma instalação
----------------------------------

Uma vez que o Python foi instalado, você pode adicionar ou remover
recursos através da ferramenta Programas e Recursos que é parte do
Windows. Selecione o registro do Python e escolha "Uninstall/Change"
para abrir o instalador no modo de manutenção.

"Modify" permite que você adicione ou remova recursos modificando as
caixas de entrada - caixas de entrada não modificadas não irão
instalar ou remover nada. Algumas opções não podem ser modificadas
dessa forma, como o diretório de instalação; para modificá-las, você
precisará remover e então reinstalar o Python completamente.

"Repair" irá verificar todos os arquivos que devem ser instalados
usando as configurações atuais e substituir qualquer um que tiver sido
removido ou modificado.

"Uninstall" irá remover o Python completamente, com a exceção do
Gerenciador de instalação do Python, que tem seu próprio registro nos
Programas e Recursos.


4.11.6. Instalando binários com threads livres
----------------------------------------------

Adicionado na versão 3.13: (Experimental)

Nota:

  Tudo descrito nesta seção é considerado experimental e espera-se que
  mude em versões futuras.

Para instalar binários pré-construídos com recurso de threads livres
habilitado (veja **PEP 703**), você deve selecionar "Customize
installation" (Instalação personalizada). A segunda página de opções
inclui a caixa de seleção "Download free-threaded binaries" (Baixar
binários de threads livres).

[imagem]

Selecionar esta opção fará o download e instalará binários adicionais
no mesmo local da instalação principal do Python. O executável
principal é chamado "python3.13t.exe", e outros binários recebem um
sufixo "t" ou um sufixo ABI completo. Arquivos de origem do Python e
dependências de terceiros empacotadas são compartilhadas com a
instalação principal.

A versão com threads livres é registrada como uma instalação regular
do Python com a tag "3.13t" (com um sufixo "-32" ou "-arm64" como
normal para essas plataformas). Isso permite que as ferramentas o
descubram e que o Gerenciador de instalação do Python ofereça suporte
a "py.exe -3.13t". Observe que o inicializador interpretará "py.exe
-3" (ou um shebang "python3") como "a instalação 3.x mais recente",
que preferirá os binários com threads livres aos normais, enquanto
"py.exe -3.13" não. Se você usar o estilo curto da opção, talvez
prefira não instalar os binários com threads livres neste momento.

Para especificar a opção de instalação na linha de comando, use
"Include_freethreaded=1". Veja Instalando Sem Download para instruções
sobre como baixar preventivamente os binários adicionais para
instalação offline. As opções para incluir símbolos de depuração e
binários também se aplicam às construções com threads livres.

Binários com threads livres também estão disponíveis em nuget.org.


4.12. Python Launcher for Windows (Deprecated)
==============================================

Descontinuado desde a versão 3.14: The launcher and this documentation
have been superseded by the Python Install Manager described above.
This is preserved temporarily for historical interest.

Adicionado na versão 3.3.

O inicializador Python para Windows é um utilitário que auxilia na
localização e execução de diferentes versões do Python. Ele permite
que scripts (ou a linha de comando) indiquem uma preferência por uma
versão do Python específica, e irá localizar e executar essa versão.

Ao contrário da variável "PATH", o inicializador irá corretamente
selecionar a versão mais apropriada do Python. Ele irá preferir
instalações por usuário ao invés de instalações globais no sistema, e
ordenará por versão da linguagem ao invés de usar a versão instalada
mais recentemente.

O inicializador foi originalmente especificado na **PEP 397**.


4.12.1. Começando
-----------------


4.12.1.1. Pela linha de comando
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Alterado na versão 3.6.

Instalações globais no sistema do Python 3.3 ou posterior irão colocar
o inicializador no seu "PATH". O inicializador é compatível com todas
as versões disponíveis do Python, então não importa qual versão está
instalada. Para verificar se o inicializador está disponível, execute
o seguinte comando no Prompt de Comando:

   py

Você deve perceber que a última versão do Python que você tem é
iniciada - ela pode ser fechada normalmente, e qualquer argumento da
linha de comando adicional especificado será enviado diretamente para
o Python.

Se você tem múltiplas versões do Python instaladas (por exemplo, 3.7 e
3.14) você deve ter notado que o Python 3.14 foi iniciado -- para
iniciar o Python 3.7, use o comando:

   py -3.7

Se você quer a versão mais recente do Python 2 que você tem instalada,
tente o comando:

   py -2

Se você ver o seguinte erro, você não tem o inicializador instalado:

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

O comando:

   py --list

exibe a(s) versão(ões) atualmente instalada(s) do Python.

O argumento "-x.y" é a forma abreviada do argumento "-V:Empresa/Tag",
que permite selecionar um ambiente de execução Python específico,
incluindo aqueles que podem ter vindo de algum lugar diferente de
python.org. Qualquer ambiente de execução registrado seguindo a **PEP
514** será detectável. O comando "--list" lista todos os ambientes de
execução disponíveis usando o formato "-V:".

Ao usar o argumento "-V:", especificar a Empresa limitará a seleção
aos ambientes de execução desse provedor, enquanto especificar apenas
a Tag selecionará de todos os provedores. Observe que omitir a barra
implica uma tag:

   # Seleciona qualquer ambiente de execução sinalizado como '3.*'
   py -V:3

   # Seleciona qualquer ambiente de execução lançado como 'PythonCore'
   py -V:PythonCore/

   # Seleciona o ambiente de execução Python 3 mais recente de PythonCore
   py -V:PythonCore/3

A forma abreviada do argumento ("-3") só seleciona a partir de versões
principais do Python, e não de outras distribuições. No entanto, a
forma mais longa ("-V:3") selecionará qualquer um.

A Empresa é correspondida na string completa, sem distinção entre
maiúsculas e minúsculas. A Tag corresponde a uma string completa ou a
um prefixo, desde que o próximo caractere seja um ponto ou um hífen.
Isso permite que "-V:3.1" corresponda a "3.1-32", mas não a "3.10". As
tags são classificadas usando ordenação numérica ("3.10" é mais
recente que "3.1"), mas são comparadas usando texto ("-V:3.01" não
corresponde a "3.1").


4.12.1.2. Ambientes virtuais
~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Adicionado na versão 3.5.

Se o inicializador é executado sem versão explícita do Python
especificada, e um ambiente virtual (criado com o módulo da biblioteca
padrão "venv" ou da ferramenta externa "virtualenv") está ativo, o
inicializador irá executar o interpretador do ambiente virtual ao
invés do global. Para executar o interpretador global, ou desative o
ambiente virtual, ou explicitamente especifique a versão global do
Python.


4.12.1.3. Por um script
~~~~~~~~~~~~~~~~~~~~~~~

Vamos criar um script teste de Python - crie um arquivo chamado
"hello.py" com os seguintes conteúdos:

   #! python
   import sys
   sys.stdout.write("olá do Python %s\n" % (sys.version,))

A partir do diretório onde hello.py está, execute o comando:

   py hello.py

Você deve notar que o número da versão da sua instalação mais recente
do Python 2.x é exibido. Agora tente mudar a primeira linha para ser:

   #! python3

Re-executar o comando agora deve exibir informações da última versão
do Python 3.x. Como nos exemplos da linha de comando acima, você pode
especificar um qualificador de versão mais explícito. Presumindo que
você tem o Python 3.7 instalado, tente mudar a primeira linha para "#!
python3.7" e você deve ver as informações da versão 3.7 sendo
exibidas.

Note que diferentemente do uso interativo, um simples "python" irá
usar a última versão do Python 2.x que você tem instalada. Isso é para
retrocompatibilidade e para compatibilidade com Unix, onde o comando
"python" tipicamente se refere ao Python 2.


4.12.1.4. Por associação de arquivos
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

O inicializador deve ter sido associado com arquivos Python (isto é,
arquivos ".py", ".pyw", ".pyc") quando foi instalado. Isso significa
que quando você clica duas vezes em um desses arquivos a partir do
Explorador de Arquivos do Windows o inicializador será usado, e assim
você pode usar as mesmas facilidades descritas acima para que o script
especifique qual versão deve ser usada.

O benefício chave disso é que um único inicializador pode suportar
múltiplas versões do Python ao mesmo tempo dependendo dos conteúdos da
primeira linha.


4.12.2. Linhas Shebang
----------------------

Se a primeira linha de um arquivo de script começa com "#!", ela é
conhecida como linha "shebang". Linux e outros tipos de sistemas
operacionais Unix têm suporte nativo para essas linhas e elas são
comumente usadas nesses sistemas para indicar como um script deve ser
executado. Esse inicializador permite que as mesmas facilidades sejam
usadas com scripts Python no Windows e os exemplos acima demonstram
seu uso.

Para permitir que linhas shebang em scripts Python sejam portáveis
entre Unix e Windows, este inicializador suporta um número de comandos
'virtuais' para especificar qual interpretador deve ser usado. Os
comandos virtuais suportados são:

* "/usr/bin/env"

* "/usr/bin/python"

* "/usr/local/bin/python"

* "python"

Por exemplo, se a primeira linha do seu script começa com

   #! /usr/bin/python

O Python padrão ou um ambiente virtual ativo será localizado e
utilizado. Como muitos scripts Python escritos para funcionar no Unix
já terão essa linha, você deve perceber que esses scripts podem ser
usados pelo inicializador sem modificação. Se você está escrevendo um
novo script no Windows que você espera que seja útil no Unix, você
deve usar uma dessas linhas shebang começando com "/usr".

Qualquer um dos comandos virtuais acima pode ser sufixado com uma
versão explícita (ou apenas a maior versão, ou a maior e a menor
versão). Além disso, a versão de 32 bits pode ser solicitada
adicionando "-32" após a menor versão. Isto é, "/usr/bin/python3.7-32"
irá solicitar o uso do python 3.7 32-bit. Se um ambiente virtual
estiver ativo, a versão será ignorada e o ambiente será usado.

Adicionado na versão 3.7: A partir do inicializador do python 3.7 é
possível solicitar a versão 64-bit adicionando o sufixo "-64". Além
disso é possível especificar uma versão maior e arquitetura sem a
menor (isto é, "/usr/bin/python3-64").

Alterado na versão 3.11: O sufixo "-64" foi descontinuado e agora
implica "qualquer arquitetura que não seja comprovadamente i386/32
bits". Para solicitar um ambiente específico, use o novo argumento
"-V:*TAG*" com a tag completa.

Alterado na versão 3.13: Comandos virtuais que referenciam "python"
agora preferem um ambiente virtual ativo em vez de pesquisar "PATH".
Isso lida com casos em que o shebang especifica "/usr/bin/env
python3", mas "python3.exe" não está presente no ambiente ativo.

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

As linhas Shebang que não correspondem a nenhum desses padrões são
procuradas na seção "[commands]" do arquivo .INI do lançador. Isso
pode ser usado para lidar com certos comandos de uma maneira que faça
sentido para o seu sistema. O nome do comando deve ser um único
argumento (sem espaços no executável shebang) e o valor substituído é
o caminho completo para o executável (argumentos adicionais
especificados no .INI serão citados como parte do nome do arquivo).

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

Quaisquer comandos não encontrados no arquivo .INI são tratados como
caminhos executáveis do **Windows** que são absolutos ou relativos ao
diretório que contém o arquivo de script. Isso é uma conveniência para
scripts somente do Windows, como aqueles gerados por um instalador,
pois o comportamento não é compatível com shells de estilo Unix. Esses
caminhos podem ser citados e podem incluir vários argumentos, após os
quais o caminho para o script e quaisquer argumentos adicionais serão
anexados.


4.12.3. Argumentos em linhas shebang
------------------------------------

As linhas shebang também podem especificar opções adicionais a serem
passadas ao interpretador Python. Por exemplo, se você tem uma linha
shebang:

   #! /usr/bin/python -v

O Python será iniciado com a opção "-v"


4.12.4. Personalização
----------------------


4.12.4.1. Personalização via arquivos INI
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Dois arquivos .ini serão pesquisados pelo inicializador - "py.ini" no
diretório de dados de aplicações do usuário atual ("%LOCALAPPDATA%" ou
"$env:LocalAppData") e "py.ini" no mesmo diretório que o
inicializador. Os mesmos arquivos .ini são usados para ambas a versão
'console' do inicializador (isto é, py.exe) e a versão 'windows' (isto
é, pyw.exe).

Personalização especificada no "diretório da aplicação" terão
precedência sobre àquela especificada junto do executável, portanto um
usuário, que pode não ter acesso de escrita ao arquivo .ini junto do
inicializador, pode sobrescrever comandos naquele arquivo .ini global.


4.12.4.2. Personalizando versões padrão do Python
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Em alguns casos, um qualificador de versão pode ser incluído em um
comando para ditar qual versão do Python deve ser usada pelo comando.
Um qualificador de versão começa com um número maior de versão e pode
opcionalmente ser seguido por um ponto ('.') e uma especificação de
versão menor. Além disso, é possível especificar se uma implementação
de 32 ou 64 bit deve ser solicitada adicionando "-32" ou "-64".

Por exemplo, uma linha shebang "#!python" não tem qualificador de
versão, enquanto "#!python3" tem um qualificador de versão que
especifica apenas uma versão maior.

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

Se nenhum qualificador de versão menor é encontrado, a variável de
ambiente "PY_PYTHON{major}" (onde "{major}" é o qualificador da versão
maior atual, como determinado acima) pode ser definida para
especificar a versão completa. Se nenhuma opção é encontrada, o
inicializador irá enumerar as versões do Python instaladas e usar a
última versão menor encontrada como versão maior, o que é
provavelmente, ainda que não garantido, a versão instalada mais
recentemente naquela família.

Em um Windows 64-bit com ambas as implementações de 32-bit e 64-bit da
mesma (maior.menor) versão do Python instaladas, a versão 64-bit
sempre será preferida. Isso será verdadeiro para ambas as
implementações de 32-bit e 64-bit do inicializador - um inicializador
32-bit irá preferir executar uma instalação 64-bit do Python da versão
especificada, se disponível. Isso é para que o comportamento do
inicializador possa ser previsto sabendo apenas quais versões estão
instaladas no PC e sem considerar a ordem com que elas foram
instaladas (isto é, sem saber se a última a ser instalada foi a versão
32 ou 64-bit do Python e do instalador correspondente). Como observado
acima, um sufixo opcional "-32" ou "-64" pode ser usado como
especificador de versão para mudar esse comportamento.

Exemplos:

* Se nenhuma opção relevante for definida, os comandos "python" e
  "python2" irão usar a última versão instalada do Python 2.x e o
  comando "python3" irá usar o último Python 3.x instalado.

* O comando "python3.7" não vai consultar nenhuma opção já que as
  versões estão completamente especificadas.

* Se "PY_PYTHON=3", os comandos "python" e "python3" irão ambos usar a
  última versão do Python 3 instalada.

* Se "PY_PYTHON=3.7-32", o comando "python" irá usar a implementação
  32 bits do 3.7 enquanto o comando "python3" irá usar o último Python
  instalado (PY_PYTHON não foi considerado porque uma versão maior foi
  especificada).

* Se "PY_PYTHON=3" e "PY_PYTHON3=3.7", os comandos "python" e
  "python3" irão ambos usar especificamente 3.7

Em adição às variáveis de ambiente, as mesmas configurações podem ser
feitas no arquivo .INI usado pelo inicializador. A seção nos arquivos
INI é chamada "[defaults]" e o nome da chave será o mesmo que as
variáveis de ambiente sem o prefixo "PY_" (e observe que os nomes das
chaves no arquivo INI não diferem maiúsculas e minúsculas). Os
conteúdos de uma variável de ambiente irão sobrescrever coisas
especificadas em um arquivo INI.

Por exemplo:

* Configurar "PY_PYTHON=3.7" é o equivalente ao arquivo INI contendo:

   [defaults]
   python=3.7

* Configurar "PY_PYTHON=3" e "PY_PYTHON3=3.7" é o equivalente ao
  arquivo INI contendo:

   [defaults]
   python=3
   python3=3.7


4.12.5. Diagnósticos
--------------------

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


4.12.6. Teste de simulação
--------------------------

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


4.12.7. Instalar sob demanda
----------------------------

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

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


4.12.8. Códigos de retorno
--------------------------

Os seguintes códigos de saída podem ser retornados pelo inicializador
do Python. Infelizmente, não há como distingui-los do código de saída
do próprio Python.

Os nomes dos códigos são como usados nas fontes e são apenas para
referência. Não há como acessá-los ou resolvê-los além de ler esta
página. As entradas são listadas em ordem alfabética de nomes.

+---------------------+---------+-------------------------------------------------+
| Nome                | Valor   | Descrição                                       |
|=====================|=========|=================================================|
| RC_BAD_VENV_CFG     | 107     | Um "pyvenv.cfg" foi encontrado, mas está        |
|                     |         | corrompido.                                     |
+---------------------+---------+-------------------------------------------------+
| RC_CREATE_PROCESS   | 101     | Falha ao iniciar o Python.                      |
+---------------------+---------+-------------------------------------------------+
| RC_INSTALLING       | 111     | Uma instalação foi iniciada, mas o comando      |
|                     |         | precisará ser executado novamente após sua      |
|                     |         | conclusão.                                      |
+---------------------+---------+-------------------------------------------------+
| RC_INTERNAL_ERROR   | 109     | Erro inesperado. Por favor, relate um bug.      |
+---------------------+---------+-------------------------------------------------+
| RC_NO_COMMANDLINE   | 108     | Não é possível obter a linha de comando do      |
|                     |         | sistema operacional.                            |
+---------------------+---------+-------------------------------------------------+
| RC_NO_PYTHON        | 103     | Não foi possível localizar a versão solicitada. |
+---------------------+---------+-------------------------------------------------+
| RC_NO_VENV_CFG      | 106     | Um "pyvenv.cfg" era necessário, mas não foi     |
|                     |         | encontrado.                                     |
+---------------------+---------+-------------------------------------------------+
