# 3. Configurando o Python

## 3.1. Requisitos de construção

Recursos e versões mínimas necessários para construir o CPython:

- Um compilador C11. Não são necessários recursos opcionais do C11.

- No Windows, é necessário o Microsoft Visual Studio 2017 ou posterior.

- Suporte para números de ponto flutuante do IEEE 754 e Not-a-Number (NaN) de ponto flutuante.

- Suporte a threads.

To build optional modules:

- libbz2 for the `bz2` module.

- libb2 (BLAKE2), used by `hashlib` module.

- libffi 3.3.0 is the recommended minimum version for the `ctypes` module.

- `liblzma`, for the `lzma` module.

- libmpdec 2.5.0 para o módulo `decimal`.

- `libncurses` or `libncursesw`, for the `curses` module.

- `libpanel` or `libpanelw`, for the `curses.panel` module.

- libreadline or libedit for the `readline` module.

- libuuid, for the `uuid` module.

- OpenSSL 1.1.1 is the minimum version and OpenSSL 3.0.18 is the recommended minimum version for the `ssl` and `hashlib` extension modules.

- SQLite 3.15.2 for the `sqlite3` extension module.

- Tcl/Tk 8.5.12 for the `tkinter` module.

- zlib 1.1.4 is the reccomended minimum version for the `zlib` module.

- zstd 1.4.5 is the minimum version for the `compression.zstd` module.

For a full list of dependencies required to build all modules and how to install them, see the devguide.

- Autoconf 2.72 e aclocal 1.16.5 são necessários para regenerar o script `configure`.

Alterado na versão 3.1: Agora é necessária a versão 8.3.1 do Tcl/Tk.

Alterado na versão 3.5: No Windows, agora é necessário o Visual Studio 2015 ou posterior. Agora é necessária a versão 8.4 do Tcl/Tk.

Alterado na versão 3.6: Recursos selecionados do C99 agora são necessários, como funções `<stdint.h>` e `static inline`.

Alterado na versão 3.7: Suporte a threads e OpenSSL 1.0.2 agora são necessários.

Alterado na versão 3.10: OpenSSL 1.1.1 agora é necessário. Requer SQLite 3.7.15.

Alterado na versão 3.11: Compilador C11, suporte a IEEE 754 e NaN agora são necessários. No Windows, é necessário o Visual Studio 2017 ou posterior. A versão 8.5.12 do Tcl/Tk agora é necessária para o módulo `tkinter`.

Alterado na versão 3.13: Autoconf 2.71, aclocal 1.16.5 e SQLite 3.15.2 agora são necessários.

Alterado na versão 3.14: Autoconf 2.72 agora é necessário.

Veja também PEP 7 “Guia de estilo para código C” e PEP 11 “Suporte do CPython a plataformas”.

## 3.2. Arquivos gerados

Para reduzir as dependências de construção, o código-fonte do Python contém vários arquivos gerados. Comandos para regenerar todos os arquivos gerados:

    make regen-all
    make regen-stdlib-module-names
    make regen-limited-abi
    make regen-configure

O arquivo `Makefile.pre.in` documenta os arquivos gerados, suas entradas e ferramentas usadas para regenerá-los. Procure por alvos `regen-*` de make.

### 3.2.1. Script configure

O comando `make regen-configure` regera o arquivo `aclocal.m4` e o script `configure` usando o shell script `Tools/build/regen-configure.sh`, o qual usa um contêiner Ubuntu para obter as mesmas versões de ferramentas e ter uma saída reproduzível.

O contêiner é opcional, o seguinte comando pode ser executado localmente:

    autoreconf -ivf -Werror

Os arquivos gerados podem mudar dependendo das versões exatas do `autoconf-archive`, `aclocal` e `pkg-config`.

## 3.3. Opções de configuração

Liste todas as opções do `configure` usando:

    ./configure --help

Veja também o `Misc/SpecialBuilds.txt` na distribuição de código-fonte do Python.

### 3.3.1. Opções gerais

--enable-loadable-sqlite-extensions

  Suporte a extensões carregáveis no módulo de extensão `_sqlite` (o padrão é não) do módulo `sqlite3`.

  Veja o método `sqlite3.Connection.enable_load_extension()` do módulo `sqlite3`.

  Adicionado na versão 3.6.

--disable-ipv6

  Desabilita suporte a IPv6 (habilitado por padrão se houver suporte), veja o módulo `socket`.

--enable-big-digits=[15|30]

  Define o tamanho em bits dos dígitos de `int` do Python: 15 ou 30 bits.

  Por padrão, o tamanho dos dígitos é 30.

  Define o `PYLONG_BITS_IN_DIGIT` para `15` ou `30`.

  Veja `sys.int_info.bits_per_digit`.

--with-suffix=SUFFIX

  Define o sufixo do executável do Python para SUFFIX.

  O sufixo padrão é `.exe` no Windows e macOS (executável `python.exe`), `.js` em nó Emscripten, `.html` em navegador Emscripten, `.wasm` em WASI e uma string vazia em outras plataformas (executável `python`).

  Alterado na versão 3.11: O sufixo padrão na plataforma WASM é um entre `.js`, `.html` ou `.wasm`

--with-tzpath=<list of absolute paths separated by pathsep>

  Seleciona o caminho de pesquisa de fuso horário padrão para `zoneinfo.TZPATH`. Veja a Configuração de tempo de compilação do módulo `zoneinfo`.

  Padrão: `/usr/share/zoneinfo:/usr/lib/zoneinfo:/usr/share/lib/zoneinfo:/etc/zoneinfo`.

  Veja o separador de caminhos `os.pathsep`.

  Adicionado na versão 3.9.

--without-decimal-contextvar

  Constrói o módulo de extensão `_decimal` usando um contexto local de thread ao invés de um contexto local de corrotina (padrão), veja o módulo `decimal`.

  Veja `decimal.HAVE_CONTEXTVAR` e o módulo `contextvars`.

  Adicionado na versão 3.9.

--with-dbmliborder=<list of backend names>

  Substitui a ordem de verificação de backends de banco de dados para o módulo `dbm`

  Um valor válido é uma string separada por dois pontos (`:`) com os nomes de backend:

  - `ndbm`;

  - `gdbm`;

  - `bdb`.

--without-c-locale-coercion

  Desabilita a coerção de localidade C para uma localidade baseada em UTF-8 (ativada por padrão).

  Não define a macro `PY_COERCE_C_LOCALE`.

  Consulte `PYTHONCOERCECLOCALE` e a PEP 538.

--with-platlibdir=DIRNAME

  Nome do diretório da biblioteca Python (o padrão é `lib`).

  Fedora e SuSE usam `lib64` em plataformas de 64 bits.

  Veja `sys.platlibdir`.

  Adicionado na versão 3.9.

--with-wheel-pkg-dir=PATH

  Diretório de pacotes de wheel usados pelo módulo `ensurepip` (nenhum por padrão).

  Algumas políticas de empacotamento de distribuição do Linux recomendam contra o empacotamento de dependências. Por exemplo, o Fedora instala pacotes wheel no diretório `/usr/share/python-wheels/` e não instala o pacote `ensurepip._bundled`.

  Adicionado na versão 3.10.

--with-pkg-config=[check|yes|no]

  Se o configure deve usar pkg-config para detectar dependências de construção.

  - `check` (padrão): pkg-config é opcional

  - `yes`: pkg-config é obrigatório

  - `no`: configure não usa pkg-config mesmo quando presente

  Adicionado na versão 3.11.

--enable-pystats

  Ativa a coleta de estatísticas internas de desempenho do Python.

  Por padrão, a coleta de estatísticas está desativada. Use o comando `python3 -X pystats` ou defina a variável de ambiente `PYTHONSTATS=1` para ativar a coleta de estatísticas na inicialização do Python.

  Na saída do Python, despeja as estatísticas se a coleta de estatísticas estiver ativada e não apagada.

  Efeitos:

  - Adiciona a opção de linha de comando `-X pystats`.

  - Adiciona a variável de ambiente `PYTHONSTATS`.

  - Define a macro `Py_STATS`.

  - Adiciona funções ao módulo `sys`:

    - `sys._stats_on()`: Ativa a coleta de estatísticas.

    - `sys._stats_off()`: Desativa a coleta de estatísticas.

    - `sys._stats_clear()`: Apaga as estatísticas.

    - `sys._stats_dump()`: Despeja as estatísticas no arquivo e apaga as estatísticas.

  As estatísticas serão despejadas em um arquivo arbitrário (provavelmente único) em `/tmp/py_stats/` (Unix) ou `C:\temp\py_stats\` (Windows). Se aquele diretório não existir, os resultados serão enviados para stderr.

  Use `Tools/scripts/summarize_stats.py` para ler as estatísticas.

  Estatísticas:

  - Código de operação:

    - Especialização: sucesso, fracasso, acerto, adiado, erro, deopt, falhas;

    - Contagem de execuções;

    - Contagem em pares.

  - Chamada:

    - Chamadas Python em linha;

    - Chamadas a PyEval;

    - Quadros enviados;

    - Objetos quadro criados;

    - Chamadas de Eval: vetor, gerador, legado, função VECTORCALL, classe de construção, slot, função “ex”, API, método.

  - Objeto:

    - incref e decref;

    - incref e decref do interpretador;

    - alocações: tudo, 512 bytes, 4 kiB, big;

    - memória livre;

    - listas de memória livre para/de;

    - Dicionário materializado/desmaterializado;

    - cache de tipo;

    - tentativas de otimização;

    - rastros de otimização criados/executados;

    - uops executados.

  - Coletor de lixo:

    - Coletas de lixo;

    - Objetos visitados;

    - Objetos coletados.

  Adicionado na versão 3.11.

--disable-gil

  Habilita suporte para execução de Python sem a trava global do interpretador (GIL): construção com threads livres.

  Define a macro `Py_GIL_DISABLED` e adiciona `"t"` a `sys.abiflags`.

  Veja CPython com threads livres para mais detalhes.

  Adicionado na versão 3.13.

--enable-experimental-jit=[no|yes|yes-off|interpreter]

  Indica como integrar o compilador just-in-time experimental.

  - `no`: não constrói o JIT;

  - `yes`: habilita o JIT. Para desabilitá-lo em tempo de execução, defina a variável de ambiente `PYTHON_JIT=0`.

  - `yes-off`: constrói o JIT, mas desabilita-o por padrão. Para habilitá-lo em tempo de execução, defina a variável de ambiente `PYTHON_JIT=1`.

  - `interpreter`: Habilita o “interpretador JIT” (útil apenas para quem está depurando o próprio JIT). Para desabilitá-lo em tempo de execução, defina a variável de ambiente `PYTHON_JIT=0`.

  `--enable-experimental-jit=no` é o comportamento padrão se a opção não for fornecida, e `--enable-experimental-jit` é uma abreviação de `--enable-experimental-jit=yes`. Consulte `Tools/jit/README.md` para mais informações, incluindo como instalar as dependências necessárias em tempo de construção.

  Nota

  Ao construir o CPython com o JIT habilitado, certifique-se de que seu sistema tenha o Python 3.11 ou posterior instalado.

  Adicionado na versão 3.13.

PKG_CONFIG

  Caminho para o utilitário `pkg-config`.

PKG_CONFIG_LIBDIR

PKG_CONFIG_PATH

  Opções do `pkg-config`.

### 3.3.2. Opções do compilador C

CC

  Comando do compilador C.

CFLAGS

  Sinalizadores do compilador C.

CPP

  Comando do pré-processador C.

CPPFLAGS

  Sinalizadores do pré-processador C, p.ex., `-Iinclude_dir`.

### 3.3.3. Opções da ligação

LDFLAGS

  Sinalizadores do vinculador. p.ex., `-Llibrary_directory`.

LIBS

  Bibliotecas para passar para o vinculador, p.ex. `-llibrary`.

MACHDEP

  Nome para arquivos de biblioteca dependentes de máquina.

### 3.3.4. Opções para dependências de terceiros

Adicionado na versão 3.11.

BZIP2_CFLAGS

BZIP2_LIBS

  Sinalizadores de compilador C e vinculador para vincular Python a `libbz2`, usados pelo módulo `bz2`, substituindo `pkg-config`.

CURSES_CFLAGS

CURSES_LIBS

  Sinalizadores de compilador C e vinculador para `libncurses` ou `libncursesw`, usados pelo módulo `curses`, substituindo `pkg-config`.

GDBM_CFLAGS

GDBM_LIBS

  Sinalizadores de compilador C e vinculador para `gdbm`.

LIBB2_CFLAGS

LIBB2_LIBS

  Sinalizadores de compilador C e vinculador para `libb2` (BLAKE2), usados pelo módulo `hashlib`, substituindo `pkg-config`.

LIBEDIT_CFLAGS

LIBEDIT_LIBS

  Sinalizadores de compilador C e vinculador para `libedit`, usados pelo módulo `readline`, substituindo `pkg-config`.

LIBFFI_CFLAGS

LIBFFI_LIBS

  Sinalizadores de compilador C e vinculador para `libffi`, usados pelo módulo `ctypes`, substituindo `pkg-config`.

LIBMPDEC_CFLAGS

LIBMPDEC_LIBS

  Sinalizadores de compilador C e vinculador para `libmpdec`, usados pelo módulo `decimal`, substituindo `pkg-config`.

  Nota

  Estas variáveis de ambiente não têm efeito a menos que `--with-system-libmpdec` seja especificado.

LIBLZMA_CFLAGS

LIBLZMA_LIBS

  Sinalizadores de compilador C e vinculador para `liblzma`, usados pelo módulo `lzma`, substituindo `pkg-config`.

LIBREADLINE_CFLAGS

LIBREADLINE_LIBS

  Sinalizadores de compilador C e vinculador para `libreadline`, usados pelo módulo `readline`, substituindo `pkg-config`.

LIBSQLITE3_CFLAGS

LIBSQLITE3_LIBS

  Sinalizadores de compilador C e vinculador para `libsqlite3`, usados pelo módulo `sqlite3`, substituindo `pkg-config`.

LIBUUID_CFLAGS

LIBUUID_LIBS

  Sinalizadores de compilador C e vinculador para `libuuid`, usados pelo módulo `uuid`, substituindo `pkg-config`.

LIBZSTD_CFLAGS

LIBZSTD_LIBS

  Sinalizadores de compilador C e ligador para `libzstd`, usados pelo módulo `compression.zstd`, substituindo `pkg-config`.

  Adicionado na versão 3.14.

PANEL_CFLAGS

PANEL_LIBS

  Sinalizadores de compilador C e vinculador para PANEL, substituindo `pkg-config`.

  Sinalizadores de compilador C e vinculador para `libpanel` ou `libpanelw`, usados pelo módulo `curses.panel`, substituindo `pkg-config`.

TCLTK_CFLAGS

TCLTK_LIBS

  Sinalizadores de compilador C e vinculador para TCLTK, substituindo `pkg-config`.;

ZLIB_CFLAGS

ZLIB_LIBS

  Sinalizadores de compilador C e vinculador para `libzlib`, usados pelo módulo `gzip`, substituindo `pkg-config`.

### 3.3.5. Opções de WebAssembly

--enable-wasm-dynamic-linking

  Ativa o suporte de vinculação dinâmica para WASM.

  A vinculação dinâmica permite `dlopen`. O tamanho do arquivo executável aumenta devido à eliminação limitada de código morto e recursos adicionais.

  Adicionado na versão 3.11.

--enable-wasm-pthreads

  Ativa o suporte a pthreads para WASM.

  Adicionado na versão 3.11.

### 3.3.6. Opções de instalação

--prefix=PREFIX

  Instala arquivos independentes de arquitetura em PREFIX. No Unix, o padrão é `/usr/local`.

  Este valor pode ser recuperado em tempo de execução usando `sys.prefix`.

  Como exemplo, pode-se usar `--prefix="$HOME/.local/"` para instalar um Python em seu diretório pessoal (home).

--exec-prefix=EPREFIX

  Instala arquivos dependentes de arquitetura no EPREFIX, o padrão é `--prefix`.

  Este valor pode ser recuperado em tempo de execução usando `sys.exec_prefix`.

--disable-test-modules

  Não constrói nem instala módulos de teste, como o pacote `test` ou o módulo de extensão `_testcapi` (construído e instalado por padrão).

  Adicionado na versão 3.10.

--with-ensurepip=[upgrade|install|no]

  Seleciona o comando `ensurepip` executado na instalação do Python:

  - `upgrade` (padrão): executa o comando `python -m ensurepip --altinstall --upgrade`.

  - `install`: executa o comando `python -m ensurepip --altinstall`;

  - `no`: não executa ensurepip;

  Adicionado na versão 3.6.

### 3.3.7. Opções de desempenho

Configurar o Python usando `--enable-optimizations --with-lto` (PGO + LTO) é o recomendado para melhor desempenho. O sinalizador experimental `--enable-bolt` também pode ser usado para melhorar o desempenho.

--enable-optimizations

  Habilita a otimização guiada por perfil (PGO, do inglês Profile Guided Optimization) usando `PROFILE_TASK` (desabilitado por padrão).

  O compilador C Clang requer o programa `llvm-profdata` para PGO. No macOS, o GCC também exige: o GCC é apenas um apelido para o Clang no macOS.

  Desabilita também a interposição semântica no libpython se `--enable-shared` e GCC forem usados: adiciona `-fno-semantic-interposition` aos sinalizadores do compilador e do vinculador.

  Nota

  Durante a construção, você poderá encontrar avisos do compilador sobre a indisponibilidade de dados de perfil para alguns arquivos fonte. Esses avisos são inofensivos, pois apenas um subconjunto do código é exercido durante a aquisição de dados de perfil. Para desativar esses avisos no Clang, suprima-os manualmente adicionando `-Wno-profile-instr-unprofiled` a `CFLAGS`.

  Adicionado na versão 3.6.

  Alterado na versão 3.10: Usa `-fno-semantic-interposition` no GCC.

PROFILE_TASK

  Variável de ambiente usada no Makefile: argumentos de linha de comando do Python para a tarefa de geração de PGO.

  Padrão: `-m test --pgo --timeout=$(TESTTIMEOUT)`.

  Adicionado na versão 3.8.

  Alterado na versão 3.13: A falha da tarefa não é mais ignorada silenciosamente.

--with-lto=[full|thin|no|yes]

  Habilita o otimização em tempo de vinculação (LTO, do inglês Link Time Optimization) em qualquer construção (desabilitado por padrão).

  O compilador C Clang requer `llvm-ar` para LTO (`ar` no macOS), bem como um vinculador compatível com LTO (`ld.gold` ou `lld`).

  Adicionado na versão 3.6.

  Adicionado na versão 3.11: Para usar o recurso ThinLTO, use `--with-lto=thin` no Clang.

  Alterado na versão 3.12: Usa ThinLTO como política de otimização padrão no Clang se o compilador aceitar o sinalizador.

--enable-bolt

  Habilita o uso do otimizador binário pós-vinculação BOLT (desabilitado por padrão).

  BOLT faz parte do projeto LLVM, mas nem sempre está incluído em suas distribuições binárias. Este sinalizador requer que `llvm-bolt` e `merge-fdata` estejam disponíveis.

  BOLT ainda é um projeto relativamente novo, então este sinalizador deve ser considerado experimental por enquanto. Como esta ferramenta opera em código de máquina, seu sucesso depende de uma combinação do ambiente de construção + os outros argumentos de configuração de otimização + a arquitetura da CPU, e nem todas as combinações são suportadas. Versões do BOLT anteriores ao LLVM 16 são conhecidas por travar o BOLT em alguns cenários. O uso do LLVM 16 ou mais recente para otimização do BOLT é fortemente incentivado.

  As variáveis `BOLT_INSTRUMENT_FLAGS` e `BOLT_APPLY_FLAGS` do configure podem ser definidas para substituir o conjunto padrão de argumentos para llvm-bolt para instrumentar e aplicar dados BOLT aos binários , respectivamente.

  Adicionado na versão 3.12.

BOLT_APPLY_FLAGS

  Argumentos para `llvm-bolt` ao criar um binário otimizado com BOLT.

  Adicionado na versão 3.12.

BOLT_INSTRUMENT_FLAGS

  Argumentos para `llvm-bolt` ao instrumentar binários.

  Adicionado na versão 3.12.

--with-computed-gotos

  Habilita “gotos” computados no laço de avaliação (habilitado por padrão em compiladores suportados).

--with-tail-call-interp

  Habilita interpretadores usando chamadas de cauda no CPython. Se habilitado, é altamente recomendável habilitar PGO (`--enable-optimizations`). Esta opção requer especificamente um compilador C com suporte adequado a chamadas de cauda e a convenção de chamada preserve_none. Por exemplo, o Clang 19 e versões mais recentes oferecem suporte a esse recurso.

  Adicionado na versão 3.14.

--without-mimalloc

  Desativa o alocador rápido mimalloc (habilitado por padrão).

  Veja também a variável de ambiente `PYTHONMALLOC`.

--without-pymalloc

  Desabilita o alocador de memória especializado do Python pymalloc (habilitado por padrão).

  Veja também a variável de ambiente `PYTHONMALLOC`.

--without-doc-strings

  Desabilita as strings de documentação estática para reduzir o consumo de memória (habilitado por padrão). As strings de documentação definidas em Python não são afetadas.

  Não define a macro `WITH_DOC_STRINGS`.

  Veja a macro `PyDoc_STRVAR()`.

--enable-profiling

  Habilita o perfil de código a nível C com `gprof` (desabilitado por padrão).

--with-strict-overflow

  Adiciona `-fstrict-overflow` aos sinalizadores do compilador C (por padrão adicionamos `-fno-strict-overflow`).

--without-remote-debug

  Desativa o suporte à depuração remota descrito na PEP 768 (habilitado por padrão). Quando este sinalizador é fornecido, o código que permite ao interpretador agendar a execução de um arquivo Python em um processo separado, conforme descrito na PEP 768, não é compilado. Isso inclui tanto a funcionalidade de agendar a execução do código quanto a funcionalidade de receber a execução do código.

  Py_REMOTE_DEBUG

    Esta macro é definida por padrão, a menos que o Python esteja configurado com `--without-remote-debug`.

    Observe que, mesmo que a macro esteja definida, a depuração remota pode não estar disponível (por exemplo, em uma plataforma incompatível).

  Adicionado na versão 3.14.

### 3.3.8. Compilação de depuração do Python

Uma compilação de depuração é Python compilada com a opção de configuração `--with-pydebug`.

Efeitos de uma compilação de depuração:

- Exibe todos os avisos por padrão: a lista de filtros de aviso padrão está vazia no módulo `warnings`.

- Adiciona `d` a `sys.abiflags`.

- Adiciona a função `sys.gettotalrefcount()`.

- Adiciona a opção de linha de comando `-X showrefcount`.

- Adiciona a opção de linha de comando `-d` e a variável de ambiente `PYTHONDEBUG` para depurar o analisador sintático.

- Adiciona suporte para a variável `__lltrace__`: habilita o rastreamento de baixo nível no laço de avaliação de bytecode se a variável estiver definida.

- Instala ganchos de depuração nos alocadores de memória para detectar estouro de buffer e outros erros de memória.

- Define as macros `Py_DEBUG` e `Py_REF_DEBUG`.

- Adiciona verificações de tempo de execução: código cercado por `#ifdef Py_DEBUG` e `#endif`. Habilita as asserções `assert(...)` e `_PyObject_ASSERT(...)`: não define a macro `NDEBUG` (veja também a configuração `--with-assertions` opção). Principais verificações de tempo de execução:

  - Adiciona verificações de sanidade nos argumentos da função.

  - Objetos Unicode e int são criados com sua memória preenchida com um padrão para detectar o uso de objetos não inicializados.

  - Garante que as funções que podem limpar ou substituir a exceção atual não sejam chamadas com uma exceção levantada.

  - Verifica se as funções desalocadoras não alteram a exceção atual.

  - O coletor de lixo (função `gc.collect()`) executa algumas verificações básicas na consistência dos objetos.

  - A macro `Py_SAFE_DOWNCAST()` verifica o underflow e o overflow de inteiros ao fazer o downcast de tipos largos para tipos estreitos.

Veja também o Modo de Desenvolvimento do Python e a opção de configuração `--with-trace-refs`.

Alterado na versão 3.8: Construções de lançamento e construções de depuração agora são compatíveis com ABI: definir a macro `Py_DEBUG` não implica mais na macro `Py_TRACE_REFS` (consulte a opção `--with-trace-refs`).

### 3.3.9. Opções de depuração

--with-pydebug

  Construção de depuração do Python: define a macro `Py_DEBUG` (desabilitada por padrão).

--with-trace-refs

  Habilita referências de rastreamento para fins de depuração (desabilitado por padrão).

  Efeitos:

  - Define a macro `Py_TRACE_REFS`.

  - Adiciona a função `sys.getobjects()`.

  - Adiciona a variável de ambiente `PYTHONDUMPREFS`.

  A variável de ambiente `PYTHONDUMPREFS` pode ser usada para despejar objetos e contagens de referências ainda ativas na saída do Python.

  Objetos alocados estaticamente não são rastreados.

  Adicionado na versão 3.8.

  Alterado na versão 3.13: Esta construção agora é compatibilidade de ABI com a construção de lançamento e construção de depuração.

--with-assertions

  Constrói com asserções C habilitadas (o padrão é não): `assert(...);` e `_PyObject_ASSERT(...);`.

  Se definido, a macro `NDEBUG` não é definida na variável do compilador `OPT`.

  Veja também a opção `--with-pydebug` (construção de depuração) que também habilita asserções.

  Adicionado na versão 3.6.

--with-valgrind

  Habilita suporte ao Valgrind (o padrão é não).

--with-dtrace

  Habilita suporte ao DTrace (o padrão é não).

  Veja Instrumentando o CPython com DTrace e SystemTap.

  Adicionado na versão 3.6.

--with-address-sanitizer

  Habilita o detector de erros de memória AddressSanitizer, `asan` (o padrão é não). Para melhorar os recursos de detecção do ASan, você também pode combinar isso com `--without-pymalloc` para desabilitar o alocador especializado de pequenos objetos cujas alocações não são rastreadas pelo ASan.

  Adicionado na versão 3.6.

--with-memory-sanitizer

  Habilita o detector de erros de alocação do MemorySanitizer, `msan` (o padrão é não).

  Adicionado na versão 3.6.

--with-undefined-behavior-sanitizer

  Habilita o detector de comportamento indefinido UndefinedBehaviorSanitizer, `ubsan` (o padrão é não).

  Adicionado na versão 3.6.

--with-thread-sanitizer

  Habilita o detector de corrida de dados ThreadSanitizer, `tsan` (o padrão é não).

  Adicionado na versão 3.13.

### 3.3.10. Opções da ligação

--enable-shared

  Habilita a construção de uma biblioteca Python compartilhada: `libpython` (o padrão é não).

--without-static-libpython

  Não constrói `libpythonMAJOR.MINOR.a` e não instala `python.o` (construído e habilitado por padrão).

  Adicionado na versão 3.10.

### 3.3.11. Opções da biblioteca

--with-libs='lib1 ...'

  Vincula bibliotecas adicionais (o padrão é não).

--with-system-expat

  Constrói o módulo `pyexpat` usando uma biblioteca `expat` instalada (o padrão é não).

--with-system-libmpdec

  Constrói o módulo de extensão `_decimal` usando uma biblioteca `mpdecimal` instalada, veja o módulo `decimal` (o padrão é sim).

  Adicionado na versão 3.3.

  Alterado na versão 3.13: O padrão é usar a biblioteca `mpdecimal` instalada.

  Deprecated since version 3.13, will be removed in version 3.16: Uma cópia dos fontes da biblioteca `mpdecimal` não será mais distribuída com Python 3.16.

  Ver também

  `LIBMPDEC_CFLAGS` e `LIBMPDEC_LIBS`.

--with-readline=readline|editline

  Designa uma biblioteca backend para o módulo `readline`.

  - readline: Usa readline como o backend.

  - editline: Usa editline como o backend.

  Adicionado na versão 3.10.

--without-readline

  Não constrói o módulo `readline` (construído por padrão).

  Não define a macro `HAVE_LIBREADLINE`.

  Adicionado na versão 3.10.

--with-libm=STRING

  Substitui a biblioteca matemática `libm` por STRING (o padrão depende do sistema).

--with-libc=STRING

  Substitui a biblioteca C `libc` por STRING (o padrão depende do sistema).

--with-openssl=DIR

  Raiz do diretório OpenSSL.

  Adicionado na versão 3.7.

--with-openssl-rpath=[no|auto|DIR]

  Define o diretório da biblioteca de tempo de execução (rpath) para bibliotecas OpenSSL:

  - `no` (padrão): não define o rpath;

  - `auto`: detecta automaticamente o rpath de `--with-openssl` e `pkg-config`;

  - DIR: define um rpath explícito.

  Adicionado na versão 3.10.

### 3.3.12. Opções de segurança

--with-hash-algorithm=[fnv|siphash13|siphash24]

  Seleciona o algoritmo de hash para usar em `Python/pyhash.c`:

  - `siphash13` (padrão);

  - `siphash24`;

  - `fnv`.

  Adicionado na versão 3.4.

  Adicionado na versão 3.11: `siphash13` é adicionado e é o novo padrão.

--with-builtin-hashlib-hashes=md5,sha1,sha256,sha512,sha3,blake2

  Módulos embutidos de hash

  - `md5`;

  - `sha1`;

  - `sha256`;

  - `sha512`;

  - `sha3` (com shake);

  - `blake2`.

  Adicionado na versão 3.9.

--with-ssl-default-suites=[python|openssl|STRING]

  Substitui a string dos conjuntos de criptografia padrão do OpenSSL:

  - `python` (padrão): use a seleciona preferida do Python;

  - `openssl`: mantém inalterados os padrões do OpenSSL;

  - STRING: usa uma string personalizada

  Veja o módulo `ssl`.

  Adicionado na versão 3.7.

  Alterado na versão 3.10: As configurações `python` e STRING também definem TLS 1.2 como versão mínima do protocolo.

--disable-safety

  Desabilita as opções do compilador recomendadas pela OpenSSF por motivos de segurança, sem causar sobrecarga de desempenho. Se esta opção não estiver habilitada, o CPython será construído com base nas opções de segurança do compilador, sem causar lentidão. Quando esta opção estiver habilitada, o CPython não será construído com as opções do compilador listadas abaixo.

  As seguintes opções do compilador são desabilitadas com `--disable-safety`:

  - -fstack-protector-strong: Habilita verificações em tempo de execução para estouros de buffer baseados em pilha.

  - -Wtrampolines: Habilita avisos sobre trampolins que exigem pilhas executáveis.

  Adicionado na versão 3.14.

--enable-slower-safety

  Habilita as opções do compilador recomendadas pela OpenSSF por motivos de segurança, o que causa sobrecarga. Se esta opção não estiver habilitada, o CPython não será construído com base nas opções de segurança do compilador, o que impacta o desempenho. Quando esta opção estiver habilitada, o CPython será construído com as opções do compilador listadas abaixo.

  As seguintes opções do compilador são habilitadas com `--enable-slower-safety`:

  - -D_FORTIFY_SOURCE=3: Fortalece as fontes com verificações de tempo de compilação e execução para uso inseguro de libc e estouros de buffer.

  Adicionado na versão 3.14.

### 3.3.13. Opções do macOS

Veja Mac/README.rst.

--enable-universalsdk

--enable-universalsdk=SDKDIR

  Cria uma construção binária universal. SDKDIR especifica qual SDK do macOS deve ser usado para executar a construção (o padrão é não).

--enable-framework

--enable-framework=INSTALLDIR

  Cria um Python.framework em vez de uma instalação tradicional do Unix. O INSTALLDIR opcional especifica o caminho de instalação (o padrão é não).

--with-universal-archs=ARCH

  Especifica o tipo de binário universal que deve ser criado. Esta opção só é válida quando `--enable-universalsdk` está definido.

  Opções:

  - `universal2` (x86-64 e arm64);

  - `32-bit` (PPC e i386);

  - `64-bit` (PPC64 e x86-64);

  - `3-way` (i386, PPC e x86-64);

  - `intel` (i386 e x86-64);

  - `intel-32` (i386);

  - `intel-64` (x86-64);

  - `all` (PPC, i386, PPC64 e x86-64).

  Observe que os valores para este item de configuração não são os mesmos que os identificadores usados para rodas binárias universais no macOS. Veja o Guia de Empacotamento do Python para detalhes sobre as tags de compatibilidade de plataforma de empacotamento usadas no macOS

--with-framework-name=FRAMEWORK

  Especifica o nome do framework python no macOS válido apenas quando `--enable-framework` está definido (padrão: `Python`).

--with-app-store-compliance

--with-app-store-compliance=PATCH-FILE

  A biblioteca padrão do Python contém strings que são conhecidas por acionar erros de ferramentas de inspeção automatizadas quando enviadas para distribuição pelas App Stores do macOS e do iOS. Se ativada, esta opção aplicará a lista de patches que corrigem a conformidade da app store. Um arquivo de patch personalizado também pode ser especificado. Esta opção está desativada por padrão.

  Adicionado na versão 3.13.

### 3.3.14. Opções do iOS

Veja iOS/README.rst.

--enable-framework=INSTALLDIR

  Cria um Python.framework. Ao contrário do macOS, o argumento INSTALLDIR que especifica o caminho de instalação é obrigatório.

--with-framework-name=FRAMEWORK

  Especifica o nome do framework (padrão: `Python`).

### 3.3.15. Opções de compilação cruzada

A compilação cruzada, também conhecida como construção cruzada, pode ser usada para construir Python para outra arquitetura ou plataforma de CPU. A compilação cruzada requer um interpretador Python para a plataforma de construção. A versão do Python para construção deve corresponder à versão do Python da compilação cruzada do host.

--build=BUILD

  configura para construir em BUILD, geralmente adivinhado por config.guess.

--host=HOST

  faz compilação cruzada para construir programas para executar no HOST (plataforma de destino)

--with-build-python=path/to/python

  caminho para construir o binário `python` para compilação cruzada

  Adicionado na versão 3.11.

CONFIG_SITE=file

  Uma variável de ambiente que aponta para um arquivo com substituições de configuração.

  Exemplo de arquivo config.site:

      # config.site-aarch64
      ac_cv_buggy_getaddrinfo=no
      ac_cv_file__dev_ptmx=yes
      ac_cv_file__dev_ptc=no

HOSTRUNNER

  Programa para executar CPython para a plataforma host para compilação cruzada.

  Adicionado na versão 3.11.

Exemplo de compilação cruzada:

    CONFIG_SITE=config.site-aarch64 ../configure \
        --build=x86_64-pc-linux-gnu \
        --host=aarch64-unknown-linux-gnu \
        --with-build-python=../x86_64/python

## 3.4. Sistema de Construção Python

### 3.4.1. Arquivos principais do sistema de construção

- `configure.ac` => `configure`;

- `Makefile.pre.in` => `Makefile` (criado por `configure`);

- `pyconfig.h` (criado por `configure`);

- `Modules/Setup`: Extensões C construídas pelo Makefile usando o shell script `Module/makesetup`;

### 3.4.2. Principais etapas de construção

- Arquivos C (`.c`) são construídos como arquivos objeto (`.o`).

- Uma biblioteca estática `libpython` (`.a`) é criada a partir de arquivos de objetos.

- `python.o` e a biblioteca estática `libpython` estão vinculadas ao programa final `python`.

- Extensões C são construídas pelo Makefile (veja `Modules/Setup`).

### 3.4.3. Alvos principais do Makefile

#### 3.4.3.1. make

Na maioria das vezes, ao reconstruir após editar algum código ou atualizar seu checkout do upstream, tudo que você precisa fazer é executar `make`, que (pela semântica do Make) constrói o alvo padrão, o primeiro definido no Makefile. Por tradição (inclusive no projeto CPython) este é geralmente o alvo `all`. O script `configure` expande uma variável `autoconf`, `@DEF_MAKE_ALL_RULE@` para descrever precisamente quais alvos `make all` serão construídos. As três opções são:

- `profile-opt` (configurado com `--enable-optimizations`)

- `build_wasm` (escolhido se a plataforma host corresponder a `wasm32-wasi*` ou `wasm32-emscripten`)

- `build_all` (configurado sem usar explicitamente nenhum dos outros)

Dependendo das alterações mais recentes no arquivo fonte, o Make irá reconstruir quaisquer alvos (arquivos objetos e executáveis) considerados desatualizados, incluindo executar `configure` novamente se necessário. As dependências de origem/alvo são muitas e mantidas manualmente, portanto, às vezes, o Make não tem todas as informações necessárias para detectar corretamente todos os alvos que precisam ser reconstruídos. Dependendo de quais destinos não são reconstruídos, você poderá enfrentar vários problemas. Se você tiver problemas de construção ou teste que você não pode explicar de outra forma, `make clean && make` deve resolver a maioria dos problemas de dependência, às custas de tempos de construção mais longos.

#### 3.4.3.2. make platform

Constrói o programa `python`, mas não constrói os módulos de extensão da biblioteca padrão. Isto gera um arquivo chamado `platform` que contém uma única linha descrevendo os detalhes da plataforma de construção, por exemplo, `macosx-14.3-arm64-3.12` ou `linux-x86_64-3.13`.

#### 3.4.3.3. make profile-opt

Constrói Python usando otimização guiada por perfil (PGO). Você pode usar a opção `--enable-optimizations` do configure para tornar este o alvo padrão do comando `make` (`make all` ou apenas `make`).

#### 3.4.3.4. make clean

Remove arquivos construídos.

#### 3.4.3.5. make distclean

Além do trabalho feito por `make clean`, remove os arquivos criados pelo script configure. `configure` terá que ser executado antes de construir novamente. [1]

#### 3.4.3.6. make install

Constrói o alvo `all` e instala o Python.

#### 3.4.3.7. make test

Constrói o alvo `all` e execute o conjunto de testes Python com a opção `--fast-ci` sem testes de GUI. Variáveis:

- `TESTOPTS`: opções adicionais de linha de comando regrtest.

- `TESTPYTHONOPTS`: opções adicionais de linha de comando do Python.

- `TESTTIMEOUT`: tempo limite em segundos (padrão: 10 minutos).

#### 3.4.3.8. make ci

Isso é semelhante ao `make test`, mas usa `-ugui` para também executar testes de GUI.

Adicionado na versão 3.14.

#### 3.4.3.9. make buildbottest

Isto é semelhante ao `make test`, mas usa a opção `--slow-ci` e o tempo limite padrão de 20 minutos, em vez da opção `--fast-ci`.

#### 3.4.3.10. make regen-all

Gera novamente (quase) todos os arquivos gerados. Isso inclui (mas não está limitado a) casos de bytecode e arquivo gerador de analisador sintático. `make regen-stdlib-module-names` e `autoconf` devem ser executados separadamente para os restantes arquivos gerados.

### 3.4.4. Extensões C

Algumas extensões C são construídas como módulos embutidos, como o módulo `sys`. Eles são construídos com a macro `Py_BUILD_CORE_BUILTIN` definida. Módulos embutidos não possuem nenhum atributo `__file__`:

    >>> import sys
    >>> sys
    <module 'sys' (built-in)>
    >>> sys.__file__
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    AttributeError: module 'sys' has no attribute '__file__'

Outras extensões C são construídas como bibliotecas dinâmicas, como o módulo `_asyncio`. Eles são construídos com a macro `Py_BUILD_CORE_MODULE` definida. Exemplo no Linux x86-64:

    >>> import _asyncio
    >>> _asyncio
    <module '_asyncio' from '/usr/lib64/python3.9/lib-dynload/_asyncio.cpython-39-x86_64-linux-gnu.so'>
    >>> _asyncio.__file__
    '/usr/lib64/python3.9/lib-dynload/_asyncio.cpython-39-x86_64-linux-gnu.so'

`Modules/Setup` é usado para gerar alvos Makefile para construir extensões C. No início dos arquivos, as extensões C são construídas como módulos embutidos. Extensões definidas após o marcador `*shared*` são construídas como bibliotecas dinâmicas.

As macros `PyAPI_FUNC()`, `PyAPI_DATA()` e `PyMODINIT_FUNC` de `Include/exports.h` são definidas de forma diferente dependendo se a macro `Py_BUILD_CORE_MODULE` está definida:

- Usa `Py_EXPORTED_SYMBOL` se `Py_BUILD_CORE_MODULE` estiver definido

- Do contrário, usa `Py_IMPORTED_SYMBOL`.

Se a macro `Py_BUILD_CORE_BUILTIN` for usada por engano em uma extensão C construída como uma biblioteca compartilhada, sua função `PyInit_xxx()` não será exportada, causando um `ImportError` na importação.

## 3.5. Sinalizadores do compilador e do vinculador

Opções definidas pelo script `./configure` e variáveis de ambiente e usadas por `Makefile`.

### 3.5.1. Sinalizadores do pré-processador

CONFIGURE_CPPFLAGS

  Valor da variável `CPPFLAGS` passado para o script `./configure`.

  Adicionado na versão 3.6.

CPPFLAGS

  Sinalizadores de pré-processador C++ / (Objective) C, p.ex. `-Iinclude_dir` se você tiver cabeçalhos em um diretório não padrão include_dir.

  Tanto `CPPFLAGS` quanto `LDFLAGS` precisam conter o valor do shell para poder construir módulos de extensão usando os diretórios especificados nas variáveis de ambiente.

BASECPPFLAGS

  Adicionado na versão 3.4.

PY_CPPFLAGS

  Sinalizadores extras de pré-processador adicionados para construir os arquivos de objeto do interpretador.

  Padrão: `$(BASECPPFLAGS) -I. -I$(srcdir)/Include $(CONFIGURE_CPPFLAGS) $(CPPFLAGS)`.

  Adicionado na versão 3.2.

### 3.5.2. Sinalizadores do compilador

CC

  Comando do compilador C.

  Exemplo: `gcc -pthread`.

CXX

  Comando do compilador C++.

  Exemplo: `g++ -pthread`.

CFLAGS

  Sinalizadores do compilador C.

CFLAGS_NODIST

  `CFLAGS_NODIST` é usado para construir o interpretador e extensões C da stdlib. Use-o quando um sinalizador do compilador não deve fazer parte de `CFLAGS` depois que o Python estiver instalado (gh-65320).

  Em particular, `CFLAGS` não deve conter:

  - o sinalizador do compilador `-I` (para definir o caminho de pesquisa para arquivos incluídos). Os sinalizadores `-I` são processadas da esquerda para a direita, e quaisquer sinalizadores em `CFLAGS` terão precedência sobre os sinalizadores `-I` fornecidos pelo usuário e pelo pacote.

  - sinalizadores de segurança como `-Werror` porque as distribuições não podem controlar se os pacotes instalados pelos usuários estão em conformidade com esses padrões elevados.

  Adicionado na versão 3.5.

COMPILEALL_OPTS

  Opções passadas para a linha de comando `compileall` ao construir arquivos PYC em `make install`. Padrão: `-j0`.

  Adicionado na versão 3.12.

EXTRA_CFLAGS

  Sinalizadores extra do compilador C.

CONFIGURE_CFLAGS

  Valor da variável `CFLAGS` passado para o script `./configure`.

  Adicionado na versão 3.2.

CONFIGURE_CFLAGS_NODIST

  Valor da variável `CFLAGS_NODIST` passado para o script `./configure`.

  Adicionado na versão 3.5.

BASECFLAGS

  Sinalizadores base do compilador.

OPT

  Sinalizadores de otimização.

CFLAGS_ALIASING

  Sinalizadores de alias estritos ou não estritos usados para compilar `Python/dtoa.c`.

  Adicionado na versão 3.7.

CCSHARED

  Sinalizadores de compilador usados para construir uma biblioteca compartilhada.

  Por exemplo, `-fPIC` é usado no Linux e no BSD.

CFLAGSFORSHARED

  Sinalizadores extras de C adicionados para construir os arquivos de objeto do interpretador.

  Padrão: `$(CCSHARED)` quando `--enable-shared` é usado, ou uma string vazia caso contrário.

PY_CFLAGS

  Padrão: `$(BASECFLAGS) $(OPT) $(CONFIGURE_CFLAGS) $(CFLAGS) $(EXTRA_CFLAGS)`.

PY_CFLAGS_NODIST

  Padrão: `$(CONFIGURE_CFLAGS_NODIST) $(CFLAGS_NODIST) -I$(srcdir)/Include/internal`.

  Adicionado na versão 3.5.

PY_STDMODULE_CFLAGS

  Sinalizadores do C usados para construir os arquivos de objeto do interpretador.

  Padrão: `$(PY_CFLAGS) $(PY_CFLAGS_NODIST) $(PY_CPPFLAGS) $(CFLAGSFORSHARED)`.

  Adicionado na versão 3.7.

PY_CORE_CFLAGS

  Padrão: `$(PY_STDMODULE_CFLAGS) -DPy_BUILD_CORE`.

  Adicionado na versão 3.2.

PY_BUILTIN_MODULE_CFLAGS

  Sinalizadores do compilador para construir um módulo de extensão de biblioteca padrão como um módulo embutido, como o módulo `posix`.

  Padrão: `$(PY_STDMODULE_CFLAGS) -DPy_BUILD_CORE_BUILTIN`.

  Adicionado na versão 3.8.

PURIFY

  Comando de Purify. Purify é um programa depurador de memória.

  Padrão: string vazia (não usada).

### 3.5.3. Sinalizadores do vinculador

LINKCC

  Comando do vinculador usado para construir programas como `python` e `_testembed`.

  Padrão: `$(PURIFY) $(CC)`.

CONFIGURE_LDFLAGS

  Valor da variável `LDFLAGS` passado para o script `./configure`.

  Evite atribuir `CFLAGS`, `LDFLAGS`, etc. para que os usuários possam usá-los na linha de comando para anexar a esses valores sem pisotear os valores predefinidos.

  Adicionado na versão 3.2.

LDFLAGS_NODIST

  `LDFLAGS_NODIST` é usado da mesma maneira que `CFLAGS_NODIST`. Use-o quando um sinalizador de vinculador não fizer parte de `LDFLAGS` depois que o Python estiver instalado (gh-65320).

  Em particular, `LDFLAGS` não deve conter:

  - o sinalizador do compilador `-L` (para definir o caminho de pesquisa para arquivos incluídos). Os sinalizadores `-L` são processadas da esquerda para a direita, e quaisquer sinalizadores em `LDFLAGS` terão precedência sobre os sinalizadores `-L` fornecidos pelo usuário e pelo pacote.

CONFIGURE_LDFLAGS_NODIST

  Valor da variável `LDFLAGS_NODIST` passado para o script `./configure`.

  Adicionado na versão 3.8.

LDFLAGS

  Sinalizadores do vinculador, p.ex. `-Llib_dir`, se você tiver bibliotecas em um diretório não padrão lib_dir.

  Tanto `CPPFLAGS` quanto `LDFLAGS` precisam conter o valor do shell para poder construir módulos de extensão usando os diretórios especificados nas variáveis de ambiente.

LIBS

  Sinalizadores do vinculador para passar bibliotecas para o vinculador ao vincular o executável Python.

  Exemplo: `-lrt`.

LDSHARED

  Comando para construir uma biblioteca compartilhada.

  Padrão: `@LDSHARED@ $(PY_LDFLAGS)`.

BLDSHARED

  Comando para construir a biblioteca compartilhada `libpython`.

  Padrão: `@BLDSHARED@ $(PY_CORE_LDFLAGS)`.

PY_LDFLAGS

  Padrão: `$(CONFIGURE_LDFLAGS) $(LDFLAGS)`.

PY_LDFLAGS_NODIST

  Padrão: `$(CONFIGURE_LDFLAGS_NODIST) $(LDFLAGS_NODIST)`.

  Adicionado na versão 3.8.

PY_CORE_LDFLAGS

  Sinalizadores de vinculador usados para construir os arquivos de objeto do interpretador.

  Adicionado na versão 3.8.

Notas de rodapé

[1]

`git clean -fdx` é uma maneira ainda mais extrema de “limpar” seu checkout. Ele remove todos os arquivos não conhecidos pelo Git. Ao procurar bugs usando `git bisect`, isso é recomendado entre testes para garantir uma construção completamente limpa. Use com cuidado, pois isso excluirá todos os arquivos não registrados no Git, incluindo seu trabalho novo e não confirmado.