# O que há de novo no Python 3.14

Editores:

  Adam Turner e Hugo van Kemenade

Este artigo explica os novos recursos no Python 3.14, em comparação com 3.13. Python 3.14 foi lançado em 7 de outubro de 2025. Veja changelog para uma lista completa de mudanças.

Ver também

PEP 745 – Cronograma de lançamento do Python 3.14

## Resumo – Destaques da versão

Python 3.14 é a versão estável mais recente da linguagem de programação Python, com uma mistura de alterações na linguagem, na implementação e na biblioteca padrão. As maiores mudanças incluem literais de string template, avaliação adiada de anotações e suporte para subinterpretadores na biblioteca padrão.

As mudanças na biblioteca incluem recursos significativamente melhorados para introspecção no asyncio, suporte para Zstandard por meio de um novo módulo `compression.zstd`, destaque de sintaxe no REPL, bem como as descontinuações e remoções habituais e melhorias na facilidade de uso e correção.

Este artigo não tenta fornecer uma especificação completa de todos os novos recursos, mas fornece uma visão geral conveniente. Para detalhes completos, consulte a documentação, como Referência da Biblioteca e Referência da Linguagem. Para entender a implementação completa e a justificativa do design para uma mudança, consulte a PEP para um novo recurso específico; mas observe que as PEPs geralmente não são mantidas atualizadas depois que um recurso é totalmente implementado. Veja Portando para o Python 3.14 para orientação sobre atualização a partir de versões anteriores do Python.

Melhorias no interpretador:

- PEP 649 e PEP 749: Avaliação adiada de anotações

- PEP 734: Múltiplos interpretadores na biblioteca padrão

- PEP 750: Strings template

- PEP 758: Permitir expressões except e except* sem parênteses

- PEP 765: Fluxo de controle em blocos finally

- PEP 768: Interface de depurador externo segura para CPython

- Um novo tipo de interpretador

- Melhorias no modo com threads livres

- Mensagens de erro melhoradas

- Coleta de lixo incremental

Melhorias significativas na biblioteca padrão:

- PEP 784: Suporte ao Zstandard na biblioteca padrão

- Capacidades de introspecção assíncrona

- Controle de avisos seguros simultâneos

- Realce de sintaxe no console interativo padrão e saída colorida em várias CLIs de biblioteca padrão

Melhorias na API C:

- PEP 741: API C de configuração do Python

Suporte à plataforma:

- PEP 776: Emscripten agora é uma plataforma oficialmente com suporte, no nível 3.

Alterações na versão:

- PEP 779: Python com threads livres é oficialmente suportado

- PEP 761: Assinaturas PGP foram descontinuadas de lançamentos oficiais

- Versões binárias de Windows e macOS agora oferecem suporte ao compilador experimental just-in-time

- Versões binárias para Android são agora fornecidas

## Novas funcionalidades

### PEP 649 e PEP 749: Avaliação adiada de anotações

As anotações em funções, classes e módulos não são mais avaliados de forma ansiosa. Em vez disso, as anotações são armazenadas em uma função de anotação com propósito especial e avaliadas somente quando necessário (exceto se `from __future__ import annotations` for usado).

Essa alteração foi projetada para melhorar o desempenho e usabilidade de anotações no Python na maioria das circunstâncias. O custo em tempo de execução para definir anotação é minimizado, mas continua sendo possível introspectar anotação em tempo de execução. Não é mais necessário incluir anotação em strings se eles contiverem referências futuras.

O novo módulo `annotationlib` fornece ferramentas para inspecionar anotação adiada. A anotação pode ser avaliada nos formatos `VALUE` (que avalia anotações para valores em tempo de execução, semelhante ao comportamento nas versões anteriores do Python), `FORWARDREF` (que substitui nomes indefinidos por marcadores especiais) e `STRING` (que retorna anotações como strings).

Este exemplo mostra como esses formatos se comportam:

    >>> from annotationlib import get_annotations, Format
    >>> def func(arg: Undefined):
    ...     pass
    >>> get_annotations(func, format=Format.VALUE)
    Traceback (most recent call last):
      ...
    NameError: name 'Undefined' is not defined
    >>> get_annotations(func, format=Format.FORWARDREF)
    {'arg': ForwardRef('Undefined', owner=<function func at 0x...>)}
    >>> get_annotations(func, format=Format.STRING)
    {'arg': 'Undefined'}

A seção Portando contém orientações sobre alterações que podem ser necessárias devido a essas mudanças, embora na maioria dos casos, o código continuará funcionando como está.

(Contribuição de Jelle Zijlstra em PEP 749 e gh-119180, PEP 649 foi escrita por Larry Hastings.)

Ver também

PEP 649

  Avaliação adiada de anotações usando descritores

PEP 749

  Implementando a PEP 649

### PEP 734: Múltiplos interpretadores na biblioteca padrão

O ambiente de execução do CPython permite a execução simultânea de várias cópias do Python no mesmo processo há mais de 20 anos. Cada uma dessas cópias separadas é chamada de “interpretador”. No entanto, o recurso estava disponível apenas por meio da API C.

Essa limitação foi removida no Python 3.14, com o novo módulo `concurrent.interpreters`.

Há pelo menos duas razões importantes pelas quais o uso de múltiplos interpretadores traz benefícios significativos:

- eles oferecem suporte a um novo modelo (para Python) de simultaneidade, amigável ao ser humano

- verdadeiro paralelismo multi-core

Para alguns casos de uso, a simultaneidade em software melhora a eficiência e pode simplificar o design em alto nível. Ao mesmo tempo, implementar e manter todos os tipos de simultaneidade, exceto as mais simples, costuma ser uma luta para o cérebro humano. Isso se aplica especialmente a threads simples (por exemplo, `threading`), onde toda a memória é compartilhada entre todas as threads.

Com múltiplos interpretadores isolados, você pode aproveitar uma classe de modelos de simultaneidade, como Communicating Sequential Processes (CSP) ou o modelo de ator, que obtiveram sucesso em outras linguagens de programação, como Smalltalk, Erlang, Haskell e Go. Pense em múltiplos interpretadores como threads, mas com compartilhamento opcional.

Sobre o paralelismo multinúcleo: a partir do Python 3.12, os interpretadores agora estão suficientemente isolados uns dos outros para serem usados em paralelo (veja PEP 684). Isso destrava uma variedade de casos de uso intensivos de CPU para Python que eram limitados pela GIL.

O uso de múltiplos interpretadores é semelhante em muitos aspectos ao `multiprocessing`, pois ambos fornecem “processos” lógicos isolados que podem ser executados em paralelo, sem compartilhamento por padrão. No entanto, ao usar múltiplos interpretadores, uma aplicação usará menos recursos do sistema e operará com mais eficiência (já que permanece dentro do mesmo processo). Pense em múltiplos interpretadores como se tivessem o isolamento de processos com a eficiência de threads.

Embora o recurso já exista há décadas, múltiplos interpretadores não têm sido amplamente utilizados devido à baixa conscientização e à ausência de um módulo da biblioteca padrão. Consequentemente, eles atualmente apresentam diversas limitações notáveis, que devem melhorar significativamente agora que o recurso finalmente está se tornando popular.

Limitações atuais:

- iniciar cada interpretador ainda não foi otimizado

- cada interpretador usa mais memória do que o necessário (o trabalho continua no compartilhamento interno extensivo entre interpretadores)

- não há muitas opções ainda para realmente compartilhar objetos ou outros dados entre interpretadores (além de `memoryview`)

- muitos módulos de extensão de terceiros no PyPI ainda não são compatíveis com múltiplos interpretadores (os módulos de extensão de biblioteca padrão são compatíveis)

- a abordagem para escrever aplicações que usam vários interpretadores isolados é, em grande parte, desconhecida para usuários do Python, por enquanto

O impacto dessas limitações dependerá de futuras melhorias no CPython, do uso dos interpretadores e do que a comunidade resolver por meio dos pacotes PyPI. Dependendo do caso de uso, as limitações podem não ter muito impacto, então experimente!

Além disso, versões futuras do CPython reduzirão ou eliminarão a sobrecarga e fornecerão utilitários menos apropriados no PyPI. Enquanto isso, a maioria das limitações também pode ser solucionada por meio de módulos de extensão, o que significa que os pacotes do PyPI podem preencher qualquer lacuna da versão 3.14 e até mesmo da versão 3.12, onde os interpretadores foram finalmente isolados adequadamente e pararam de compartilhar a GIL. Da mesma forma, espera-se que bibliotecas no PyPI surjam para abstrações de alto nível sobre os interpretadores.

Em relação aos módulos de extensão, estamos trabalhando para atualizar alguns projetos PyPI, bem como ferramentas como Cython, pybind11, nanobind e PyO3. As etapas para isolar um módulo de extensão podem ser encontradas em Isolando módulos de extensão. O isolamento de um módulo tem muitas sobreposições com o que é necessário para oferecer suporte a threads livres, portanto, o trabalho contínuo da comunidade nessa área ajudará a acelerar o suporte a múltiplos interpretadores.

Também adicionado no 3.14: concurrent.futures.InterpreterPoolExecutor.

(Contribuição de Eric Snow em gh-134939)

Ver também

PEP 734

### PEP 750: literal de string template

Strings template são um novo mecanismo para processamento personalizado de strings. Elas compartilham a sintaxe familiar das f-strings, mas, diferentemente das f-strings, retornam um objeto que representa as partes estáticas e interpoladas da string, em vez de um simples `str`.

Para escrever uma t-string, use um prefixo `'t'` em vez de `'f'`:

    >>> variety = 'Stilton'
    >>> template = t'Experimente um pouco de queijo {variety}!'
    >>> type(template)
    <class 'string.templatelib.Template'>

Objetos `Template` fornecem acesso às partes estáticas e interpoladas (entre chaves) de uma string antes de serem combinadas. Itere sobre instâncias de `Template` para acessar suas partes em ordem:

    >>> list(template)
    ['Experimente um pouco de queijo ', Interpolation('Stilton', 'variety', None, ''), '!']

É fácil escrever (ou chamar) código para processar instâncias de `Template`. Por exemplo, aqui está uma função que renderiza partes estáticas em minúsculas e instâncias de `Interpolation` em maiúsculas:

    from string.templatelib import Interpolation

    def lower_upper(template):
        """Render static parts lowercase and interpolations uppercase."""
        parts = []
        for part in template:
            if isinstance(part, Interpolation):
                parts.append(str(part.value).upper())
            else:
                parts.append(part.lower())
        return ''.join(parts)

    name = 'Wenslydale'
    template = t'Mister {name}'
    assert lower_upper(template) == 'mister WENSLYDALE'

Como as instâncias de `Template` distinguem entre strings estáticas e interpolações em tempo de execução, elas podem ser úteis para sanitizar a entrada do usuário. Escrever uma função `html()` que escape a entrada do usuário em HTML é um exercício deixado para o leitor! O código de processamento de template pode proporcionar maior flexibilidade. Por exemplo, uma função `html()` mais avançada poderia aceitar um `dict` de atributos HTML diretamente no template:

    attributes = {'src': 'limburger.jpg', 'alt': 'lovely cheese'}
    template = t'<img {attributes}>'
    assert html(template) == '<img src="limburger.jpg" alt="lovely cheese" />'

É claro que o código de processamento de template não precisa retornar um resultado semelhante a uma string. Uma função `html()` ainda mais avançada poderia retornar um tipo personalizado representando uma estrutura semelhante a um DOM.

Com t-strings, os desenvolvedores podem escrever sistemas higienizam SQL, fazer operações de shell seguras, melhorar o registro, abordar ideias modernas em desenvolvimento web (HTML, CSS e assim por diante) e implementar DSLs comerciais leves e personalizadas.

(Contribuição de Jim Baker, Guido van Rossum, Paul Everitt, Koudai Aono, Lysandros Nikolaou, Dave Peck, Adam Turner, Jelle Zijlstra, Bénédikt Tran e Pablo Galindo Salgado em gh-132661.)

Ver também

PEP 750.

### PEP 768: Interface segura para depurador externo

O Python 3.14 introduz uma interface de depuração sem sobrecarga que permite que depuradores e perfiladores se conectem com segurança a processos Python em execução sem interrompê-los ou reiniciá-los. Esta é uma melhoria significativa nos recursos de depuração do Python, o que significa que alternativas inseguras não são mais necessárias.

A nova interface fornece pontos de execução seguros para anexar código do depurador sem modificar o caminho de execução normal do interpretador ou adicionar qualquer sobrecarga em tempo de execução. Graças a isso, as ferramentas agora podem inspecionar e interagir com aplicações Python em tempo real, um recurso crucial para sistemas de alta disponibilidade e ambientes de produção.

Por conveniência, essa interface é implementada na função `sys.remote_exec()`. Por exemplo:

    import sys
    from tempfile import NamedTemporaryFile

    with NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
        script_path = f.name
        f.write(f'import my_debugger; my_debugger.connect({os.getpid()})')

    # Executa no processo com PID 1234
    print('Behold! An offering:')
    sys.remote_exec(1234, script_path)

Esta função permite o envio de código Python para ser executado em um processo de destino no próximo ponto de execução seguro. No entanto, os autores da ferramenta também podem implementar o protocolo diretamente, conforme descrito na PEP, que detalha os mecanismos subjacentes usados para anexar com segurança a processos em execução.

A interface de depuração foi cuidadosamente projetada com a segurança em mente e inclui vários mecanismos para controlar o acesso:

- Uma variável de ambiente `PYTHON_DISABLE_REMOTE_DEBUG`.

- Uma opção de linha de comando `-X disable-remote-debug`.

- Um sinalizador de configuração `--without-remote-debug` para desabilitar completamente o recurso no momento da construção.

(Contribuição de Pablo Galindo Salgado, Matt Wozniski e Ivona Stojanovic em gh-131591.)

Ver também

PEP 768.

### Um novo tipo de interpretador

Um novo tipo de interpretador foi adicionado ao CPython. Ele utiliza chamadas de cauda entre pequenas funções C que implementam opcodes Python individuais, em vez de uma única instrução `case` C. Para alguns compiladores mais recentes, este interpretador oferece desempenho significativamente melhor. Benchmarks preliminares sugerem uma média geométrica de 3 a 5% mais rápida no conjunto de benchmarks padrão `pyperformance`, dependendo da plataforma e da arquitetura. A linha de base é o Python 3.14, construído com o Clang 19, sem este novo interpretador.

Atualmente, este interpretador funciona apenas com o Clang 19 e versões mais recentes em arquiteturas x86-64 e AArch64. No entanto, espera-se que uma versão futura do GCC também ofereça suporte a ele.

Este recurso é opcional por enquanto. É altamente recomendável habilitar a otimização guiada por perfil ao usar o novo interpretador, pois é a única configuração testada e validada para melhorar o desempenho. Para mais informações, consulte `--with-tail-call-interp`.

Nota

Isso não deve ser confundido com a otimização de chamada de cauda de funções Python, que atualmente não está implementada no CPython.

Este novo tipo de interpretador é um detalhe de implementação interna do interpretador CPython. Ele não altera em nada o comportamento visível dos programas Python. Pode melhorar o desempenho deles, mas não altera nada mais.

(Contribuição de Ken Jin em gh-128563, com ideias sobre como implementar isso em CPython por Mark Shannon, Garrett Gu, Haoran Xu e Josh Haberman.)

### Melhorias no modo com threads livres

O modo de threads livres do CPython (PEP 703), adicionado inicialmente na versão 3.13, foi significativamente aprimorado no Python 3.14. A implementação descrita no PEP 703 foi concluída, incluindo alterações na API C, e soluções temporárias no interpretador foram substituídas por soluções mais permanentes. O interpretador adaptativo especializado (PEP 659) agora está habilitado no modo de threads livres, o que, juntamente com muitas outras otimizações, melhora significativamente seu desempenho. A perda de desempenho em código de thread única no modo de threads livres agora é de aproximadamente 5 a 10%, dependendo da plataforma e do compilador C utilizados.

A partir do Python 3.14, ao compilar módulos de extensão para a construção do CPython com threads livres no Windows, a variável de pré-processador `Py_GIL_DISABLED` agora precisa ser especificada pelo backend de construção, pois não será mais determinada automaticamente pelo compilador C. Para um interpretador em execução, a configuração usada em tempo de compilação pode ser encontrada usando `sysconfig.get_config_var()`.

O novo sinalizador `-X context_aware_warnings` controla se o controle de avisos seguros concorrentes está habilitado. O sinalizador padrão é true para a construção com threads livres e false para a construção com a GIL habilitada.

Um novo sinalizador `thread_inherit_context` foi adicionado, o que, se habilitado, significa que threads criadas com `threading.Thread` iniciam com uma cópia de `Context()` do chamador de `start()`. Mais significativamente, isso faz com que o contexto de filtragem de avisos estabelecido por `catch_warnings` seja “herdado” por threads (ou tarefas assíncronas) iniciadas dentro desse contexto. Isso também afeta outros módulos que usam variáveis de contexto, como o gerenciador de contexto `decimal`. Este sinalizador assume como padrão true para a construção com threads livres e false para a construção com a GIL habilitada.

(Contribuição de Sam Gross, Matt Page, Neil Schemenauer, Thomas Wouters, Donghee Na, Kirill Podoprigora, Ken Jin, Itamar Oren, Brett Simmers, Dino Viehland, Nathan Goldbaum, Ralf Gommers, Lysandros Nikolaou, Kumar Aditya, Edgar Margffoy e muitos outros. Alguns desses colaboradores são funcionários da Meta, que continuou a fornecer recursos de engenharia significativos para dar suporte a este projeto.)

### Mensagens de erro melhoradas

- O interpretador agora fornece sugestões úteis ao detectar erros de digitação em palavras reservadas do Python. Ao encontrar uma palavra que se assemelha muito a uma palavra reservada do Python, o interpretador sugere a palavra reservada correta na mensagem de erro. Esse recurso ajuda os programadores a identificar e corrigir rapidamente erros comuns de digitação. Por exemplo:

      >>> whille True:
      ...     pass
      Traceback (most recent call last):
        File "<stdin>", line 1
          whille True:
          ^^^^^^
      SyntaxError: invalid syntax. Did you mean 'while'?

  Embora o recurso se concentre nos casos mais comuns, algumas variações de erros ortográficos ainda podem resultar em erros de sintaxe comuns. (Contribuição de Pablo Galindo em gh-132449.)

- Instruções `elif` que seguem um bloco `else` agora têm uma mensagem de erro específica. (Contribuição de Steele Farnsworth em gh-129902.)

      >>> if who == "eu":
      ...     print("Sou eu!")
      ... else:
      ...     print("Não sou eu!")
      ... elif who is None:
      ...     print("Quem é?")
      File "<stdin>", line 5
        elif who is None:
        ^^^^
      SyntaxError: 'elif' block follows an 'else' block

- Se uma instrução for passada para Expressões condicionais após `else`, ou uma dentre `pass`, `break` ou `continue` for passada antes de `if`, a mensagem de erro destacará onde a `expressão` é necessária. (Contribuição de Sergey Miryanov em gh-129515.)

      >>> x = 1 if True else pass
      Traceback (most recent call last):
        File "<string>", line 1
          x = 1 if True else pass
                             ^^^^
      SyntaxError: expected expression after 'else', but statement is given

      >>> x = continue if True else break
      Traceback (most recent call last):
        File "<string>", line 1
          x = continue if True else break
              ^^^^^^^^
      SyntaxError: expected expression before 'if', but statement is given

- Quando strings fechadas incorretamente são detectadas, a mensagem de erro sugere que pode ser que a intenção era a string ser parte da string. (Contribuição de Pablo Galindo em gh-88535.)

      >>> "O objeto interessante "O objeto interessante" é muito importante"
      Traceback (most recent call last):
      SyntaxError: invalid syntax. Is this intended to be part of the string?

- Quando strings têm prefixos incompatíveis, o erro agora mostra quais prefixos são incompatíveis. (Contribuição de Nikita Sobolev em gh-133197.)

      >>> ub'abc'
        File "<python-input-0>", line 1
          ub'abc'
          ^^
      SyntaxError: 'u' and 'b' prefixes are incompatible

- Mensagens de erro aprimoradas ao usar `as` com alvos incompatíveis em:

  - Importações: `import ... as ...`

  - Importações “from”: `from ... import ... as ...`

  - Manipuladores “except”: `except ... as ...`

  - Casos de correspondência de padrão: `case ... as ...`

  (Contribuição de Nikita Sobolev in gh-123539, gh-123562 e gh-123440.)

- Mensagem de erro aprimorada ao tentar adicionar uma instância de um tipo não-hasheável a um `dict` ou `set`. (Contribuição de CF Bolz-Tereick e Victor Stinner em gh-132828.)

      >>> s = set()
      >>> s.add({'pages': 12, 'grade': 'A'})
      Traceback (most recent call last):
        File "<python-input-1>", line 1, in <module>
          s.add({'pages': 12, 'grade': 'A'})
          ~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
      TypeError: cannot use 'dict' as a set element (unhashable type: 'dict')
      >>> d = {}
      >>> l = [1, 2, 3]
      >>> d[l] = 12
      Traceback (most recent call last):
        File "<python-input-4>", line 1, in <module>
          d[l] = 12
          ~^^^
      TypeError: cannot use 'list' as a dict key (unhashable type: 'list')

- Melhoria na mensagem de erro quando um objeto que oferece suporte ao protocolo do gerenciador de contexto síncrono é inserido usando `async with` em vez de `with`, e vice-versa para o protocolo do gerenciador de contexto assíncrono. (Contribuição de Bénédikt Tran em gh-128398.)

### Suporte ao Zstandard na biblioteca padrão

O novo pacote `compression` contém os módulos `compression.lzma`, `compression.bz2`, `compression.gzip` e `compression.zlib`, que reexportam os módulos `lzma`, `bz2`, `gzip` e `zlib`, respectivamente. Os novos nomes de importação em `compression` são os nomes preferidos para a importação desses módulos de compactação no Python 3.14. No entanto, os nomes dos módulos existentes não foram descontinuados. Qualquer descontinuação ou remoção dos módulos de compressão existentes ocorrerá no mínimo cinco anos após o lançamento da versão 3.14.

O novo módulo `compression.zstd` fornece APIs de compactação e descompactação para o formato Zstandard por meio de ligações à biblioteca zstd da Meta. O Zstandard é um formato de compactação amplamente adotado, altamente eficiente e rápido. Além das APIs introduzidas em `compression.zstd`, o suporte para leitura e gravação de arquivos compactados do Zstandard foi adicionado aos módulos `tarfile`, `zipfile` e `shutil`.

Aqui está um exemplo de uso do novo módulo para compactar alguns dados:

    from compression import zstd
    import math

    data = str(math.pi).encode() * 20
    compressed = zstd.compress(data)
    ratio = len(compressed) / len(data)
    print(f"Achieved compression ratio of {ratio}")

Como pode ser visto, a API é semelhante às APIs dos módulos `lzma` e `bz2`.

(Contribuição de Emma Harper Smith, Adam Turner, Gregory P. Smith, Tomas Roun, Victor Stinner e Rogdham em gh-132983.)

Ver também

PEP 784.

### Capacidades de introspecção assíncrona

Foi adicionada uma nova interface de linha de comando para inspecionar processos Python em execução usando tarefas assíncronas, disponível via `python -m asyncio ps PID` ou `python -m asyncio pstree PID`.

O subcomando `ps` inspeciona o ID do processo (PID) fornecido e exibe informações sobre as tarefas assíncronas em execução. Ela gera uma tabela de tarefas: uma lista simples de todas as tarefas, seus nomes, suas pilhas de corrotinas e quais tarefas as aguardam.

O subcomando `pstree` busca as mesmas informações, mas em vez disso renderiza uma árvore de chamadas assíncrona visual, mostrando os relacionamentos das corrotinas em um formato hierárquico. Este comando é particularmente útil para depurar programas assíncronos de longa duração ou travados. Ele pode ajudar os desenvolvedores a identificar rapidamente onde um programa está bloqueado, quais tarefas estão pendentes e como as corrotinas estão encadeadas.

Por exemplo, dado este código:

    import asyncio

    async def play_track(track):
        await asyncio.sleep(5)
        print(f'🎵 Finished: {track}')

    async def play_album(name, tracks):
        async with asyncio.TaskGroup() as tg:
            for track in tracks:
                tg.create_task(play_track(track), name=track)

    async def main():
        async with asyncio.TaskGroup() as tg:
            tg.create_task(
              play_album('Sundowning', ['TNDNBTG', 'Levitate']),
              name='Sundowning')
            tg.create_task(
              play_album('TMBTE', ['DYWTYLM', 'Aqua Regia']),
              name='TMBTE')

    if __name__ == '__main__':
        asyncio.run(main())

Executar a nova ferramenta no processo em execução produzirá uma tabela como esta:

    python -m asyncio ps 12345

    tid        task id              task name            coroutine stack                                    awaiter chain                                      awaiter name    awaiter id
    ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    1935500    0x7fc930c18050       Task-1               TaskGroup._aexit -> TaskGroup.__aexit__ -> main                                                                       0x0
    1935500    0x7fc930c18230       Sundowning           TaskGroup._aexit -> TaskGroup.__aexit__ -> album   TaskGroup._aexit -> TaskGroup.__aexit__ -> main    Task-1          0x7fc930c18050
    1935500    0x7fc93173fa50       TMBTE                TaskGroup._aexit -> TaskGroup.__aexit__ -> album   TaskGroup._aexit -> TaskGroup.__aexit__ -> main    Task-1          0x7fc930c18050
    1935500    0x7fc93173fdf0       TNDNBTG              sleep -> play                                      TaskGroup._aexit -> TaskGroup.__aexit__ -> album   Sundowning      0x7fc930c18230
    1935500    0x7fc930d32510       Levitate             sleep -> play                                      TaskGroup._aexit -> TaskGroup.__aexit__ -> album   Sundowning      0x7fc930c18230
    1935500    0x7fc930d32890       DYWTYLM              sleep -> play                                      TaskGroup._aexit -> TaskGroup.__aexit__ -> album   TMBTE           0x7fc93173fa50
    1935500    0x7fc93161ec30       Aqua Regia           sleep -> play                                      TaskGroup._aexit -> TaskGroup.__aexit__ -> album   TMBTE           0x7fc93173fa50

ou uma árvore como esta:

    python -m asyncio pstree 12345

    └── (T) Task-1
        └──  main example.py:13
            └──  TaskGroup.__aexit__ Lib/asyncio/taskgroups.py:72
                └──  TaskGroup._aexit Lib/asyncio/taskgroups.py:121
                    ├── (T) Sundowning
                    │   └──  album example.py:8
                    │       └──  TaskGroup.__aexit__ Lib/asyncio/taskgroups.py:72
                    │           └──  TaskGroup._aexit Lib/asyncio/taskgroups.py:121
                    │               ├── (T) TNDNBTG
                    │               │   └──  play example.py:4
                    │               │       └──  sleep Lib/asyncio/tasks.py:702
                    │               └── (T) Levitate
                    │                   └──  play example.py:4
                    │                       └──  sleep Lib/asyncio/tasks.py:702
                    └── (T) TMBTE
                        └──  album example.py:8
                            └──  TaskGroup.__aexit__ Lib/asyncio/taskgroups.py:72
                                └──  TaskGroup._aexit Lib/asyncio/taskgroups.py:121
                                    ├── (T) DYWTYLM
                                    │   └──  play example.py:4
                                    │       └──  sleep Lib/asyncio/tasks.py:702
                                    └── (T) Aqua Regia
                                        └──  play example.py:4
                                            └──  sleep Lib/asyncio/tasks.py:702

Se um ciclo for detectado no grafo async await (o que pode indicar um problema de programação), a ferramenta levanta um erro e lista os caminhos de ciclo que impedem a construção da árvore:

    python -m asyncio pstree 12345

    ERROR: await-graph contains cycles - cannot print a tree!

    cycle: Task-2 → Task-3 → Task-2

(Contribuição de Pablo Galindo, Łukasz Langa, Yury Selivanov e Marta Gomez Macias em gh-91048.)

### Controle de avisos seguros simultâneos

O gerenciador de contexto `warnings.catch_warnings` agora usará opcionalmente uma variável de contexto para filtros de aviso. Isso é habilitado definindo o sinalizador `context_aware_warnings`, seja com a opção de linha de comando `-X` ou com uma variável de ambiente. Isso fornece controle previsível de avisos ao usar `catch_warnings` combinado com múltiplas threads ou tarefas assíncronas. O sinalizador padrão é true para a construção com threads livres e false para a construção com GIL habilitada.

(Contribuição de Neil Schemenauer e Kumar Aditya em gh-130010.)

## Outras mudanças de linguagem

- Todas as páginas de código do Windows agora são suportadas como codecs ‘cpXXX’ no Windows. (Contribuição de Serhiy Storchaka em gh-123803.)

- Implementa regras aritméticas de modo misto combinando números reais e complexos, conforme especificado pelo C padrão desde C99. (Contribuição de Sergey B Kirpichev em gh-69639.)

- Mais erros de sintaxe agora são detectados, independentemente da otimização e da opção de linha de comando `-O`. Isso inclui escritas no `__debug__`, uso incorreto de `await` e compreensões assíncronas fora de funções assíncronas. Por exemplo, `python -O -c 'assert (__debug__ := 1)'` ou `python -O -c 'assert await 1'` agora produzem `SyntaxError`s. (Contribuição de Irit Katriel e Jelle Zijlstra em gh-122245 e gh-121637.)

- Ao criar uma subclasse de um tipo C puro, os slots C para o novo tipo não são mais substituídos por uma versão encapsulada na criação da classe, caso não sejam explicitamente substituídos na subclasse. (Contribuição de Tomasz Pytel em gh-132284.)

### Embutidos

- Os métodos `bytes.fromhex()` e `bytearray.fromhex()` agora aceitam objetos ASCII `bytes` e similares. (Contribuição de Daniel Pope em gh-129349.)

- Adiciona os métodos de classe `float.from_number()` e `complex.from_number()` para converter um número para o tipo `float` ou `complex`, respectivamente. Eles levantam um `TypeError` se o argumento não for um número real. (Contribuição de Serhiy Storchaka em gh-84978.)

- Suporte para sublinhado e vírgula como separadores de milhares na parte fracionária para tipos de apresentação de ponto flutuante do novo estilo de formatação de string (com `format()` ou Literais de strings formatadas). (Contribuição de Sergey B Kirpichev em gh-87790.)

- A função `int()` não delega mais para `__trunc__()`. Classes que desejam oferecer suporte a conversão para `int()` devem implementar `__int__()` ou `__index__()`. (Contribuição de Mark Dickinson em gh-119743.)

- A função `map()` agora possui um sinalizador somente-nomeado opcional strict, como `zip()`, para verificar se todos os iteráveis têm o mesmo comprimento. (Contribuição de Wannes Boeykens em gh-119793.)

- O tipo `memoryview` agora oferece suporte a subscrição, tornando-o um tipo genérico. (Contribuição de Brian Schubert em gh-126012.)

- Usa `NotImplemented` em um contexto booleano agora levantará `TypeError`. Isso levanta `DeprecationWarning` desde o Python 3.9. (Contribuição de Jelle Zijlstra em gh-118767.)

- `pow()` de três argumentos agora tenta chamar `__rpow__()` se necessário. Anteriormente, ele só era chamado em `pow()` de dois argumentos e no operador binário de potência. (Contribuição de Serhiy Storchaka em gh-130104.)

- Os objetos `super` agora são `copiáveis` e `serializáveis com pickle`. (Contribuição de Serhiy Storchaka em gh-125767.)

### Linha de comando e ambiente

- O sinalizador de tempo de importação agora pode rastrear módulos já carregados (‘em cache’), por meio da nova opção `-X importtime=2`. Quando um módulo desse tipo é importado, os tempos `self` e `cumulative` são substituídos pela string `cached`.

  Valores acima de `2` para `-X importtime` agora são reservados para uso futuro.

  (Contribuição de Noah Kim e Adam Turner em gh-118655.)

- A opção de linha de comando `-c` agora recua automaticamente seu argumento de código antes da execução. O comportamento de dedentação automática espelha `textwrap.dedent()`. (Contribuição de Jon Crall e Steven Sun em gh-103998.)

- `-J` não é mais um sinalizador reservado para Jython e agora não tem nenhum significado especial. (Contribuição de Adam Turner em gh-133336.)

### PEP 758: permite expressões `except` e `except*` sem parênteses

As expressões `except` e `except*` agora permitem a omissão de parênteses quando há vários tipos de exceção e a cláusula `as` não é usada. Por exemplo:

    try:
        connect_to_server()
    except TimeoutError, ConnectionRefusedError:
        print('A rede deixou de ser!')

(Contribuição de Pablo Galindo e Brett Cannon em PEP 758 e gh-131831.)

### PEP 765: Fluxo de controle em blocos `finally`

O compilador agora emite uma `SyntaxWarning` quando uma instrução `return`, `break` ou `continue` tem efeito ao sair de um bloco `finally`. Essa alteração é especificada na PEP 765.

Em situações em que essa alteração é inconveniente (como aquelas em que os avisos são redundantes devido à verificação de código), o filtro de avisos pode ser usado para desativar todos os avisos de sintaxe adicionando `ignore::SyntaxWarning` como filtro. Isso pode ser especificado em combinação com um filtro que converte outros avisos em erros (por exemplo, passando `-Werror -Wignore::SyntaxWarning` como opções da CLI ou definindo `PYTHONWARNINGS=error,ignore::SyntaxWarning`).

Observe que a aplicação desse filtro em tempo de execução usando o módulo `warnings` só suprimirá o aviso no código compilado após o ajuste do filtro. O código compilado antes do ajuste do filtro (por exemplo, quando um módulo é importado) ainda emitirá o aviso de sintaxe.

(Contribuição de Irit Katriel em gh-130080.)

### Coleta de lixo incremental

O coletor de lixo cíclico agora é incremental. Isso significa que os tempos máximos de pausa são reduzidos em uma ordem de magnitude ou mais para heaps maiores.

Agora existem apenas duas gerações: jovem e velha. Quando `gc.collect()` não é chamado diretamente, o coletor de lixo é invocado com um pouco menos de frequência. Quando invocado, ele coleta a geração jovem e um incremento da geração antiga, em vez de coletar uma ou mais gerações.

O comportamento de `gc.collect()` muda ligeiramente:

- `gc.collect(1)`: Executa um incremento da coleta de lixo, em vez de coletar a geração 1.

- Outras chamadas para `gc.collect()` não foram alteradas.

(Contribuição de Mark Shannon em gh-108362.)

### Console interativo padrão

- O console interativo padrão agora realça a sintaxe Python. O recurso é habilitado por padrão, exceto se `PYTHON_BASIC_REPL` ou qualquer outra variável de ambiente que desabilite cores estiver definida. Consulte Controlando cores para obter detalhes.

  O tema de cores padrão para realce de sintaxe busca um bom contraste e usa exclusivamente os códigos de cores ANSI padrão VGA de 4 bits para obter a máxima compatibilidade. O tema pode ser personalizado com o uso de uma API experimental `_colorize.set_theme()`. Isso pode ser chamado interativamente ou no script `PYTHONSTARTUP`. Observe que esta função tem nenhuma garantia de estabilidade e pode ser alterada ou removida.

  (Contribuição de Łukasz Langa em gh-131507.)

- O console interativo padrão agora oferece suporte ao preenchimento automático de importação. Isso significa que digitar `import co` e pressionar `<Tab>` vai sugerir módulos que começam com `co`. Da mesma forma, digitar `from concurrent import i` vai sugerir submódulos de `concurrent` que começam com `i`. Observe que o preenchimento automático de atributos de módulo não é suportado atualmente. (Contribuição de Tomas Roun em gh-69605.)

## Novos módulos

- `annotationlib`: Para introspecção de anotações. Veja PEP 749 para mais detalhes. (Contribuição de Jelle Zijlstra em gh-119180.)

- `compression` (incluindo `compression.zstd`): Um pacote para módulos relacionados à compactação, incluindo um novo módulo para oferecer suporte ao formato de compactação Zstandard. Consulte PEP 784 para mais detalhes. (Contribuição de Emma Harper Smith, Adam Turner, Gregory P. Smith, Tomas Roun, Victor Stinner e Rogdham em gh-132983.)

- `concurrent.interpreters`: Suporte para múltiplos interpretadores na biblioteca padrão. Consulte PEP 734 para mais detalhes. (Contribuição de Eric Snow em gh-134939.)

- `string.templatelib`: Suporte para literais de strings templates (t-strings). Veja PEP 750 para mais detalhes. (Contribuição de Jim Baker, Guido van Rossum, Paul Everitt, Koudai Aono, Lysandros Nikolaou, Dave Peck, Adam Turner, Jelle Zijlstra, Bénédikt Tran e Pablo Galindo Salgado em gh-132661.)

## Módulos melhorados

### argparse

- O valor padrão do nome do programa para `argparse.ArgumentParser` agora reflete a maneira como o interpretador Python foi instruído a encontrar o código do módulo `__main__`. (Contribuição de Serhiy Storchaka e Alyssa Coghlan em gh-66436.)

- Foi introduzido o parâmetro opcional suggest_on_error em `argparse.ArgumentParser`, permitindo sugestões para escolhas de argumentos e nomes de subanalisadores caso sejam digitados incorretamente pelo usuário. (Contribuição de Savannah Ostrowski em gh-124456.)

- Habilita a cor do texto de ajuda, que pode ser desabilitada com o parâmetro opcional color em `argparse.ArgumentParser`. Isso também pode ser controlado por variáveis de ambiente. (Contribuição de Hugo van Kemenade em gh-130645.)

### ast

- Adiciona `compare()`, uma função para comparar dois ASTs. (Contribuição de Batuhan Taskaya e Jeremy Hylton em gh-60191.)

- Adiciona suporte para `copy.replace()` para nós AST. (Contribuição de Bénédikt Tran em gh-121141.)

- Docstrings agora são removidas de um AST otimizado no nível de otimização 2. (Contribuição de Irit Katriel em gh-123958.)

- A saída `repr()` para nós AST agora inclui mais informações. (Contribuição de Tomas Roun em gh-116022.)

- Quando chamado com um AST como entrada, a função `parse()` agora sempre verifica se o tipo de nó raiz é apropriado. (Contribuição de Irit Katriel em gh-130139.)

- Adiciona novas opções à interface de linha de comando: `--feature-version`, `--optimize` e `--show-empty`. (Contribuição de Semyon Moroz em gh-133367.)

### asyncio

- A função e os métodos denominados `create_task()` agora aceitam uma lista arbitrária de argumentos nomeados. Todos os argumentos nomeados são passados para o construtor `Task` ou para a fábrica de tarefas personalizada. (Consulte `set_task_factory()` para obter detalhes.) Os argumentos nomeados `name` e `context` não são mais especiais; o nome agora deve ser definido usando o argumento nomeados `name` da fábrica, e `context` pode ser `None`.

  Isso afeta as seguintes funções e métodos: `asyncio.create_task()`, `asyncio.loop.create_task()`, `asyncio.TaskGroup.create_task()`.

  (Contribuição de Thomas Grainger em gh-128307.)

- Há duas novas funções utilitárias para introspecção e impressão do gráfico de chamadas de um programa: `capture_call_graph()` e `print_call_graph()`. Veja Capacidades de introspecção do asyncio para mais detalhes. (Contribuição de Yury Selivanov, Pablo Galindo Salgado e Łukasz Langa em gh-91048.)

### calendar

- Por padrão, a data de hoje é destacada em cores na saída de texto da linha de comando do `calendar`. Isso pode ser controlado pelas variáveis de ambiente. (Contribuição de Hugo van Kemenade em gh-128317.)

### concurrent.futures

- Adiciona uma nova classe executora, `InterpreterPoolExecutor`, que expõe vários interpretadores Python no mesmo processo (‘subinterpretadores’) ao código Python. Isso usa um conjunto de interpretadores Python independentes para executar chamadas de forma assíncrona.

  Isto é separado do novo módulo `interpreters` introduzido pela PEP 734. (Contribuição de Eric Snow em gh-124548.)

- On Unix platforms other than macOS, ‘forkserver’ is now the default start method for `ProcessPoolExecutor` (replacing ‘fork’). This change does not affect Windows or macOS, where ‘spawn’ remains the default start method.

  Se o método fork incompatível com threading for necessário, você deverá solicitá-lo explicitamente fornecendo um contexto de multiprocessamento mp_context para `ProcessPoolExecutor`.

  Veja as restrições de forkserver para obter informações e diferenças com o método fork e como essa alteração pode afetar o código existente com variáveis globais compartilhadas mutáveis e/ou objetos compartilhados que não podem ser automaticamente `serializadas com pickle`.

  (Contribuição de Gregory P. Smith em gh-84559.)

- Adiciona dois novos métodos a `ProcessPoolExecutor`, `terminate_workers()` e `kill_workers()`, como formas de encerrar ou eliminar todos os processos de trabalho ativos no pool fornecido. (Contribuição de Charles Machalow em gh-130849.)

- Adiciona o parâmetro opcional buffersize a `Executor.map`. para limitar o número de tarefas enviadas cujos resultados ainda não foram gerados. Se o buffer estiver cheio, a iteração sobre os iteráveis será pausada até que um resultado seja produzido pelo buffer. (Contribuição de Enzo Bonnal e Josh Rosenberg em gh-74028.)

### configparser

- `configparser` will no longer write config files it cannot read, to improve security. Attempting to `write()` keys containing delimiters or beginning with the section header pattern will raise an `InvalidWriteError`. (Contributed by Jacob Lincoln in gh-129270.)

### contextvars

- Adiciona suporte ao protocolo do gerenciador de contexto para objetos `Token`. (Contribuição de Andrew Svetlov em gh-129889.)

### ctypes

- The layout of bit fields in `Structure` and `Union` objects is now a closer match to platform defaults (GCC/Clang or MSVC). In particular, fields no longer overlap. (Contributed by Matthias Görgens in gh-97702.)

- O atributo de classe `Structure._layout_` agora pode ser definido para ajudar a corresponder a uma ABI não padrão. (Contribuição de Petr Viktorin em gh-97702.)

- A classe de descritores de campo `Structure`/`Union` agora está disponível como `CField` e possui novos atributos para auxiliar na depuração e na introspecção. (Contribuição de Petr Viktorin em gh-128715.)

- No Windows, a exceção `COMError` agora é pública. (Contribuição de Jun Komoda em gh-126686.)

- No Windows, a função `CopyComPointer()` agora é pública. (Contribuição de Jun Komoda em gh-127275.)

- Add `memoryview_at()`, a function to create a `memoryview` object that refers to the supplied pointer and length. This works like `ctypes.string_at()` except it avoids a buffer copy, and is typically useful when implementing pure Python callback functions that are passed dynamically-sized buffers. (Contributed by Rian Hunter in gh-112018.)

- Complex types, `c_float_complex`, `c_double_complex`, and `c_longdouble_complex`, are now available if both the compiler and the `libffi` library support complex C types. (Contributed by Sergey B Kirpichev in gh-61103.)

- Adiciona `ctypes.util.dllist()` para listar as bibliotecas compartilhadas carregadas pelo processo atual. (Contribuição de Brian Ward em gh-119349.)

- Move `ctypes.POINTER()` types cache from a global internal cache (`_pointer_type_cache`) to the `_CData.__pointer_type__` attribute of the corresponding `ctypes` types. This will stop the cache from growing without limits in some situations. (Contributed by Sergey Miryanov in gh-100926.)

- The `py_object` type now supports subscription, making it a generic type. (Contributed by Brian Schubert in gh-132168.)

- `ctypes` now supports free-threading builds. (Contributed by Kumar Aditya and Peter Bierma in gh-127945.)

### curses

- Add the `assume_default_colors()` function, a refinement of the `use_default_colors()` function which allows changing the color pair `0`. (Contributed by Serhiy Storchaka in gh-133139.)

### datetime

- Add the `strptime()` method to the `datetime.date` and `datetime.time` classes. (Contributed by Wannes Boeykens in gh-41431.)

### decimal

- Add `Decimal.from_number()` as an alternative constructor for `Decimal`. (Contributed by Serhiy Storchaka in gh-121798.)

- Expose `IEEEContext()` to support creation of contexts corresponding to the IEEE 754 (2008) decimal interchange formats. (Contributed by Sergey B Kirpichev in gh-53032.)

### difflib

- Comparison pages with highlighted changes generated by the `HtmlDiff` class now support ‘dark mode’. (Contributed by Jiahao Li in gh-129939.)

### dis

- Adiciona suporte para renderizar informações completas sobre o local da fonte de `instruções`, em vez de apenas o número da linha. Este recurso é adicionado às seguintes interfaces por meio do argumento nomeado show_positions:

  - `dis.Bytecode`

  - `dis.dis()`

  - `dis.distb()`

  - `dis.disassemble()`

  Esse recurso também é exposto via `dis --show-positions`. (Contribuição de Bénédikt Tran em gh-123165.)

- Adiciona a opção de linha de comando `dis --specialized` para mostrar o bytecode especializado. (Contribuição de Bénédikt Tran em gh-127413.)

### errno

- Add the `EHWPOISON` error code constant. (Contributed by James Roy in gh-126585.)

### faulthandler

- Add support for printing the C stack trace on systems that support it via the new `dump_c_stack()` function or via the c_stack argument in `faulthandler.enable()`. (Contributed by Peter Bierma in gh-127604.)

### fnmatch

- Add `filterfalse()`, a function to reject names matching a given pattern. (Contributed by Bénédikt Tran in gh-74598.)

### fractions

- A `Fraction` object may now be constructed from any object with the `as_integer_ratio()` method. (Contributed by Serhiy Storchaka in gh-82017.)

- Add `Fraction.from_number()` as an alternative constructor for `Fraction`. (Contributed by Serhiy Storchaka in gh-121797.)

### functools

- Add the `Placeholder` sentinel. This may be used with the `partial()` or `partialmethod()` functions to reserve a place for positional arguments in the returned partial object. (Contributed by Dominykas Grigonis in gh-119127.)

- Allow the initial parameter of `reduce()` to be passed as a keyword argument. (Contributed by Sayandip Dutta in gh-125916.)

### getopt

- Adiciona suporte para opções com argumento opcional. (Contribuição de Serhiy Storchaka em gh-126374.)

- Adiciona suporte para retornar opções misturadas e argumentos não-opcionais em ordem. (Contribuição de Serhiy Storchaka em gh-126390.)

### getpass

- Support keyboard feedback in the `getpass()` function via the keyword-only optional argument echo_char. Placeholder characters are rendered whenever a character is entered, and removed when a character is deleted. (Contributed by Semyon Moroz in gh-77065.)

### graphlib

- Allow `TopologicalSorter.prepare()` to be called more than once as long as sorting has not started. (Contributed by Daniel Pope in gh-130914.)

### heapq

- The `heapq` module has improved support for working with max-heaps, via the following new functions:

  - `heapify_max()`

  - `heappush_max()`

  - `heappop_max()`

  - `heapreplace_max()`

  - `heappushpop_max()`

### hmac

- Adiciona uma implementação embutido para HMAC (RFC 2104) usando código formalmente verificado do projeto HACL*. Esta implementação é usada como fallback quando a implementação OpenSSL do HMAC não está disponível. (Contribuição de Bénédikt Tran em gh-99108.)

### http

- As páginas de erro e listas de diretórios geradas pelo módulo `http.server` permitem que o navegador aplique seu modo escuro padrão. (Contribuição de Yorik Hansen em gh-123430.)

- O módulo `http.server` agora provê suporte para HTTPS usando a classe `http.server.HTTPSServer`. Essa funcionalidade é exposta pela interface de linha de comando (`python -m http.server`) por meio das seguintes opções:

  - `--tls-cert <path>`: Path to the TLS certificate file.

  - `--tls-key <path>`: Optional path to the private key file.

  - `--tls-password-file <path>`: Optional path to the password file for the private key.

  (Contribuição de Semyon Moroz em gh-85162.)

### imaplib

- Add `IMAP4.idle()`, implementing the IMAP4 `IDLE` command as defined in RFC 2177. (Contributed by Forest in gh-55454.)

### inspect

- `signature()` takes a new argument annotation_format to control the `annotationlib.Format` used for representing annotations. (Contributed by Jelle Zijlstra in gh-101552.)

- `Signature.format()` takes a new argument unquote_annotations. If true, string annotations are displayed without surrounding quotes. (Contributed by Jelle Zijlstra in gh-101552.)

- Add function `ispackage()` to determine whether an object is a package or not. (Contributed by Zhikang Yan in gh-125634.)

### io

- A leitura de texto de um fluxo sem bloqueio com `read` pode agora levantar um `BlockingIOError` se a operação não puder imediatamente retornar bytes. (Contribuição de Giovanni Siragusa em gh-109523.)

- Add the `Reader` and `Writer` protocols as simpler alternatives to the pseudo-protocols `typing.IO`, `typing.TextIO`, and `typing.BinaryIO`. (Contributed by Sebastian Rittau in gh-127648.)

### json

- Add exception notes for JSON serialization errors that allow identifying the source of the error. (Contributed by Serhiy Storchaka in gh-122163.)

- Allow using the `json` module as a script using the `-m` switch: python -m json. This is now preferred to python -m json.tool, which is soft deprecated. See the JSON command-line interface documentation. (Contributed by Trey Hunner in gh-122873.)

- Por padrão, a saída da interface de linha de comando JSON é destacada em cores. Isso pode ser controlado por variáveis de ambiente . (Contribuição de Tomas Roun em gh-131952.)

### linecache

- `getline()` can now retrieve source code for frozen modules. (Contributed by Tian Gao in gh-131638.)

### logging.handlers

- `QueueListener` objects now support the context manager protocol. (Contributed by Charles Machalow in gh-132106.)

- `QueueListener.start` agora levanta `RuntimeError` se o ouvinte já tiver sido iniciado. (Contribuição de Charles Machalow em gh-132106.)

### math

- Adicionadas mensagens de erro mais detalhadas para erros de domínio no módulo. (Contribuição de Charlie Zhao e Sergey B Kirpichev em gh-101410.)

### mimetypes

- Add a public command-line for the module, invoked via python -m mimetypes. (Contributed by Oleg Iarygin and Hugo van Kemenade in gh-93096.)

- Add several new MIME types based on RFCs and common usage:

  Microsoft and RFC 8081 MIME types for fonts

  - Embedded OpenType: `application/vnd.ms-fontobject`

  - OpenType Layout (OTF) `font/otf`

  - TrueType: `font/ttf`

  - WOFF 1.0 `font/woff`

  - WOFF 2.0 `font/woff2`

  RFC 9559 MIME types for Matroska audiovisual data container structures

  - áudio com nenhum vídeo: `audio/matroska` (`.mka`)

  - vídeo: `video/matroska` (`.mkv`)

  - vídeo estereoscópico: `video/matroska-3d` (`.mk3d`)

  Images with RFCs

  - RFC 1494: CCITT Group 3 (`.g3`)

  - RFC 3362: Real-time Facsimile, T.38 (`.t38`)

  - RFC 3745: JPEG 2000 (`.jp2`), extensão (`.jpx`) e composto (`.jpm`)

  - RFC 3950: Tag Image File Format Fax eXtended, TIFF-FX (`.tfx`)

  - RFC 4047: Flexible Image Transport System (`.fits`)

  - RFC 7903: Enhanced Metafile (`.emf`) and Windows Metafile (`.wmf`)

  Other MIME type additions and changes

  - RFC 2361: altera o tipo de `.avi` para `video/vnd.avi` e de `.wav` para `audio/vnd.wave`

  - RFC 4337: adiciona MPEG-4 `audio/mp4` (`.m4a`)

  - RFC 5334: adiciona mídia Ogg (`.oga`, `.ogg` e `.ogx`)

  - RFC 6713: adiciona gzip `aplication/gzip` (`.gz`)

  - RFC 9639: adiciona FLAC `audio/flac` (`.flac`)

  - RFC 9512 `application/yaml` MIME type for YAML files (`.yaml` and `.yml`)

  - Adiciona 7z `aplication/x-7z-compressed` (`.7z`)

  - Adiciona Android Package `application/vnd.android.package-archive` (`.apk`) quando não for rigoroso

  - Adiciona deb `application/x-debian-package` (`.deb`)

  - Adiciona glTF binário `model/gltf-binary` (`.glb`)

  - Adiciona glTF JSON/ASCII `model/gltf+json` (`.gltf`)

  - Adiciona M4V `video/x-m4v` (`.m4v`)

  - Adiciona PHP `application/x-httpd-php` (`.php`)

  - Adiciona RAR `application/vnd.rar` (`.rar`)

  - Adiciona RPM `application/x-rpm` (`.rpm`)

  - Adiciona STL `model/stl` (`.stl`)

  - Adiciona Windows Media Video `video/x-ms-wmv` (`.wmv`)

  - De facto: adiciona WebM `audio/webm` (`.weba`)

  - ECMA-376: adiciona tipos `.docx`, `.pptx` e `.xlsx`

  - OASIS: adiciona tipos OpenDocument `.odg`, `.odp`, `.ods` e `.odt`

  - W3C: adiciona EPUB `application/epub+zip` (`.epub`)

  (Contributed by Sahil Prajapati and Hugo van Kemenade in gh-84852, by Sasha “Nelie” Chernykh and Hugo van Kemenade in gh-132056, and by Hugo van Kemenade in gh-89416, gh-85957, and gh-129965.)

### multiprocessing

- On Unix platforms other than macOS, ‘forkserver’ is now the default start method (replacing ‘fork’). This change does not affect Windows or macOS, where ‘spawn’ remains the default start method.

  If the threading incompatible fork method is required, you must explicitly request it via a context from `get_context()` (preferred) or change the default via `set_start_method()`.

  Veja as restrições de forkserver para obter informações e diferenças com o método fork e como essa alteração pode afetar o código existente com variáveis globais compartilhadas mutáveis e/ou objetos compartilhados que não podem ser automaticamente `serializadas com pickle`.

  (Contribuição de Gregory P. Smith em gh-84559.)

- `multiprocessing`’s `'forkserver'` start method now authenticates its control socket to avoid solely relying on filesystem permissions to restrict what other processes could cause the forkserver to spawn workers and run code. (Contributed by Gregory P. Smith for gh-97514.)

- Os objetos proxies de multiprocessing para os tipos list e dict ganhou métodos anteriormente ausentes:

  > - `clear()` e `copy()` para proxies de `list`

  > - `fromkeys()`, `reversed(d)`, `d | {}`, `{} | d`, `d |= {'b': 2}` para proxies de `dict`

  (Contribuição de Roy Hyunjin Han em gh-103134.)

- Add support for shared `set` objects via `SyncManager.set()`. The `set()` in `Manager()` method is now available. (Contributed by Mingyu Park in gh-129949.)

- Add the `interrupt()` to `multiprocessing.Process` objects, which terminates the child process by sending `SIGINT`. This enables `finally` clauses to print a stack trace for the terminated process. (Contributed by Artem Pulkin in gh-131913.)

### operador

- Add `is_none()` and `is_not_none()` as a pair of functions, such that `operator.is_none(obj)` is equivalent to `obj is None` and `operator.is_not_none(obj)` is equivalent to `obj is not None`. (Contributed by Raymond Hettinger and Nico Mexis in gh-115808.)

### os

- Add the `reload_environ()` function to update `os.environ` and `os.environb` with changes to the environment made by `os.putenv()`, by `os.unsetenv()`, or made outside Python in the same process. (Contributed by Victor Stinner in gh-120057.)

- Add the `SCHED_DEADLINE` and `SCHED_NORMAL` constants to the `os` module. (Contributed by James Roy in gh-127688.)

- Add the `readinto()` function to read into a buffer object from a file descriptor. (Contributed by Cody Maloney in gh-129205.)

### os.path

- The strict parameter to `realpath()` accepts a new value, `ALLOW_MISSING`. If used, errors other than `FileNotFoundError` will be re-raised; the resulting path can be missing but it will be free of symlinks. (Contributed by Petr Viktorin for CVE 2025-4517.)

### pathlib

- Adiciona métodos a `pathlib.Path` para copiar ou mover arquivos e diretórios recursivamente:

  - `copy()` copia um arquivo ou árvore de diretório para um destino.

  - `copy_into()` copia para um diretório de destino.

  - `move()` move um arquivo ou árvore de diretórios para um destino.

  - `move_into()` move para um diretório de destino.

  (Contribuição de Barney Gale em gh-73991.)

- Add the `info` attribute, which stores an object implementing the new `pathlib.types.PathInfo` protocol. The object supports querying the file type and internally caching `stat()` results. Path objects generated by `iterdir()` are initialized with file type information gleaned from scanning the parent directory. (Contributed by Barney Gale in gh-125413.)

### pdb

- The `pdb` module now supports remote attaching to a running Python process using a new `-p PID` command-line option:

      python -m pdb -p 1234

  Isso se conectará ao processo Python com o PID fornecido e permitirá que você o depure interativamente. Observe que, devido ao funcionamento do interpretador Python, a conexão a um processo remoto bloqueado em uma chamada de sistema ou aguardando E/S só funcionará quando a próxima instrução de bytecode for executada ou quando o processo receber um sinal.

  This feature uses PEP 768 and the new `sys.remote_exec()` function to attach to the remote process and send the PDB commands to it.

  (Contribuição de Matt Wozniski e Pablo Galindo em gh-131591.)

- Hardcoded breakpoints (`breakpoint()` and `set_trace()`) now reuse the most recent `Pdb` instance that calls `set_trace()`, instead of creating a new one each time. As a result, all the instance specific data like `display` and `commands` are preserved across hardcoded breakpoints. (Contributed by Tian Gao in gh-121450.)

- Adiciona um novo argumento mode a `pdb.Pdb`. Desabilita o comando `restart` quando `pdb` estiver no modo `inline`. (Contribuição de Tian Gao em gh-123757.)

- Um prompt de confirmação será exibido quando o usuário tentar sair do comando `pdb` no modo `inline`. `y`, `Y`, `<Enter>` ou `EOF` confirmarão o encerramento e chamarão `sys.exit()`, em vez de executar `bdb.BdbQuit`. (Contribuição de Tian Gao em gh-124704.)

- Pontos de interrupção em linha como `breakpoint()` ou `pdb.set_trace()` sempre interromperão o programa no quadro da chamada, ignorando o padrão `skip` (se houver). (Contribuição de Tian Gao em gh-130493.)

- `<tab>` no início da linha na entrada multilinha do `pdb` agora preencherá um recuo de 4 espaços, em vez de inserir um caractere `\t`. (Contribuição de Tian Gao em gh-130471.)

- A indentação automática foi introduzida na entrada multilinha do `pdb`. Ela mantém a indentação da última linha ou insere uma indentação de 4 espaços ao detectar um novo bloco de código. (Contribuição de Tian Gao em gh-133350.)

- `$_asynctask` foi adicionado para acessar a tarefa asyncio atual, se aplicável. (Contribuição de Tian Gao em gh-124367.)

- `pdb.set_trace_async()` foi adicionado para oferecer suporte à depuração de corrotinas assíncronas. Instruções `await` são suportadas com esta função. (Contribuição de Tian Gao em gh-132576.)

- Source code displayed in `pdb` will be syntax-highlighted. This feature can be controlled using the same methods as the default interactive shell, in addition to the newly added `colorize` argument of `pdb.Pdb`. (Contributed by Tian Gao and Łukasz Langa in gh-133355.)

### pickle

- Define a versão do protocolo padrão no módulo `pickle` como 5. Para mais detalhes, consulte protocolos pickle.

- Add exception notes for pickle serialization errors that allow identifying the source of the error. (Contributed by Serhiy Storchaka in gh-122213.)

### platform

- Add `invalidate_caches()`, a function to invalidate cached results in the `platform` module. (Contributed by Bénédikt Tran in gh-122549.)

### pydoc

- Anotações na saída de ajuda agora são exibidas em um formato mais próximo ao da fonte original. (Contribuição de Jelle Zijlstra em gh-101552.)

### re

- Suporte a `\z` como sinônimo de `\Z` em `expressões regulares`. É interpretado sem ambiguidade em muitos outros mecanismos de expressão regular, ao contrário de `\Z`, que tem um comportamento ligeiramente diferente. (Contribuição de Serhiy Storchaka em gh-133306.)

- `\B` in `regular expression` now matches the empty input string, meaning that it is now always the opposite of `\b`. (Contributed by Serhiy Storchaka in gh-124130.)

### socket

- Melhora e corrige o suporte para soquetes Bluetooth.

  - Corrige o suporte a soquetes Bluetooth no NetBSD e no DragonFly BSD. (Contribuição de Serhiy Storchaka em gh-132429.)

  - Corrige o suporte para `BTPROTO_HCI` no FreeBSD. (Contribuição de Victor Stinner em gh-111178.)

  - Adiciona suporte para `BTPROTO_SCO` no FreeBSD. (Contribuição de Serhiy Storchaka em gh-85302.)

  - Adiciona suporte para cid e bdaddr_type no endereço para `BTPROTO_L2CAP` no FreeBSD. (Contribuição de Serhiy Storchaka em gh-132429.)

  - Adiciona suporte para channel no endereço para `BTPROTO_HCI` no Linux. (Contribuição de Serhiy Storchaka em gh-70145.)

  - Aceita um inteiro como endereço para `BTPROTO_HCI` no Linux. (Contribuição de Serhiy Storchaka em gh-132099.)

  - Retorna cid em `getsockname()` para `BTPROTO_L2CAP`. (Contribuição de Serhiy Storchaka em gh-132429.)

  - Adiciona muitas novas constantes. (Contribuição de Serhiy Storchaka em gh-132734.)

### ssl

- Indicate through the `HAS_PHA` Boolean whether the `ssl` module supports TLSv1.3 post-handshake client authentication (PHA). (Contributed by Will Childs-Klein in gh-128036.)

### struct

- Suporte aos tipos C float complex e double complex no módulo `struct` (formatando os caracteres `'F'` e `'D'`, respectivamente). (Contribuição de Sergey B Kirpichev em gh-121249.)

### symtable

- Expose the following `Symbol` methods:

  - `is_comp_cell()`

  - `is_comp_iter()`

  - `is_free_class()`

  (Contribuição de Bénédikt Tran em gh-120029.)

### sys

- The previously undocumented special function `sys.getobjects()`, which only exists in specialized builds of Python, may now return objects from other interpreters than the one it’s called in. (Contributed by Eric Snow in gh-125286.)

- Adiciona `sys._is_immortal()` para determinar se um objeto é imortal. (Contribuição de Peter Bierma em gh-128509.)

- On FreeBSD, `sys.platform` no longer contains the major version number. It is always `'freebsd'`, instead of `'freebsd13'` or `'freebsd14'`. (Contributed by Michael Osipov in gh-129393.)

- Levanta `DeprecationWarning` para `sys._clear_type_cache()`. Esta função foi descontinuada no Python 3.13, mas não levantava um aviso em tempo de execução.

- Add `sys.remote_exec()` to implement the new external debugger interface. See PEP 768 for details. (Contributed by Pablo Galindo Salgado, Matt Wozniski, and Ivona Stojanovic in gh-131591.)

- Add the `sys._jit` namespace, containing utilities for introspecting just-in-time compilation. (Contributed by Brandt Bucher in gh-133231.)

### sys.monitoring

- Add two new monitoring events, `BRANCH_LEFT` and `BRANCH_RIGHT`. These replace and deprecate the `BRANCH` event. (Contributed by Mark Shannon in gh-122548.)

### sysconfig

- Add `ABIFLAGS` key to `get_config_vars()` on Windows. (Contributed by Xuehai Pan in gh-131799.)

### tarfile

- `data_filter()` agora normaliza alvos de links simbólicos para evitar ataques de travessia de caminho. (Contribuição de Petr Viktorin em gh-127987 e CVE 2025-4138.)

- `extractall()` agora ignora a correção de atributos de diretório quando um diretório é removido ou substituído por outro tipo de arquivo. (Contribuição de Petr Viktorin em gh-127987 e CVE 2024-12718.)

- `extract()` e `extractall()` agora (re)aplicam o filtro de extração ao substituir um link (físico ou simbólico) por uma cópia de outro membro do arquivo e ao corrigir atributos de diretório. O primeiro levanta uma nova exceção, `LinkFallbackError`. (Contribuição de Petr Viktorin para CVE 2025-4330 e CVE 2024-12718.)

- `extract()` e `extractall()` não extraem mais membros rejeitados quando `errorlevel()` é zero. (Contribuição de Matt Prodani e Petr Viktorin em gh-112887 e CVE 2025-4435.)

### threading

- `threading.Thread.start()` agora define o nome do thread do sistema operacional como `threading.Thread.name`. (Contribuição de Victor Stinner em gh-59705.)

### tkinter

- Make `tkinter` widget methods `after()` and `after_idle()` accept keyword arguments. (Contributed by Zhikang Yan in gh-126899.)

- Add ability to specify a name for `tkinter.OptionMenu` and `tkinter.ttk.OptionMenu`. (Contributed by Zhikang Yan in gh-130482.)

### turtle

- Add context managers for `turtle.fill()`, `turtle.poly()`, and `turtle.no_animation()`. (Contributed by Marie Roald and Yngve Mardal Moe in gh-126350.)

### tipos

- `types.UnionType` agora é um apelido para `typing.Union`. Veja abaixo para mais detalhes. (Contribuição de Jelle Zijlstra em gh-105499.)

### typing

- The `types.UnionType` and `typing.Union` types are now aliases for each other, meaning that both old-style unions (created with `Union[int, str]`) and new-style unions (`int | str`) now create instances of the same runtime type. This unifies the behavior between the two syntaxes, but leads to some differences in behavior that may affect users who introspect types at runtime:

  - Both syntaxes for creating a union now produce the same string representation in `repr()`. For example, `repr(Union[int, str])` is now `"int | str"` instead of `"typing.Union[int, str]"`.

  - Unions created using the old syntax are no longer cached. Previously, running `Union[int, str]` multiple times would return the same object (`Union[int, str] is Union[int, str]` would be `True`), but now it will return two different objects. Use `==` to compare unions for equality, not `is`. New-style unions have never been cached this way. This change could increase memory usage for some programs that use a large number of unions created by subscripting `typing.Union`. However, several factors offset this cost: unions used in annotations are no longer evaluated by default in Python 3.14 because of PEP 649; an instance of `types.UnionType` is itself much smaller than the object returned by `Union[]` was on prior Python versions; and removing the cache also saves some space. It is therefore unlikely that this change will cause a significant increase in memory usage for most users.

  - Previously, old-style unions were implemented using the private class `typing._UnionGenericAlias`. This class is no longer needed for the implementation, but it has been retained for backward compatibility, with removal scheduled for Python 3.17. Users should use documented introspection helpers like `get_origin()` and `typing.get_args()` instead of relying on private implementation details.

  - Agora é possível usar o próprio `typing.Union` em verificações de `isinstance()`. Por exemplo, `isinstance(int | str, typing.Union)` retornará `True`; anteriormente, isso levantava `TypeError`.

  - The `__args__` attribute of `typing.Union` objects is no longer writable.

  - It is no longer possible to set any attributes on `Union` objects. This only ever worked for dunder attributes on previous versions, was never documented to work, and was subtly broken in many cases.

  (Contribuição de Jelle Zijlstra em gh-105499.)

- `TypeAliasType` now supports star unpacking.

### unicodedata

- O banco de dados Unicode foi atualizado para Unicode 16.0.0.

### unittest

- A saída do `unittest` agora é colorida por padrão. Isso pode ser controlado pelas variáveis de ambiente. (Contribuição de Hugo van Kemenade em gh-127221.)

- O Unittest Discovery suporta novamente pacote de espaço de nomes como diretório inicial. Ele foi removido no Python 3.11. (Contribuição de Jacob Walls em gh-80958.)

- Vários novos métodos foram adicionados à classe `TestCase` que fornecem testes mais especializados.

  - `assertHasAttr()` e `assertNotHasAttr()` verificam se o objeto tem um atributo específico.

  - `assertIsSubclass()` e `assertNotIsSubclass()` verificam se o objeto é uma subclasse de uma classe específica ou de uma tupla de classes.

  - `assertStartsWith()`, `assertNotStartsWith()`, `assertEndsWith()` e `assertNotEndsWith()` verificam se a sequência de caracteres Unicode ou de bytes começa ou termina com sequências de caracteres específicas.

  (Contribuição de Serhiy Storchaka em gh-71339.)

### urllib

- Atualiza o algoritmo de autenticação de resumo HTTP para `urllib.request`, oferecendo suporte à autenticação de resumo SHA-256, conforme especificado em RFC 7616. (Contribuição de Calvin Bui em gh-128193.)

- Melhora a ergonomia e a conformidade com os padrões ao analisar e emitir URLs `file:`.

  In `url2pathname()`:

  - Aceita uma URL completa quando o novo argumento require_scheme for definido como verdadeiro.

  - Descarta a autoridade de URL se ela corresponder ao nome de host local.

  - Descarta a autoridade de URL se ela for resolvida para um endereço IP local quando o novo argumento resolve_host for definido como verdadeiro.

  - Descarta componentes de consulta e fragmento de URL.

  - Levanta `URLError` se uma autoridade de URL não for local, exceto no Windows, onde retornamos um caminho UNC como antes.

  In `pathname2url()`:

  - Retorna uma URL completa quando o novo argumento add_scheme for definido como verdadeiro.

  - Inclui uma autoridade de URL vazia quando um caminho começar com uma barra. Por exemplo, o caminho `/etc/hosts` é convertido para a URL `///etc/hosts`.

  No Windows, as letras de unidade não são mais convertidas em maiúsculas, e os caracteres `:` que não seguem uma letra de unidade não causam mais o levantamento de uma exceção `OSError`.

  (Contribuição de Barney Gale em gh-125866.)

### uuid

- Add support for UUID versions 6, 7, and 8 via `uuid6()`, `uuid7()`, and `uuid8()` respectively, as specified in RFC 9562. (Contributed by Bénédikt Tran in gh-89083.)

- `NIL` and `MAX` are now available to represent the Nil and Max UUID formats as defined by RFC 9562. (Contributed by Nick Pope in gh-128427.)

- Allow generating multiple UUIDs simultaneously on the command-line via `python -m uuid --count`. (Contributed by Simon Legner in gh-131236.)

### webbrowser

- Os nomes na variável de ambiente `BROWSER` agora podem se referir a navegadores já registrados para o módulo `webbrowser`, em vez de sempre gerar um novo comando de navegador.

  Isso torna possível definir `BROWSER` como o valor de um dos navegadores suportados no macOS.

### zipfile

- Added `ZipInfo._for_archive`, a method to resolve suitable defaults for a `ZipInfo` object as used by `ZipFile.writestr`. (Contributed by Bénédikt Tran in gh-123424.)

- `ZipFile.writestr()` now respects the `SOURCE_DATE_EPOCH` environment variable in order to better support reproducible builds. (Contributed by Jiahao Li in gh-91279.)

## Otimizações

- O tempo de importação para vários módulos de biblioteca padrão foi melhorado, incluindo `annotationlib`, `ast`, `asyncio`, `base64`, `cmd`, `csv`, `gettext`, `importlib.util`, `locale`, `mimetypes`, `optparse`, `pickle`, `pprint`, `pstats`, `shlex`, `socket`, `string`, `subprocess`, `threading`, `tomllib`, `types` e `zipfile`.

  (Contribuição de Adam Turner, Bénédikt Tran, Chris Markiewicz, Eli Schwartz, Hugo van Kemenade, Jelle Zijlstra e outros em gh-118761.)

- The interpreter now avoids some reference count modifications internally when it’s safe to do so. This can lead to different values being returned from `sys.getrefcount()` and `Py_REFCNT()` compared to previous versions of Python. See below for details.

### asyncio

- Standard benchmark results have improved by 10-20% following the implementation of a new per-thread doubly linked list for `native tasks`, also reducing memory usage. This enables external introspection tools such as python -m asyncio pstree to introspect the call graph of asyncio tasks running in all threads. (Contributed by Kumar Aditya in gh-107803.)

- O módulo agora conta com suporte de primeira classe para construção com threads livres. Isso permite a execução paralela de múltiplos laços de eventos em diferentes threads, com escala linear com o número de threads. (Contribuição de Kumar Aditya em gh-128002.)

### base64

- `b16decode()` agora é até seis vezes mais rápido. (Contribuição de Bénédikt Tran, Chris Markiewicz e Adam Turner em gh-118761.)

### bdb

- O depurador básico agora conta com um backend baseado em `sys.monitoring`, que pode ser selecionado passando `'monitoring'` para o novo parâmetro backend da classe `Bdb`. (Contribuição de Tian Gao em gh-124533.)

### difflib

- A função `IS_LINE_JUNK()` agora é até duas vezes mais rápida. (Contribuição de Adam Turner e Semyon Moroz em gh-130167.)

### gc

- O novo coletor de lixo incremental significa que os tempos máximos de pausa são reduzidos em uma ordem de magnitude ou mais para heaps maiores.

  Devido a essa otimização, o significado dos resultados de `get_threshold()` e `set_threshold()` foi alterado, juntamente com `get_count()` e `get_stats()`.

  - Para retrocompatibilidade, `get_threshold()` continua retornando uma tupla de três itens. O primeiro valor é o limite para coleções novas, como antes; o segundo valor determina a taxa de varredura da coleção antiga (o padrão é 10, e valores mais altos significam que a coleção antiga é varrida mais lentamente). O terceiro valor agora não tem mais significado e é sempre zero.

  - `set_threshold()` agora ignora quaisquer itens após o segundo.

  - `get_count()` e `get_stats()` continuam retornando o mesmo formato de resultados. A única diferença é que, em vez dos resultados se referirem às gerações jovem, idosa e idosa, os resultados se referem à geração jovem e aos espaços de envelhecimento e coleta da geração idosa.

  Em resumo, o código que tenta manipular o comportamento do ciclo de coleta de lixo pode não funcionar exatamente como o esperado, mas é muito improvável que seja prejudicial. Todos os outros códigos funcionarão perfeitamente.

  (Contribuição de Mark Shannon em gh-108362.)

### io

- Abrir e ler arquivos agora executa menos chamadas de sistema. Ler um pequeno arquivo em cache do sistema operacional na íntegra é até 15% mais rápido. (Contribuição de Cody Maloney e Victor Stinner em gh-120754 e gh-90102.)

### pathlib

- `Path.read_bytes` agora usa o modo sem buffer para abrir arquivos, o que é entre 9% e 17% mais rápido para leitura completa. (Contribuição de Cody Maloney em gh-120754.)

### pdb

- `pdb` agora suporta dois backends, baseados em `sys.settrace()` ou `sys.monitoring`. Usar a CLI do pdb ou `breakpoint()` sempre usará o backend `sys.monitoring`. Instanciar explicitamente `pdb.Pdb` e suas classes derivadas usará o backend `sys.settrace()` por padrão, que é configurável. (Contribuição de Tian Gao em gh-124533.)

### uuid

- `uuid3()` e `uuid5()` agora são aproximadamente 40% mais rápidos para nomes de 16 bytes e 20% mais rápidos para nomes de 1024 bytes. O desempenho para nomes mais longos permanece inalterado. (Contribuição de Bénédikt Tran em gh-128150.)

- `uuid4()` agora é cerca de 30% mais rápido. (Contribuição de Bénédikt Tran em gh-128150.)

### zlib

- No Windows, zlib-ng agora é usado como implementação do módulo `zlib` nos binários padrão. Não há incompatibilidades conhecidas entre `zlib-ng` e a implementação `zlib` usada anteriormente. Isso deve resultar em melhor desempenho em todos os níveis de compactação.

  Vale ressaltar que `zlib.Z_BEST_SPEED` (`1`) pode resultar em significativamente menos compressão do que a implementação anterior, além de reduzir significativamente o tempo necessário para compactar.

  (Contribuição de Steve Dower em gh-91349.)

## Removidos

### argparse

- Remove os parâmetros type, choices e metavar de `BooleanOptionalAction`. Eles estão descontinuados desde o Python 3.12. (Contribuição de Nikita Sobolev em gh-118805.)

- Chamar `add_argument_group()` em um grupo de argumentos agora gera um `ValueError`. Da mesma forma, `add_argument_group()` ou `add_mutually_exclusive_group()` em um grupo mutuamente exclusivo agora levantam `ValueError`s. Esse “aninhamento” nunca foi suportado, frequentemente não funcionava corretamente e era exposto involuntariamente por herança. Essa funcionalidade está descontinuada desde o Python 3.11. (Contribuição de Savannah Ostrowski em gh-127186.)

### ast

- Remove as seguintes classes, que são apelidos descontinuados de `Constant` desde o Python 3.8 e emitem avisos de descontinuação desde o Python 3.12:

  - `Bytes`

  - `Ellipsis`

  - `NameConstant`

  - `Num`

  - `Str`

  Como consequência dessas remoções, os métodos `visit_Num`, `visit_Str`, `visit_Bytes`, `visit_NameConstant` e `visit_Ellipsis` definidos pelo usuário nas subclasses personalizadas `NodeVisitor` não serão mais chamados quando a subclasse `NodeVisitor` estiver visitando uma AST. Em vez disso, defina um método `visit_Constant`.

  (Contribuição de Alex Waygood em gh-119562.)

- Remove as seguintes propriedades descontinuadas em `ast.Constant`, que estavam presentes para compatibilidade com as classes AST agora removidas:

  - `Constant.n`

  - `Constant.s`

  Em vez disso, use `Constant.value`. (Contribuição de Alex Waygood em gh-119562.)

### asyncio

- Remove as seguintes classes, métodos e funções, que foram descontinuados desde o Python 3.12:

  - `AbstractChildWatcher`

  - `FastChildWatcher`

  - `MultiLoopChildWatcher`

  - `PidfdChildWatcher`

  - `SafeChildWatcher`

  - `ThreadedChildWatcher`

  - `AbstractEventLoopPolicy.get_child_watcher()`

  - `AbstractEventLoopPolicy.set_child_watcher()`

  - `get_child_watcher()`

  - `set_child_watcher()`

  (Contribuição de Kumar Aditya em gh-120804.)

- `asyncio.get_event_loop()` agora levanta uma `RuntimeError` se não houver um laço de eventos atual e não cria mais implicitamente um laço de eventos.

  (Contribuição de Kumar Aditya em gh-126353.)

  Existem alguns padrões que usam `asyncio.get_event_loop()`, a maioria deles pode ser substituída por `asyncio.run()`.

  Se você estiver executando uma função assíncrona, basta usar `asyncio.run()`.

  Antes:

      async def main():
          ...

      loop = asyncio.get_event_loop()
      try:
          loop.run_until_complete(main())
      finally:
          loop.close()

  Depois:

      async def main():
          ...

      asyncio.run(main())

  Se você precisar iniciar algo, por exemplo, um servidor escutando em um soquete e depois rodar para sempre, use `asyncio.run()` e um `asyncio.Event`.

  Antes:

      def start_server(loop): ...

      loop = asyncio.get_event_loop()
      try:
          start_server(loop)
          loop.run_forever()
      finally:
          loop.close()

  Depois:

      def start_server(loop): ...

      async def main():
          start_server(asyncio.get_running_loop())
          await asyncio.Event().wait()

      asyncio.run(main())

  Se você precisar executar algo em um laço de eventos, execute algum código de bloqueio em torno dele, use `asyncio.Runner`.

  Antes:

      async def operation_one(): ...
      def blocking_code(): ...
      async def operation_two(): ...

      loop = asyncio.get_event_loop()
      try:
          loop.run_until_complete(operation_one())
          blocking_code()
          loop.run_until_complete(operation_two())
      finally:
          loop.close()

  Depois:

      async def operation_one(): ...
      def blocking_code(): ...
      async def operation_two(): ...

      with asyncio.Runner() as runner:
          runner.run(operation_one())
          blocking_code()
          runner.run(operation_two())

### email

- Remove o parâmetro isdst de `email.utils.localtime()`, que foi descontinuado e é ignorado desde o Python 3.12. (Contribuição de Hugo van Kemenade em gh-118798.)

### importlib.abc

- Remove classes descontinuadas `importlib.abc`:

  - `ResourceReader` (use `TraversableResources`)

  - `Traversable` (use `Traversable`)

  - `TraversableResources` (use `TraversableResources`)

  (Contribuição de Jason R. Coombs e Hugo van Kemenade em gh-93963.)

### itertools

- Remove o suporte para operações de cópia, cópia profunda e de serialização com pickle dos iteradores `itertools`. Eles emitem um `DeprecationWarning` desde o Python 3.12. (Contribuição de Raymond Hettinger em gh-101588.)

### pathlib

- Remove o suporte para passagem de argumentos nomeados adicionais para `Path`. Em versões anteriores, tais argumentos eram ignorados. (Contribuição de Barney Gale em gh-74033.)

- Remove o suporte para passagem de argumentos posicionais adicionais para `PurePath.relative_to()` e `is_relative_to()`. Em versões anteriores, tais argumentos eram unidos a other. (Contribuição de Barney Gale em gh-78707.)

### pkgutil

- Remove as funções `get_loader()` e `find_loader()`, que foram descontinuadas desde o Python 3.12. (Contribuição de Bénédikt Tran em gh-97850.)

### pty

- Remove as funções `master_open()` e `slave_open()`, que foram descontinuadas desde o Python 3.12. Em vez disso, use `pty.openpty()`. (Contribuição de Nikita Sobolev em gh-118824.)

### sqlite3

- Remove `version` e `version_info` do módulo `sqlite3`; use `sqlite_version` e `sqlite_version_info` para o número da versão real da biblioteca SQLite em tempo de execução. (Contribuição de Hugo van Kemenade em gh-118924.)

- Usar uma sequência de parâmetros com espaços reservados nomeados agora levanta uma `ProgrammingError`, que estava descontinuado desde o Python 3.12. (Contribuição de Erlend E. Aasland em gh-118928 e gh-101693.)

### urllib

- Remove a classe `Quoter` de `urllib.parse`, que está descontinuada desde o Python 3.11. (Contribuição de Nikita Sobolev em gh-118827.)

- Remove as classes `URLopener` e `FancyURLopener` de `urllib.request`, que foram descontinuadas desde o Python 3.3.

  `myopener.open()` pode ser substituído por `urlopen()`. `myopener.retrieve()` pode ser substituído por `urlretrieve()`. Personalizações nas classes de abertura podem ser feitas passando manipuladores personalizados para `build_opener()`. (Contribuição de Barney Gale em gh-84850.)

## Descontinuados

### Novas descontinuações

- Passar um número complexo como argumento real ou imag no construtor `complex()` agora está descontinuado; números complexos devem ser passados apenas como um único argumento posicional. (Contribuição de Serhiy Storchaka em gh-109218.)

- `argparse`:

  - A passagem do argumento nomeado não documentado prefix_chars para o método `add_argument_group()` agora está descontinuado. (Contribuição de Savannah Ostrowski em gh-125563.)

  - O conversor de tipo `argparse.FileType` foi descontinuado. Qualquer coisa relacionada a gerenciamento de recursos deve ser tratado posteriormente, após os argumentos terem sido analisados. (Contribuição de Serhiy Storchaka em gh-58032.)

- `asyncio`:

  - A `asyncio.iscoroutinefunction()` está agora descontinuado e será removido no Python 3.16, use `inspect.iscoroutinefunction()` em vez disso. (Contribuição de Jiahao Li e Kumar Aditya em gh-122875.)

  - O sistema de políticas `asyncio` está descontinuado e será removido no Python 3.16. Em particular, as seguintes classes e funções estão descontinuadas:

    - `asyncio.AbstractEventLoopPolicy`

    - `asyncio.DefaultEventLoopPolicy`

    - `asyncio.WindowsSelectorEventLoopPolicy`

    - `asyncio.WindowsProactorEventLoopPolicy`

    - `asyncio.get_event_loop_policy()`

    - `asyncio.set_event_loop_policy()`

    Os usuários devem usar `asyncio.run()` ou `asyncio.Runner` com o argumento loop_factory para usar a implementação de laço de eventos desejada.

    por exemplo, para usar `asyncio.SelectorEventLoop` no Windows:

        import asyncio

        async def main():
            ...

        asyncio.run(main(), loop_factory=asyncio.SelectorEventLoop)

    (Contribuição de Kumar Aditya em gh-127949.)

- `codecs`: A função `codecs.open()` está descontinuada e será removida em uma versão futura do Python. Em vez disso, use `open()`. (Contribuição de Inada Naoki em gh-133036.)

- `ctypes`:

  - Em plataformas não Windows, a configuração de `Structure._pack_` para usar um layout de memória padrão compatível com MSVC foi também descontinuada em favor da configuração de `Structure._layout_` para `'ms'`, e será removida no Python 3.19. (Contribuição de Petr Viktorin em gh-131747.)

  - A chamada de `ctypes.POINTER()` em uma string está agora descontinuada. Use tipos incompletos para estruturas autorreferenciais. Além disso, o `ctypes._pointer_type_cache` interno está descontinuado. Consulte `ctypes.POINTER()` para obter detalhes de implementação atualizados. (Contribuição de Sergey Myrianov em gh-100926.)

- `functools`: Chamar a implementação Python de `functools.reduce()` com function ou sequence como argumentos nomeados agora está descontinuado; os parâmetros serão tornados somente-posicionais no Python 3.16. (Contribuição de Kirill Podoprigora em gh-121676.)

- `logging`: O suporte para manipuladores de registro personalizados com o argumento strm está agora descontinuado e está programado para ser removido no Python 3.16. Em vez disso, defina manipuladores com o argumento stream. (Contribuição de Mariusz Felisiak em gh-115032.)

- `mimetypes`: Extensões válidas estão vazias ou devem começar com ‘.’ para `mimetypes.MimeTypes.add_type()`. Extensões sem ponto estão descontinuadas e levantarão uma exceção `ValueError` no Python 3.16. (Contribuição de Hugo van Kemenade em gh-75223.)

- `nturl2path`: Este módulo está descontinuado. Em vez disso, chame `urllib.request.url2pathname()` e `pathname2url()`. (Contribuição de Barney Gale em gh-125866.)

- `os`: As funções `os.popen()` e `os.spawn*` estão agora suavemente descontinuadas. Elas não devem mais ser usadas para escrever código novo. O módulo `subprocess` é recomendado em seu lugar. (Contribuição de Victor Stinner em gh-120743.)

- `pathlib`: `pathlib.PurePath.as_uri()` está agora descontinuado e está programado para remoção no Python 3.19. Em vez disso, use `pathlib.Path.as_uri()`. (Contribuição de Barney Gale em gh-123599.)

- `pdb`: O atributo não documentado `pdb.Pdb.curframe_locals` agora é uma propriedade somente leitura descontinuada, que será removido em uma versão futura do Python. O acesso dinâmico de baixa sobrecarga aos locais de quadro, adicionado no Python 3.13 pela PEP 667, significa que a referência ao cache de locais de quadro, armazenada anteriormente neste atributo, não é mais necessária. Depuradores derivados devem acessar `pdb.Pdb.curframe.f_locals` diretamente no Python 3.13 e versões posteriores. (Contribuição de Tian Gao em gh-124369 e gh-125951.)

- `symtable`: Descontinua `symtable.Class.get_methods()` por falta de interesse, programado para remoção no Python 3.16. (Contribuição de Bénédikt Tran em gh-119698.)

- `tkinter`: Os métodos `tkinter.Variable` `trace_variable()`, `trace_vdelete()` e `trace_vinfo()` estão descontinuados. Em vez disso, use `trace_add()`, `trace_remove()` e `trace_info()`. (Contribuição de Serhiy Storchaka em gh-120220.)

- `urllib.parse`: Aceitar objetos com valores falsos (como `0` e `[]`), exceto strings vazias, objetos bytes ou similares e `None` nas funções `parse_qsl()` e `parse_qs()`, agora está descontinuado. (Contribuição de Serhiy Storchaka em gh-116897.)

### Remoção pendente no Python 3.15

- O sistema de importação:

  - A definição de `__cached__` em um módulo enquanto falha na definição de `__spec__.cached` está descontinuado. No Python 3.15, `__cached__` deixará de ser definido ou levado em consideração pelo sistema de importação ou pela biblioteca padrão. (gh-97879)

  - A definição de `__package__` em um módulo enquanto falha na definição de `__spec__.parent` está descontinuado. No Python 3.15, `__package__` deixará de ser definido ou levado em consideração pelo sistema de importação ou pela biblioteca padrão. (gh-97879)

- `ctypes`:

  - A função não documentada `ctypes.SetPointerType()` foi descontinuada desde o Python 3.13.

- `http.server`:

  - A classe obsoleta e raramente usada `CGIHTTPRequestHandler` foi descontinuada desde o Python 3.13. Não existe substituição direta. Qualquer coisa é melhor que CGI para fazer a interface de um servidor web com um manipulador de requisição.

  - O sinalizador `--cgi` para a interface de linha de comando python -m http.server foi descontinuado desde o Python 3.13.

- `importlib`:

  - Método `load_module()`: use `exec_module()`.

- `locale`:

  - A função `getdefaultlocale()` foi descontinuada desde o Python 3.11. Sua remoção foi planejada originalmente para o Python 3.13 (gh-90817), mas foi adiada para o Python 3.15. Em vez disso, use `getlocale()`, `setlocale()` e `getencoding()`. (Contribuição de Hugo van Kemenade em gh-111187.)

- `pathlib`:

  - `PurePath.is_reserved()` foi descontinuado desde o Python 3.13. Use `os.path.isreserved()` para detectar caminhos reservados no Windows.

- `platform`:

  - `java_ver()` foi descontinuada desde o Python 3.13. Esta função é útil apenas para suporte Jython, tem uma API confusa e é amplamente não testada.

- `sysconfig`:

  - O argumento check_home de `sysconfig.is_python_build()` foi descontinuado desde o Python 3.12.

- `threading`:

  - `RLock()` não aceitará argumentos no Python 3.15. A passagem quaisquer argumentos foi descontinuada desde o Python 3.14, pois a versão Python não permite nenhum argumento, mas a versão C permite qualquer número de argumentos posicionais ou nomeados, ignorando todos os argumentos.

- `types`:

  - `types.CodeType`: o acesso a `co_lnotab` foi descontinuado na PEP 626 desde 3.10 e foi planejado para ser removido em 3.12, mas só recebeu uma `DeprecationWarning` adequada em 3.12. Pode ser removido em 3.15. (Contribuição de Nikita Sobolev em gh-101866.)

- `typing`:

  - A não-documentada sintaxe de argumento nomeado para criar classes `NamedTuple` (por exemplo, `Point = NamedTuple("Point", x=int, y=int)`) foi descontinuada desde o Python 3.13. Em vez disso, use as sintaxes baseada em classe ou funcional.

  - Ao usar a sintaxe funcional de `TypedDict`s, não passar um valor para o parâmetro fields (`TD = TypedDict("TD")`) ou passar `None` (`TD = TypedDict("TD", None)`) foi está descontinuado desde o Python 3.13. Use `class TD(TypedDict): pass` ou `TD = TypedDict("TD", {})` para criar uma classe TypedDict com nenhum campo.

  - A função decoradora `typing.no_type_check_decorator()` foi descontinuada desde o Python 3.13. Após oito anos no módulo `typing`, ela ainda não foi suportada por nenhum verificador de tipo importante.

- `wave`:

  - Os métodos `getmark()`, `setmark()` e `getmarkers()` das classes `Wave_read` e `Wave_write` foram descontinuados desde o Python 3.13.

- `zipimport`:

  - `load_module()` está descontinuado desde o Python 3.10. Em vez disso, use `exec_module()`. (Contribuição de Jiahao Li em gh-125746.)

### Remoção pendente no Python 3.16

- O sistema de importação:

  - A definição de `__loader__` em um módulo enquanto falha na definição de `__spec__.loader` está descontinuado. No Python 3.16, `__loader__` deixará de ser definido ou levado em consideração pelo sistema de importação ou pela biblioteca padrão.

- `array`:

  - O código de formato `'u'` (`wchar_t`) foi descontinuado na documentação desde o Python 3.3 e do ambiente de execução desde o Python 3.13. Em vez disso, use o código de formato `'w'` (`Py_UCS4`) para caracteres Unicode.

- `asyncio`:

  - `asyncio.iscoroutinefunction()` foi descontinuado e será removido no Python 3.16, use `inspect.iscoroutinefunction()` em vez disso. (Contribuição de Jiahao Li e Kumar Aditya em gh-122875.)

  - O sistema de políticas `asyncio` está descontinuado e será removido no Python 3.16. Em particular, as seguintes classes e funções estão descontinuadas:

    - `asyncio.AbstractEventLoopPolicy`

    - `asyncio.DefaultEventLoopPolicy`

    - `asyncio.WindowsSelectorEventLoopPolicy`

    - `asyncio.WindowsProactorEventLoopPolicy`

    - `asyncio.get_event_loop_policy()`

    - `asyncio.set_event_loop_policy()`

    Os usuários devem usar `asyncio.run()` ou `asyncio.Runner` com loop_factory para usar a implementação de loop de eventos desejada.

    por exemplo, para usar `asyncio.SelectorEventLoop` no Windows:

        import asyncio

        async def main():
            ...

        asyncio.run(main(), loop_factory=asyncio.SelectorEventLoop)

    (Contribuição de Kumar Aditya em gh-127949.)

- `builtins`:

  - A inversão bit a bit em tipos booleanos, `~True` ou `~False` foi descontinuada desde o Python 3.12, pois produz resultados surpreendentes e não intuitivos (`-2` e `-1`). Em vez disso, use `not x` para a negação lógica de um booleano. No caso raro de você precisar da inversão bit a bit do inteiro subjacente, converta para `int` explicitamente (`~int(x)`).

- `functools`:

  - A chamada da implementação Python de `functools.reduce()` com function ou sequence como argumentos nomeados foi descontinuada desde o Python 3.14.

- `logging`:

  O suporte para manipuladores de registro personalizados com o argumento strm foi descontinuado e está programado para ser removido no Python 3.16. Em vez disso, defina manipuladores com o argumento stream. (Contribuição de Mariusz Felisiak em gh-115032.)

- `mimetypes`:

  - Extensões válidas começam com um ‘.’ ou estão vazias para `mimetypes.MimeTypes.add_type()`. Extensões sem ponto estão descontinuadas e levantarão uma exceção `ValueError` no Python 3.16. (Contribuição de Hugo van Kemenade em gh-75223.)

- `shutil`:

  - A exceção `ExecError` foi descontinuada desde o Python 3.14. Ela não foi usada por nenhuma função em `shutil` desde o Python 3.4, e agora é um alias de `RuntimeError`.

- `symtable`:

  - O método `Class.get_methods` foi descontinuado desde o Python 3.14.

- `sys`:

  - A função `_enablelegacywindowsfsencoding()` foi descontinuada desde o Python 3.13. Em vez disso, use a variável de ambiente `PYTHONLEGACYWINDOWSFSENCODING`.

- `sysconfig`:

  - A função `sysconfig.expand_makefile_vars()` está descontinuada desde o Python 3.14. Em vez disso, use o argumento `vars` de `sysconfig.get_paths()`.

- `tarfile`:

  - O atributo não documentado e não utilizado `TarFile.tarfile` foi descontinuado desde o Python 3.13.

### Remoção pendente no Python 3.17

- `collections.abc`:

  - `collections.abc.ByteString` está agendado para remoção no Python 3.17.

    Use `isinstance(obj, collections.abc.Buffer)` para testar se `obj` implementa o protocolo de buffer em tempo de execução. Para uso em anotações de tipo, use `Buffer` ou uma união que especifique explicitamente os tipos suportados pelo seu código (por exemplo, `bytes | bytearray | memoryview`).

    `ByteString` foi originalmente concebido para ser uma classe abstrata que serviria como um supertipo de `bytes` e `bytearray`. No entanto, como o ABC nunca teve métodos, saber que um objeto era uma instância de `ByteString` nunca lhe dizia nada de útil sobre o objeto. Outros tipos comuns de buffer, como `memoryview`, também nunca foram entendidos como subtipos de `ByteString` (seja em tempo de execução ou por verificadores de tipo estáticos).

    Veja PEP 688 para mais detalhes. (Contribuição de Shantanu Jain em gh-91896.)

- `typing`:

  - Antes do Python 3.14, as uniões antigas eram implementadas usando a classe privada `typing._UnionGenericAlias`. Essa classe não é mais necessária para a implementação, mas foi mantida para compatibilidade com versões anteriores, com remoção prevista para o Python 3.17. Os usuários devem usar auxiliares de introspecção documentados, como `typing.get_origin()` e `typing.get_args()`, em vez de depender de detalhes de implementação privada.

  - `typing.ByteString`, obsoleto desde o Python 3.9, está programado para ser removido no Python 3.17.

    Use `isinstance(obj, collections.abc.Buffer)` para testar se `obj` implementa o protocolo de buffer em tempo de execução. Para uso em anotações de tipo, use `Buffer` ou uma união que especifique explicitamente os tipos suportados pelo seu código (por exemplo, `bytes | bytearray | memoryview`).

    `ByteString` foi originalmente concebido para ser uma classe abstrata que serviria como um supertipo de `bytes` e `bytearray`. No entanto, como o ABC nunca teve métodos, saber que um objeto era uma instância de `ByteString` nunca lhe dizia nada de útil sobre o objeto. Outros tipos comuns de buffer, como `memoryview`, também nunca foram entendidos como subtipos de `ByteString` (seja em tempo de execução ou por verificadores de tipo estáticos).

    Veja PEP 688 para mais detalhes. (Contribuição de Shantanu Jain em gh-91896.)

### Remoção pendente no Python 3.19

- `ctypes`:

  - Troca implícita para o layout de estrutura compatível com MSVC definindo `_pack_`, mas não `_layout_` em plataformas não Windows.

### Remoção pendente em versões futuras

As APIs a seguir serão removidas no futuro, embora atualmente não haja uma data agendada para sua remoção.

- `argparse`:

  - O aninhamento de grupos de argumentos e o aninhamento de grupos mutuamente exclusivos estão descontinuado.

  - A passagem do argumento nomeado não documentado prefix_chars para `add_argument_group()` agora está descontinuado.

  - O conversor de tipo `argparse.FileType` está descontinuado.

- `builtins`:

  - Geradores: a assinatura `throw(type, exc, tb)` e `athrow(type, exc, tb)` está descontinuada: use `throw(exc)` e `athrow(exc)`, a assinatura do argumento único.

  - Atualmente Python aceita literais numéricos imediatamente seguidos por palavras reservadas como, por exemplo, `0in x`, `1or x`, `0if 1else 2`. Ele permite expressões confusas e ambíguas como `[0x1for x in y]` (que pode ser interpretada como `[0x1 for x in y]` ou `[0x1f or x in y]`). Um aviso de sintaxe é levantado se o literal numérico for imediatamente seguido por uma das palavras reservadas `and`, `else`, `for`, `if`, `in` , `is` e `or`. Em uma versão futura, será alterado para um erro de sintaxe. (gh-87999)

  - Suporte para métodos `__index__()` e `__int__()` retornando tipo não-int: esses métodos serão necessários para retornar uma instância de uma subclasse estrita de `int`.

  - Suporte para o método `__float__()` retornando uma subclasse estrita de `float`: esses métodos serão necessários para retornar uma instância de `float`.

  - Suporte para o método `__complex__()` retornando uma subclasse estrita de `complex`: esses métodos serão necessários para retornar uma instância de `complex`.

  - Delegação do método `int()` para o `__trunc__()`.

  - Passar um número complexo como argumento real ou imag no construtor `complex()` agora está descontinuado; deve ser passado apenas como um único argumento posicional. (Contribuição de Serhiy Storchaka em gh-109218.)

- `calendar`: as constantes `calendar.January` e `calendar.February` foram descontinuadas e substituídas por `calendar.JANUARY` e `calendar.FEBRUARY`. (Contribuição de Prince Roshan em gh-103636.)

- `codecs`: use `open()` em vez de `codecs.open()`. (gh-133038)

- `codeobject.co_lnotab`: use o método `codeobject.co_lines()`.

- `datetime`:

  - `utcnow()`: use `datetime.datetime.now(tz=datetime.UTC)`.

  - `utcfromtimestamp()`: use `datetime.datetime.fromtimestamp(timestamp, tz=datetime.UTC)`.

- `gettext`: o valor de plural deve ser um número inteiro.

- `importlib`:

  - O parâmetro debug_override de `cache_from_source()` foi descontinuado: use o parâmetro optimization.

- `importlib.metadata`:

  - Interface de tupla `EntryPoints`.

  - `None` implícito nos valores de retorno.

- `logging`: o método `warn()` foi descontinuado desde o Python 3.3, use `warning()`.

- `mailbox`: o uso da entrada StringIO e do modo de texto foi descontinuado; em vez disso, use BytesIO e o modo binário.

- `os`: chame `os.register_at_fork()` em processo multithread.

- `pydoc.ErrorDuringImport`: um valor de tupla para o parâmetro exc_info foi descontinuado, use uma instância de exceção.

- `re`: regras mais rigorosas agora são aplicadas para referências numéricas de grupos e nomes de grupos em expressões regulares. Apenas a sequência de dígitos ASCII agora é aceita como referência numérica. O nome do grupo em padrões de bytes e strings de substituição agora pode conter apenas letras e dígitos ASCII e sublinhado. (Contribuição de Serhiy Storchaka em gh-91760.)

- Módulos `sre_compile`, `sre_constants` e `sre_parse`.

- `shutil`: o parâmetro onerror de `rmtree()` foi descontinuado no Python 3.12; use o parâmetro onexc.

- Protocolos e opções de `ssl`

  - `ssl.SSLContext` sem argumento de protocolo foi descontinuado.

  - `ssl.SSLContext`: `set_npn_protocols()` e `selected_npn_protocol()` foram descontinuados, use ALPN.

  - Opções de `ssl.OP_NO_SSL*`

  - Opções de `ssl.OP_NO_TLS*`

  - `ssl.PROTOCOL_SSLv3`

  - `ssl.PROTOCOL_TLS`

  - `ssl.PROTOCOL_TLSv1`

  - `ssl.PROTOCOL_TLSv1_1`

  - `ssl.PROTOCOL_TLSv1_2`

  - `ssl.TLSVersion.SSLv3`

  - `ssl.TLSVersion.TLSv1`

  - `ssl.TLSVersion.TLSv1_1`

- Métodos de `threading`:

  - `threading.Condition.notifyAll()`: use `notify_all()`.

  - `threading.Event.isSet()`: use `is_set()`.

  - `threading.Thread.isDaemon()`, `threading.Thread.setDaemon()`: use o atributo `threading.Thread.daemon`.

  - `threading.Thread.getName()`, `threading.Thread.setName()`: use o atributo `threading.Thread.name`.

  - `threading.currentThread()`: use `threading.current_thread()`.

  - `threading.activeCount()`: use `threading.active_count()`.

- `typing.Text` (gh-92332).

- A classe interna `typing._UnionGenericAlias` não é mais usada para implementar `typing.Union`. Para preservar a compatibilidade com usuários que utilizam esta classe privada, uma correção de compatibilidade será fornecida pelo menos até a versão 3.17 do Python. (Contribuição de Jelle Zijlstra em gh-105499.)

- `unittest.IsolatedAsyncioTestCase`: foi descontinuado retornar um valor que não seja `None` de um caso de teste.

- Funções descontinuadas de `urllib.parse`: use `urlparse()`

  - `splitattr()`

  - `splithost()`

  - `splitnport()`

  - `splitpasswd()`

  - `splitport()`

  - `splitquery()`

  - `splittag()`

  - `splittype()`

  - `splituser()`

  - `splitvalue()`

  - `to_bytes()`

- `wsgiref`: `SimpleHandler.stdout.write()` não deve fazer gravações parciais.

- `xml.etree.ElementTree`: testar o valor verdade de um `Element` está descontinuado. Em um lançamento futuro isso sempre retornará `True`. Em vez disso, prefira os testes explícitos `len(elem)` ou `elem is not None`.

- `sys._clear_type_cache()` está descontinuada: use `sys._clear_internal_caches()`.

## Alterações de bytecode do CPython

- Substituído o opcode `BINARY_SUBSCR` pelo opcode `BINARY_OP` com o oparg `NB_SUBSCR`. (Contribuição de Irit Katriel em gh-100239.)

- Add the `BUILD_INTERPOLATION` and `BUILD_TEMPLATE` opcodes to construct new `Interpolation` and `Template` instances, respectively. (Contributed by Lysandros Nikolaou and others in gh-132661; see also PEP 750: Template strings).

- Remove o opcode `BUILD_CONST_KEY_MAP`. Em vez disso, use `BUILD_MAP`. (Contribuição de Mark Shannon em gh-122160.)

- Substitui o opcode `LOAD_ASSERTION_ERROR` por `LOAD_COMMON_CONSTANT` e adiciona suporte para carregar `NotImplementedError`.

- Adiciona os opcodes `LOAD_FAST_BORROW` e `LOAD_FAST_BORROW_LOAD_FAST_BORROW` para reduzir a sobrecarga de contagem de referências quando o interpretador puder provar que a referência no quadro sobrevive à referência carregada na pilha. (Contribuição de Matt Page em gh-130704.)

- Adiciona o opcode `LOAD_SMALL_INT`, que envia um inteiro pequeno igual a `oparg` para a pilha. O opcode `RETURN_CONST` foi removido, pois não é mais usado. (Contribuição de Mark Shannon em gh-125837.)

- Adiciona a nova instrução `LOAD_SPECIAL`. Gere código para as instruções `with` e `async with` usando a nova instrução. Remove as instruções `BEFORE_WITH` e `BEFORE_ASYNC_WITH`. (Contribuição de Mark Shannon em gh-120507.

- Adiciona o opcode `POP_ITER` para oferecer suporte a iteradores “virtuais”. (Contribuição de Mark Shannon em gh-132554.)

### Pseudoinstruções

- Add the `ANNOTATIONS_PLACEHOLDER` pseudo instruction to support partially executed module-level annotations with deferred evaluation of annotations. (Contributed by Jelle Zijlstra in gh-130907.)

- Adiciona a pseudoinstrução `BINARY_OP_EXTEND` que executa um par de funções (funções de guarda e especialização) acessadas do cache inline. (Contribuição de Irit Katriel em gh-100239.)

- Adiciona três especializações para `CALL_KW`; `CALL_KW_PY` para chamadas de funções Python, `CALL_KW_BOUND_METHOD` para chamadas de métodos vinculados e `CALL_KW_NON_PY` para todas as outras chamadas. (Contribuição de Mark Shannon em gh-118093.)

- Adiciona as pseudoinstruções `JUMP_IF_TRUE` e `JUMP_IF_FALSE`, saltos condicionais que não impactam a pilha. Substituídas pela sequência `COPY 1`, `TO_BOOL`, `POP_JUMP_IF_TRUE/FALSE`. (Contribuição de Irit Katriel em gh-124285.)

- Adiciona a pseudoinstrução `LOAD_CONST_MORTAL`. (Contribuição de Mark Shannon em gh-128685.)

- Adiciona a pseudoinstrução `LOAD_CONST_IMMORTAL`, que faz o mesmo que `LOAD_CONST`, mas é mais eficiente para objetos imortais. (Contribuição de Mark Shannon em gh-125837.)

- Adiciona a pseudoinstrução `NOT_TAKEN`, usada por `sys.monitoring` para registrar eventos de ramificação (como `BRANCH_LEFT`). (Contribuição de Mark Shannon em gh-122548.)

## Alterações na API C

### Python configuration C API

Adiciona uma PyInitConfig API C para configurar a inicialização do Python sem depender de estruturas C e a capacidade de fazer alterações compatíveis com ABI no futuro.

Complete the PEP 587 PyConfig C API by adding `PyInitConfig_AddModule()` which can be used to add a built-in extension module; a feature previously referred to as the “inittab”.

Adiciona as funções `PyConfig_Get()` e `PyConfig_Set()` para obter e definir a configuração de tempo de execução atual.

PEP 587 ‘Python Initialization Configuration’ unified all the ways to configure Python’s initialization. This PEP also unifies the configuration of Python’s preinitialization and initialization in a single API. Moreover, this PEP only provides a single choice to embed Python, instead of having two ‘Python’ and ‘Isolated’ choices (PEP 587), to further simplify the API.

The lower level PEP 587 PyConfig API remains available for use cases with an intentionally higher level of coupling to CPython implementation details (such as emulating the full functionality of CPython’s CLI, including its configuration mechanisms).

(Contribuição de Victor Stinner em gh-107954.)

Ver também

PEP 741 and PEP 587

### Novos recursos na API C

- Adiciona `Py_PACK_VERSION()` e `Py_PACK_FULL_VERSION()`, duas novas macros para empacotamento de bits de números de versão do Python. Isso é útil para comparações com `Py_Version` ou `PY_VERSION_HEX`. (Contribuição de Petr Viktorin em gh-128629.)

- Adiciona a função `PyBytes_Join(sep, iterable)`, semelhante a `sep.join(iterable)` em Python. (Contribuição de Victor Stinner em gh-121645.)

- Add functions to manipulate the configuration of the current runtime Python interpreter (PEP 741: Python configuration C API):

  - `PyConfig_Get()`

  - `PyConfig_GetInt()`

  - `PyConfig_Set()`

  - `PyConfig_Names()`

  (Contribuição de Victor Stinner em gh-107954.)

- Add functions to configure Python initialization (PEP 741: Python configuration C API):

  - `Py_InitializeFromInitConfig()`

  - `PyInitConfig_AddModule()`

  - `PyInitConfig_Create()`

  - `PyInitConfig_Free()`

  - `PyInitConfig_FreeStrList()`

  - `PyInitConfig_GetError()`

  - `PyInitConfig_GetExitCode()`

  - `PyInitConfig_GetInt()`

  - `PyInitConfig_GetStr()`

  - `PyInitConfig_GetStrList()`

  - `PyInitConfig_HasOption()`

  - `PyInitConfig_SetInt()`

  - `PyInitConfig_SetStr()`

  - `PyInitConfig_SetStrList()`

  (Contribuição de Victor Stinner em gh-107954.)

- Adiciona a função `Py_fopen()` para abrir um arquivo. Isso funciona de forma semelhante à função padrão do C `fopen()`, aceitando um objeto Python como parâmetro path e definindo uma exceção em caso de erro. A nova função correspondente `Py_fclose()` deve ser usada para fechar um arquivo. (Contribuição de Victor Stinner em gh-127350.)

- Adiciona `Py_HashBuffer()` para calcular e retornar o valor de hash de um buffer. (Contribuição de Antoine Pitrou e Victor Stinner em gh-122854.)

- Adiciona as funções auxiliares `PyImport_ImportModuleAttr()` e `PyImport_ImportModuleAttrString()` para importar um módulo e obter um atributo do módulo. (Contribuição de Victor Stinner em gh-128911.)

- Adiciona `PyIter_NextItem()` para substituir `PyIter_Next()`, que tem um valor de retorno ambíguo. (Contribuição de Irit Katriel e Erlend Aasland em gh-105201.)

- Adiciona a função `PyLong_GetSign()` para obter o sinal de objetos `int`. (Contribuição de Sergey B Kirpichev em gh-116560.)

- Adiciona `PyLong_IsPositive()`, `PyLong_IsNegative()` e `PyLong_IsZero()` para verificar se `PyLongObject` é positivo, negativo ou zero, respectivamente. (Contribuição de James Roy e Sergey B Kirpichev em gh-126061.)

- Adiciona novas funções para converter números C `<stdint.h>` para/de objetos `int` Python:

  - `PyLong_AsInt32()`

  - `PyLong_AsInt64()`

  - `PyLong_AsUInt32()`

  - `PyLong_AsUInt64()`

  - `PyLong_FromInt32()`

  - `PyLong_FromInt64()`

  - `PyLong_FromUInt32()`

  - `PyLong_FromUInt64()`

  (Contribuição de Victor Stinner em gh-120389.)

- Adiciona uma nova API de importação e exportação para objetos Python `int` (PEP 757):

  - `PyLong_GetNativeLayout()`

  - `PyLong_Export()`

  - `PyLong_FreeExport()`

  - `PyLongWriter_Create()`

  - `PyLongWriter_Finish()`

  - `PyLongWriter_Discard()`

  (Contribuição de Sergey B Kirpichev e Victor Stinner em gh-102471.)

- Adiciona `PyMonitoring_FireBranchLeftEvent()` e `PyMonitoring_FireBranchRightEvent()` para gerar eventos `BRANCH_LEFT` e `BRANCH_RIGHT`, respectivamente. (Contribuição de Mark Shannon em gh-122548.)

- Adiciona a função `PyType_Freeze()` para tornar um tipo imutável. (Contribuição de Victor Stinner em gh-121654.)

- Adiciona `PyType_GetBaseByToken()` e o slot `Py_tp_token` para facilitar a identificação da superclasse, o que tenta resolver o problema de verificação de tipos mencionado na PEP 630. (Contribuição em gh-124153.)

- Adiciona a nova função `PyUnicode_Equal()` para testar se duas strings são iguais. A função também foi adicionada à API C Limitada. (Contribuição de Victor Stinner em gh-124502.)

- Adiciona uma nova API `PyUnicodeWriter` para criar um objeto Python `str` com as seguintes funções:

  - `PyUnicodeWriter_Create()`

  - `PyUnicodeWriter_DecodeUTF8Stateful()`

  - `PyUnicodeWriter_Discard()`

  - `PyUnicodeWriter_Finish()`

  - `PyUnicodeWriter_Format()`

  - `PyUnicodeWriter_WriteASCII()`

  - `PyUnicodeWriter_WriteChar()`

  - `PyUnicodeWriter_WriteRepr()`

  - `PyUnicodeWriter_WriteStr()`

  - `PyUnicodeWriter_WriteSubstring()`

  - `PyUnicodeWriter_WriteUCS4()`

  - `PyUnicodeWriter_WriteUTF8()`

  - `PyUnicodeWriter_WriteWideChar()`

  (Contribuição de Victor Stinner em gh-119182.)

- Os formatos `k` e `K` em `PyArg_ParseTuple()` e funções similares agora usam `__index__()` se disponível, assim como todos os outros formatos inteiros. (Contribuição de Serhiy Storchaka em gh-112068.)

- Adiciona suporte para uma nova unidade de formato `p` em `Py_BuildValue()` que produz um objeto `bool` Python de um inteiro C. (Contribuição de Pablo Galindo em bpo-45325.)

- Adiciona `PyUnstable_IsImmortal()` para determinar se um objeto é imortal, para fins de depuração. (Contribuição de Peter Bierma em gh-128509.)

- Adiciona `PyUnstable_Object_EnableDeferredRefcount()` para habilitar a contagem de referências adiada, conforme descrito em PEP 703.

- Adiciona `PyUnstable_Object_IsUniquelyReferenced()` como substituto para `Py_REFCNT(op) == 1` em construções com threads livres. (Contribuição de Peter Bierma em gh-133140.)

- Adiciona `PyUnstable_Object_IsUniqueReferencedTemporary()` para determinar se um objeto é um objeto temporário exclusivo na pilha de operandos do interpretador. Isso pode ser usado em alguns casos como um substituto para verificar se `Py_REFCNT()` é `1` para objetos Python passados como argumentos para funções da API C. (Contribuição de Sam Gross em gh-133164.)

### Mudanças na API C limitada

- Na API C limitada versão 3.14 e versões mais novas, `Py_TYPE()` e `Py_REFCNT()` agora são implementadas como uma chamada de função opaca para ocultar detalhes de implementação. (Contribuição de Victor Stinner em gh-120600 e gh-124127.)

- Remove as macros `PySequence_Fast_GET_SIZE`, `PySequence_Fast_GET_ITEM` e `PySequence_Fast_ITEMS` da API C limitada, já que elas estiveram quebradas na API C limitada. (Contribuição de Victor Stinner em gh-91417.)

### APIs C removidas

- A criação de `tipos imutáveis` com bases mutáveis foi descontinuada no Python 3.12, e agora levanta `TypeError`. (Contribuição de Nikita Sobolev em gh-119775.)

- Remove o membro `PyDictObject.ma_version_tag`, que foi descontinuado no Python 3.12. Em vez disso, use a API `PyDict_AddWatcher()`. (Contribuição de Sam Gross em gh-124296.)

- Remova a função privada `_Py_InitializeMain()`. Era uma API provisória adicionada ao Python 3.8 pela PEP 587. (Contribuição de Victor Stinner em gh-129033.)

- Remove as APIs não documentadas `Py_C_RECURSION_LIMIT` e `PyThreadState.c_recursion_remaining`. Elas foram adicionadas no 3.13 e foram removidas sem descontinuação. Use `Py_EnterRecursiveCall()` para se proteger contra recursão descontrolada em código C. (Remoção por Petr Viktorin em gh-133079, veja também gh-130396.)

### APIs C descontinuadas

- A macro `Py_HUGE_VAL` está agora suavemente descontinuada. Em vez disso, use `Py_INFINITY`. (Contribuição de Sergey B Kirpichev em gh-120026.)

- As macros `Py_IS_NAN`, `Py_IS_INFINITY` e `Py_IS_FINITE` estão agora suavemente descontinuadas. Em vez delas, use `isnan`, `isinf` e `isfinite`, disponíveis em `math.h` desde C99. (Contribuição de Sergey B Kirpichev em gh-119613.)

- Sequências não-tuplas estão agora descontinuadas como argumento para a unidade de formato `(items)` em `PyArg_ParseTuple()` e outras funções de análise de argumentos se items contiver unidades de formato que armazenam um buffer emprestado ou uma referência emprestada. (Contribuição de Serhiy Storchaka em gh-50333.)

- A função `_PyMonitoring_FireBranchEvent` está agora descontinuada e deve ser substituída por chamadas para `PyMonitoring_FireBranchLeftEvent()` e `PyMonitoring_FireBranchRightEvent()`.

- A função `PySequence_In()`, anteriormente não documentada, está agora suavemente descontinuado. Em vez disso, use `PySequence_Contains()`. (Contribuição de Yuki Kobayashi em gh-127896.)

#### Remoção pendente no Python 3.15

- The `PyImport_ImportModuleNoBlock()`: use `PyImport_ImportModule()`.

- `PyWeakref_GetObject()` e `PyWeakref_GET_OBJECT()`: Use `PyWeakref_GetRef()`. O projeto pythoncapi-compat pode ser usado para usar `PyWeakref_GetRef()` no Python 3.12 e versões anteriores.

- O tipo `Py_UNICODE` e a macro `Py_UNICODE_WIDE`: use `wchar_t`.

- `PyUnicode_AsDecodedObject()`: use `PyCodec_Decode()`.

- `PyUnicode_AsDecodedUnicode()`: Use `PyCodec_Decode()`; Note que alguns codecs (por exemplo, “base64”) podem retornar um tipo diferente de `str`, tal como `bytes`.

- `PyUnicode_AsEncodedObject()`: use `PyCodec_Encode()`.

- `PyUnicode_AsEncodedUnicode()`: Use `PyCodec_Encode()`; Note que alguns codecs (por exemplo, “base64”) podem retornar um tipo diferente de `bytes`, tal com `str`.

- Funções de inicialização do Python, descontinuadas no Python 3.9:

  - `Py_GetPath()`: Use `PyConfig_Get("module_search_paths")` (`sys.path`).

  - `Py_GetPrefix()`: Use `PyConfig_Get("base_prefix")` (`sys.base_prefix`). Use `PyConfig_Get("prefix")` (`sys.prefix`) se ambientes virtuais precisam ser tratados.

  - `Py_GetExecPrefix()`: Use `PyConfig_Get("base_exec_prefix")` (`sys.base_exec_prefix`). Use `PyConfig_Get("exec_prefix")` (`sys.exec_prefix`) se ambientes virtuais precisam ser tratados.

  - `Py_GetProgramFullPath()`: Use `PyConfig_Get("executable")` (`sys.executable`).

  - `Py_GetProgramName()`: Use `PyConfig_Get("executable")` (`sys.executable`).

  - `Py_GetPythonHome()`: Use `PyConfig_Get("home")` ou a variável de ambiente `PYTHONHOME`.

  O projeto pythoncapi-compat pode ser usado para obter `PyConfig_Get()` no Python 3.13 e versões anteriores.

- Funções para configurar a inicialização do Python, descontinuadas no Python 3.11:

  - `PySys_SetArgvEx()`: defina `PyConfig.argv`.

  - `PySys_SetArgv()`: defina `PyConfig.argv`.

  - `Py_SetProgramName()`: defina `PyConfig.program_name`.

  - `Py_SetPythonHome()`: defina `PyConfig.home`.

  - `PySys_ResetWarnOptions()`: apague `sys.warnoptions` e `warnings.filters`.

  Em vez disso, a API `Py_InitializeFromConfig()` deve ser usada com `PyConfig`.

- Variáveis de configuração globais

  - `Py_DebugFlag`: Use `PyConfig.parser_debug` ou `PyConfig_Get("parser_debug")`.

  - `Py_VerboseFlag`: Use `PyConfig.verbose` ou `PyConfig_Get("verbose")`.

  - `Py_QuietFlag`: Use `PyConfig.quiet` ou `PyConfig_Get("quiet")`.

  - `Py_InteractiveFlag`: Use `PyConfig.interactive` ou `PyConfig_Get("interactive")`.

  - `Py_InspectFlag`: Use `PyConfig.inspect` ou `PyConfig_Get("inspect")`.

  - `Py_OptimizeFlag`: Use `PyConfig.optimization_level` ou `PyConfig_Get("optimization_level")`.

  - `Py_NoSiteFlag`: Use `PyConfig.site_import` ou `PyConfig_Get("site_import")`.

  - `Py_BytesWarningFlag`: Use `PyConfig.bytes_warning` ou `PyConfig_Get("bytes_warning")`.

  - `Py_FrozenFlag`: Use `PyConfig.pathconfig_warnings` ou `PyConfig_Get("pathconfig_warnings")`.

  - `Py_IgnoreEnvironmentFlag`: Use `PyConfig.use_environment` ou `PyConfig_Get("use_environment")`.

  - `Py_DontWriteBytecodeFlag`: Use `PyConfig.write_bytecode` ou `PyConfig_Get("write_bytecode")`.

  - `Py_NoUserSiteDirectory`: Use `PyConfig.user_site_directory` ou `PyConfig_Get("user_site_directory")`.

  - `Py_UnbufferedStdioFlag`: Use `PyConfig.buffered_stdio` ou `PyConfig_Get("buffered_stdio")`.

  - `Py_HashRandomizationFlag`: Use `PyConfig.use_hash_seed` e `PyConfig.hash_seed` ou `PyConfig_Get("hash_seed")`.

  - `Py_IsolatedFlag`: Use `PyConfig.isolated` ou `PyConfig_Get("isolated")`.

  - `Py_LegacyWindowsFSEncodingFlag`: Use `PyPreConfig.legacy_windows_fs_encoding` ou `PyConfig_Get("legacy_windows_fs_encoding")`.

  - `Py_LegacyWindowsStdioFlag`: Use `PyConfig.legacy_windows_stdio` ou `PyConfig_Get("legacy_windows_stdio")`.

  - `Py_FileSystemDefaultEncoding`, `Py_HasFileSystemDefaultEncoding`: Use `PyConfig.filesystem_encoding` ou `PyConfig_Get("filesystem_encoding")`.

  - `Py_FileSystemDefaultEncodeErrors`: Use `PyConfig.filesystem_errors` ou `PyConfig_Get("filesystem_errors")`.

  - `Py_UTF8Mode`: Use `PyPreConfig.utf8_mode` ou `PyConfig_Get("utf8_mode")`. (veja `Py_PreInitialize()`)

  A API `Py_InitializeFromConfig()` deve ser usada com `PyConfig` para definir essas opções. Ou `PyConfig_Get()` pode ser usado para obter essas opções em tempo de execução.

#### Remoção pendente no Python 3.16

- A cópia empacotada do `libmpdec`.

#### Remoção pendente no Python 3.18

- As seguintes funções privadas estão descontinuado e planejadas para remoção no Python 3.18:

  - `_PyBytes_Join()`: use `PyBytes_Join()`.

  - `_PyDict_GetItemStringWithError()`: use `PyDict_GetItemStringRef()`.

  - `_PyDict_Pop()`: use `PyDict_Pop()`.

  - `_PyLong_Sign()`: use `PyLong_GetSign()`.

  - `_PyLong_FromDigits()` e `_PyLong_New()`: use `PyLongWriter_Create()`.

  - `_PyThreadState_UncheckedGet()`: use `PyThreadState_GetUnchecked()`.

  - `_PyUnicode_AsString()`: use `PyUnicode_AsUTF8()`.

  - `_PyUnicodeWriter_Init()`: substitua `_PyUnicodeWriter_Init(&writer)` por `writer = PyUnicodeWriter_Create(0)`.

  - `_PyUnicodeWriter_Finish()`: substitua `_PyUnicodeWriter_Finish(&writer)` por `PyUnicodeWriter_Finish(writer)`.

  - `_PyUnicodeWriter_Dealloc()`: substitua `_PyUnicodeWriter_Dealloc(&writer)` por `PyUnicodeWriter_Discard(writer)`.

  - `_PyUnicodeWriter_WriteChar()`: substituta `_PyUnicodeWriter_WriteChar(&writer, ch)` por `PyUnicodeWriter_WriteChar(writer, ch)`.

  - `_PyUnicodeWriter_WriteStr()`: substitua `_PyUnicodeWriter_WriteStr(&writer, str)` por `PyUnicodeWriter_WriteStr(writer, str)`.

  - `_PyUnicodeWriter_WriteSubstring()`: substitua `_PyUnicodeWriter_WriteSubstring(&writer, str, start, end)` por `PyUnicodeWriter_WriteSubstring(writer, str, start, end)`.

  - `_PyUnicodeWriter_WriteASCIIString()`: substitua `_PyUnicodeWriter_WriteASCIIString(&writer, str)` por `PyUnicodeWriter_WriteASCII(writer, str)`.

  - `_PyUnicodeWriter_WriteLatin1String()`: substitua `_PyUnicodeWriter_WriteLatin1String(&writer, str)` por `PyUnicodeWriter_WriteUTF8(writer, str)`.

  - `_PyUnicodeWriter_Prepare()`: (sem substituto).

  - `_PyUnicodeWriter_PrepareKind()`: (sem substituto).

  - `_Py_HashPointer()`: use `Py_HashPointer()`.

  - `_Py_fopen_obj()`: use `Py_fopen()`.

  O projeto pythoncapi-compat pode ser usado para obter essas novas funções públicas no Python 3.13 e versões anteriores. (Contribuição de Victor Stinner em gh-128863.)

#### Remoção pendente em versões futuras

As APIs a seguir foram descontinuadas e serão removidas, embora atualmente não haja uma data agendada para sua remoção.

- `Py_TPFLAGS_HAVE_FINALIZE`: desnecessária desde o Python 3.8.

- `PyErr_Fetch()`: use `PyErr_GetRaisedException()`.

- `PyErr_NormalizeException()`: use `PyErr_GetRaisedException()`.

- `PyErr_Restore()`: use `PyErr_SetRaisedException()`.

- `PyModule_GetFilename()`: use `PyModule_GetFilenameObject()`.

- `PyOS_AfterFork()`: use `PyOS_AfterFork_Child()`.

- `PySlice_GetIndicesEx()`: use `PySlice_Unpack()` e `PySlice_AdjustIndices()`.

- `PyUnicode_READY()`: desnecessário desde o Python 3.12

- `PyErr_Display()`: use `PyErr_DisplayException()`.

- `_PyErr_ChainExceptions()`: use `_PyErr_ChainExceptions1()`.

- O membro `PyBytesObject.ob_shash`: chame `PyObject_Hash()`.

- API do Thread Local Storage (TLS):

  - `PyThread_create_key()`: use `PyThread_tss_alloc()`.

  - `PyThread_delete_key()`: use `PyThread_tss_free()`.

  - `PyThread_set_key_value()`: use `PyThread_tss_set()`.

  - `PyThread_get_key_value()`: use `PyThread_tss_get()`.

  - `PyThread_delete_key_value()`: use `PyThread_tss_delete()`.

  - `PyThread_ReInitTLS()`: desnecessário desde o Python 3.7.

## Build changes

- PEP 776: Emscripten is now an officially supported platform at tier 3. As a part of this effort, more than 25 bugs in Emscripten libc were fixed. Emscripten now includes support for `ctypes`, `termios`, and `fcntl`, as well as experimental support for the new default interactive shell. (Contributed by R. Hood Chatham in gh-127146, gh-127683, and gh-136931.)

- Official Android binary releases are now provided on python.org.

- O GNU Autoconf 2.72 agora é necessário para gerar o `configure`. (Contribuição de Erlend Aasland em gh-115765.)

- `wasm32-unknown-emscripten` agora é uma plataforma de nível 3 segundo a PEP 11. (Contribuição de R. Hood Chatham em gh-127146, gh-127683 e gh-136931.)

- A vinculação baseada em `#pragma` com `python3*.lib` agora pode ser desativada com Py_NO_LINK_LIB. (Contribuição de Jean-Christophe Fillion-Robin em gh-82909.)

- O CPython agora habilita um conjunto de opções de compilador recomendadas por padrão para maior segurança. Use as opções `--disable-safety` e `configure` para desabilitá-las, ou a opção `--enable-slower-safety` para um conjunto maior de opções de compilador, embora com um custo de desempenho.

- A macro `WITH_FREELISTS` e a opção `--without-freelists` `configure` foram removidas.

- The new `configure` option `--with-tail-call-interp` may be used to enable the experimental tail call interpreter. See Um novo tipo de interpretador for further details.

- Para desabilitar o novo suporte à depuração remota, use as opções `--without-remote-debug` e `configure`. Isso pode ser útil por motivos de segurança.

- Aplicações iOS e macOS agora podem ser configurados para redirecionar o conteúdo `stdout` e `stderr` para o log do sistema. (Contribuição de Russell Keith-Magee em gh-127592.)

- O ambiente de teste do iOS agora pode transmitir a saída do teste enquanto ele está em execução. O ambiente de teste também pode ser usado para executar o conjunto de testes de outros projetos além do CPython. (Contribuição de Russell Keith-Magee em gh-127592.)

### `build-details.json`

As instalações do Python agora contêm um novo arquivo, `build-details.json`. Este é um documento JSON estático contendo detalhes da construção do CPython, permitindo introspecção sem a necessidade de executar código. Isso é útil para casos de uso como inicializadores do Python, compilação cruzada e assim por diante.

`build-details.json` deve ser instalado no diretório da biblioteca padrão independente de plataforma. Isso corresponde ao caminho de instalação ‘stdlib’ `sysconfig`, que pode ser encontrado executando `sysconfig.get_path('stdlib')`.

Ver também

PEP 739 – `build-details.json` 1.0 – um arquivo de descrição estática para detalhes de construção do Python

### Descontinuação de assinaturas PGP

Assinaturas PGP (Pretty Good Privacy) não serão fornecidas para versões do Python 3.14 ou versões futuras. Para verificar artefatos do CPython, os usuários devem usar materiais de verificação do Sigstore. As versões são assinadas usando o Sigstore desde o Python 3.11.

Essa mudança no processo de lançamento foi especificada em PEP 761.

### Free-threaded Python is officially supported

The free-threaded build of Python is now supported and no longer experimental. This is the start of phase II where free-threaded Python is officially supported but still optional.

The free-threading team are confident that the project is on the right path, and appreciate the continued dedication from everyone working to make free-threading ready for broader adoption across the Python community.

With these recommendations and the acceptance of this PEP, the Python developer community should broadly advertise that free-threading is a supported Python build option now and into the future, and that it will not be removed without a proper deprecation schedule.

Any decision to transition to phase III, with free-threading as the default or sole build of Python is still undecided, and dependent on many factors both within CPython itself and the community. This decision is for the future.

Ver também

PEP 779

PEP 779’s acceptance

### Versões binárias para o compilador experimental just-in-time

Os binários oficiais de lançamento para macOS e Windows agora incluem um compilador JIT (just-in-time) experimental. Embora não seja recomendado para uso em produção, ele pode ser testado definindo `PYTHON_JIT=1` como uma variável de ambiente. Construções de código-fonte downstream e redistribuidores podem usar a opção de configuração `--enable-experimental-jit=yes-off` para obter um comportamento semelhante.

O JIT está em estágio inicial e ainda em desenvolvimento ativo. Portanto, o impacto típico de sua ativação no desempenho pode variar de 10% mais lento a 20% mais rápido, dependendo da carga de trabalho. Para auxiliar nos testes e na avaliação, um conjunto de funções de introspecção foi fornecido no espaço de nomes `sys._jit`. `sys._jit.is_available()` pode ser usado para determinar se o executável atual oferece suporte a compilação JIT, enquanto `sys._jit.is_enabled()` pode ser usado para informar se a compilação JIT foi ativada para o processo atual.

Atualmente, a funcionalidade ausente mais significativa é que depuradores e profilers nativos, como `gdb` e `perf`, não conseguem desenrolar quadros JIT (depuradores e profilers Python, como `pdb` ou `profile`, continuam funcionando sem modificações). Construções com threads livres não oferecem suporte a compilação JIT.

Por favor, relate quaisquer bugs ou grandes regressões de desempenho que você encontrar!

Ver também

PEP 744

## Portando para o Python 3.14

Esta seção lista as alterações descritas anteriormente e outras correções que podem exigir alterações no seu código.

### Alterações na API Python

- On Unix platforms other than macOS, forkserver is now the default start method for `multiprocessing` and `ProcessPoolExecutor`, instead of fork.

  Consulte (1) e (2) para detalhes.

  Se você encontrar `NameError`s ou erros de serialização com pickle vindos de `multiprocessing` ou `concurrent.futures`, consulte as restrições do forkserver.

  This change does not affect Windows or macOS, where ‘spawn’ remains the default start method.

- `functools.partial` agora é um descritor de método. Envolva-o em `staticmethod()` se quiser preservar o comportamento antigo. (Contribuição de Serhiy Storchaka e Dominykas Grigonis em gh-121027.)

- O coletor de lixo agora é incremental, o que significa que o comportamento de `gc.collect()` muda ligeiramente:

  - `gc.collect(1)`: Executa um incremento da coleta de lixo, em vez de coletar a geração 1.

  - Outras chamadas para `gc.collect()` não foram alteradas.

- A função `locale.nl_langinfo()` agora define temporariamente a localidade `LC_CTYPE` em alguns casos. Esta alteração temporária afeta outras threads. (Contribuição de Serhiy Storchaka em gh-69998.)

- `types.UnionType` agora é um apelido para `typing.Union`, causando alterações em alguns comportamentos. Veja acima para mais detalhes. (Contribuição de Jelle Zijlstra em gh-105499.)

- The runtime behavior of annotations has changed in various ways; see above for details. While most code that interacts with annotations should continue to work, some undocumented details may behave differently.

- As part of making the `mimetypes` CLI public, it now exits with `1` on failure instead of `0` and `2` on incorrect command-line parameters instead of `1`. Error messages are now printed to stderr.

- The `\B` pattern in regular expression now matches the empty string when given as the entire pattern, which may cause behavioural changes.

- On FreeBSD, `sys.platform` no longer contains the major version number.

### Changes in annotations (PEP 649 and PEP 749)

This section contains guidance on changes that may be needed to annotations or Python code that interacts with or introspects annotations, due to the changes related to deferred evaluation of annotations.

In the majority of cases, working code from older versions of Python will not require any changes.

#### Implicações para o código anotado

Se você definir anotação em seu código (por exemplo, para uso com um verificador de tipo estático), essa alteração provavelmente não o afetará: você pode continuar escrevendo anotação da mesma forma que fazia com as versões anteriores de Python.

É provável que você consiga remover as strings entre aspas em anotações, que são frequentemente usadas para referência futura. Da mesma forma, se você usar `from __future__ import annotations` para evitar ter que escrever strings em anotações, poderá remover essa importação se você for manter seu código apenas para Python 3.14 e mais recentes. No entanto, se você depende de bibliotecas de terceiros que leem anotações, essas bibliotecas podem precisar de alterações no suporte a anotações sem aspas para funcionarem como esperado.

#### Implicações para leitores de `__annotations__`

If your code reads the `__annotations__` attribute on objects, you may want to make changes in order to support code that relies on deferred evaluation of annotations. For example, you may want to use `annotationlib.get_annotations()` with the `FORWARDREF` format, as the `dataclasses` module now does.

O pacote externo typing_extensions fornece compatibilidade retroativa parcial de algumas das funcionalidades do módulo `annotationlib`, como a enumeração `Format` e a função `get_annotations()`. Eles podem ser usados para escrever código com versão-cruzada que aproveite as vantagens do novo comportamento em Python 3.14.

#### Mudanças relacionadas

The changes in Python 3.14 are designed to rework how `__annotations__` works at runtime while minimizing breakage to code that contains annotations in source code and to code that reads `__annotations__`. However, if you rely on undocumented details of the annotation behavior or on private functions in the standard library, there are many ways in which your code may not work in Python 3.14. To safeguard your code against future changes, only use the documented functionality of the `annotationlib` module.

Em particular, não leia anotação diretamente do atributo dicionário com o espaço de nomes dos objetos de tipo. Use `annotationlib.get_annotate_from_class_namespace()` durante a construção da classe e `annotationlib.get_annotations()` depois.

Em versões anteriores, às vezes era possível acessar as anotações da classe a partir de uma instância de uma classe anotada. Esse comportamento não estava documentado e era acidental e não será mais possível em Python 3.14.

#### `from __future__ import annotations`

In Python 3.7, PEP 563 introduced the `from __future__ import annotations` future statement, which turns all annotations into strings.

However, this statement is now deprecated and it is expected to be removed in a future version of Python. This removal will not happen until after Python 3.13 reaches its end of life in 2029, being the last version of Python without support for deferred evaluation of annotations.

In Python 3.14, the behavior of code using `from __future__ import annotations` is unchanged.

### Alterações na API C

- `Py_Finalize()` agora exclui todas as strings internalizadas. Isso é incompatível com versões anteriores de qualquer extensão C que retenha uma string internada após uma chamada para `Py_Finalize()` e seja reutilizada após uma chamada para `Py_Initialize()`. Quaisquer problemas decorrentes desse comportamento normalmente resultarão em travamentos durante a execução da chamada subsequente para `Py_Initialize()` ao acessar memória não inicializada. Para corrigir, use um sanitizador de endereços para identificar qualquer uso após liberação proveniente de uma string internalizada e desalocá-la durante o desligamento do módulo. (Contribuição de Eddie Elizondo em gh-113601.)

- A API C objetos de exceção Unicode agora levanta `TypeError` se o argumento de exceção não for um objeto `UnicodeError`. (Contribuição de Bénédikt Tran em gh-127691.)

- O interpretador evita internamente algumas modificações na contagem de referências ao carregar objetos na pilha de operandos, pegando emprestadas referências quando possível. Isso pode levar a valores menores de contagem de referências em comparação com versões anteriores do Python. Extensões da API C que verificavam `Py_REFCNT()` de `1` para determinar se um argumento de função não é referenciado por nenhum outro código devem, em vez disso, usar `PyUnstable_Object_IsUniqueReferencedTemporary()` como uma substituição mais segura.

- Funções privadas promovidas para APIs C públicas:

  - `_PyBytes_Join()`: `PyBytes_Join()`

  - `_PyLong_IsNegative()`: `PyLong_IsNegative()`

  - `_PyLong_IsPositive()`: `PyLong_IsPositive()`

  - `_PyLong_IsZero()`: `PyLong_IsZero()`

  - `_PyLong_Sign()`: `PyLong_GetSign()`

  - `_PyUnicodeWriter_Dealloc()`: `PyUnicodeWriter_Discard()`

  - `_PyUnicodeWriter_Finish()`: `PyUnicodeWriter_Finish()`

  - `_PyUnicodeWriter_Init()`: use `PyUnicodeWriter_Create()`

  - `_PyUnicodeWriter_Prepare()`: (sem substituto)

  - `_PyUnicodeWriter_PrepareKind()`: (sem substituto)

  - `_PyUnicodeWriter_WriteChar()`: `PyUnicodeWriter_WriteChar()`

  - `_PyUnicodeWriter_WriteStr()`: `PyUnicodeWriter_WriteStr()`

  - `_PyUnicodeWriter_WriteSubstring()`: `PyUnicodeWriter_WriteSubstring()`

  - `_PyUnicode_EQ()`: `PyUnicode_Equal()`

  - `_PyUnicode_Equal()`: `PyUnicode_Equal()`

  - `_Py_GetConfig()`: `PyConfig_Get()` e `PyConfig_GetInt()`

  - `_Py_HashBytes()`: `Py_HashBuffer()`

  - `_Py_fopen_obj()`: `Py_fopen()`

  - `PyMutex_IsLocked()` : `PyMutex_IsLocked()`

  O projeto pythoncapi-compat pode ser usado para obter a maioria dessas novas funções no Python 3.13 e versões anteriores.