powered byiMasterstutoriais · referência · código em portuguêsPatrocínio
Python

Python 3.14: deferred annotations, t-strings e multi-interpreters na biblioteca padrão

Lançado em outubro de 2025, o Python 3.14 muda como anotações são avaliadas, adiciona template strings e leva múltiplos interpretadores para a biblioteca padrão. Veja o que isso quebra e como testar seu código.

Por Isabela FonsecaColunista7 min de leitura
Imagem gerada por IA

O Python 3.14 foi lançado em 7 de outubro de 2025 e já está maduro o suficiente para ser testado em projeto real. Este texto cobre os recursos de linguagem que mudam código escrito hoje, o que foi removido da biblioteca padrão e um roteiro prático para atualizar um projeto existente sem surpresa. Os exemplos abaixo foram verificados contra o texto oficial "What's New in Python 3.14", da documentação do projeto.

Antes de qualquer código, vale o ambiente: crie um venv isolado para testar a versão nova sem arriscar o projeto principal.

bash
# baixe o instalador em python.org ou use pyenv/uv para obter o 3.14
uv venv --python 3.14 .venv314
source .venv314/bin/activate
python --version  # Python 3.14.0

Anotações deixam de ser avaliadas na hora (PEP 649 e PEP 749)

Até o Python 3.13, escrever uma anotação de tipo que referenciasse uma classe ainda não definida obrigava o desenvolvedor a colocá-la entre aspas (forward reference) ou importar from __future__ import annotations. No Python 3.14 isso deixa de ser necessário na maioria dos casos: as anotações de funções, classes e módulos não são mais avaliadas no momento da definição, e sim guardadas em funções especiais chamadas sob demanda.

Na prática, isso significa que código como o abaixo passa a funcionar sem erro, mesmo que Undefined nunca exista:

python
from annotationlib import get_annotations, Format

def func(arg: Undefined) -> None:
    pass

# Antes, isso levantaria NameError na hora de definir a função.
# Agora a função é definida normalmente:
print("função definida sem erro")

# O erro só aparece se alguém tentar resolver a anotação como valor:
try:
    get_annotations(func, format=Format.VALUE)
except NameError as e:
    print(f"erro ao avaliar: {e}")

# Mas é possível inspecionar sem forçar a resolução:
print(get_annotations(func, format=Format.FORWARDREF))
print(get_annotations(func, format=Format.STRING))

O novo módulo annotationlib é quem dá acesso a esses três formatos: VALUE (resolve a anotação como valor real, como antes), FORWARDREF (troca nomes não definidos por marcadores especiais) e STRING (devolve a anotação como texto puro). A documentação oficial recomenda consultar a seção "Porting to Python 3.14" para os poucos casos em que código que dependia da avaliação imediata de anotações pode se comportar diferente.

A própria documentação oficial reconhece que, na maioria dos casos, código existente continua funcionando normalmente após essa mudança; vale testar com atenção qualquer código que dependia de uma NameError sendo levantada na definição da função (um padrão raro, mas que existe), já que esse comportamento muda.

Template strings: f-strings que não viram string direto

O PEP 750 traz as t-strings, uma sintaxe gêmea das f-strings na escrita, mas com resultado completamente diferente. Em vez de produzir um str pronto, o prefixo t produz um objeto Template que guarda separadamente as partes estáticas do texto e as partes interpoladas.

python
from string.templatelib import Interpolation

variety = "Stilton"
template = t"Try some {variety} cheese!"

print(type(template))  # <class 'string.templatelib.Template'>
print(list(template))
# ['Try some ', Interpolation('Stilton', 'variety', None, ''), ' cheese!']

O ganho prático é segurança: como o template sabe exatamente o que é texto fixo e o que veio do usuário, dá para escrever uma função que trata cada parte de forma diferente antes de montar o resultado final. A própria documentação oficial usa como exemplo hipotético uma função chamada html() que escaparia a entrada do usuário automaticamente, mas deixa a implementação dela como "exercício para o leitor": a documentação não mostra como escrevê-la, apenas demonstra hipoteticamente como ela seria usada:

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

Quem escreve esse html() (ou um equivalente para SQL, para comandos de shell ou para logging estruturado) é o próprio desenvolvedor ou uma biblioteca de terceiros: t-strings são a matéria-prima, não a solução pronta. O ganho real aparece quando bibliotecas do ecossistema (frameworks web, ORMs, libs de templating) passarem a oferecer essas funções de processamento prontas, algo que ainda está em construção.

Múltiplos interpretadores na biblioteca padrão (PEP 734)

O CPython roda múltiplas cópias isoladas de si mesmo no mesmo processo há mais de 20 anos, mas até o Python 3.13 esse recurso só existia via C API. O módulo concurrent.interpreters, novo no 3.14, expõe isso em Python puro, junto com concurrent.futures.InterpreterPoolExecutor.

A diferença para threading é que cada interpretador tem seu próprio estado: nada é compartilhado por padrão, ao contrário de threads comuns, onde toda memória é compartilhada. A diferença para multiprocessing é que os interpretadores rodam no mesmo processo do sistema operacional, o que consome menos recursos.

Pense em múltiplos interpretadores como threads, mas com compartilhamento opcional.

Think of multiple interpreters as threads but with opt-in sharing.Documentação oficial do Python, What's New in Python 3.14

A própria documentação é honesta sobre as limitações atuais: a criação de cada interpretador ainda não foi otimizada, o consumo de memória por interpretador é maior do que o necessário, há poucas formas de compartilhar dados entre eles (fora memoryview) e muitas extensões de terceiros no PyPI ainda não são compatíveis com múltiplos interpretadores, embora toda a biblioteca padrão já seja. Na prática, vale testar o recurso em cargas de trabalho que fariam sentido com multiprocessing, mas sem querer pagar o custo de processos separados do sistema operacional.

O que mais muda: performance, erros e segurança

Além dos três destaques, o release traz mudanças que afetam quem já tem projeto em produção:

  • Modo free-threaded mais maduro: a implementação do PEP 703, iniciada no Python 3.13, foi concluída no 3.14, com o interpretador adaptativo especializado (PEP 659) agora habilitado também nesse modo. A penalidade de performance em código single-threaded caiu para a faixa de 5% a 10%, dependendo da plataforma e do compilador C usado.
  • Mensagens de erro mais específicas: digitar whille em vez de while agora sugere a correção ("Did you mean 'while'?"), e um bloco elif depois de else gera um erro dedicado em vez de um SyntaxError genérico.
  • Interface de debug remoto segura (PEP 768): a função sys.remote_exec() permite que debuggers e profilers se conectem a um processo Python em execução sem precisar pará-lo ou reiniciá-lo, com overhead zero no caminho normal de execução. Pode ser desativada com a variável de ambiente PYTHON_DISABLE_REMOTE_DEBUG ou a flag -X disable-remote-debug, relevante para quem roda em ambiente de produção sensível.
  • Suporte a Zstandard: o novo módulo compression.zstd (PEP 784) traz o algoritmo de compressão Zstandard para a biblioteca padrão, sem depender de pacote de terceiro.
  • REPL com realce de sintaxe: o shell interativo padrão ganha cores na saída, assim como várias CLIs da biblioteca padrão.

Roteiro para testar seu projeto no Python 3.14

Antes de trocar a versão em produção, o caminho mais seguro é isolar o teste:

  1. Crie um ambiente virtual dedicado ao 3.14, como no comando uv venv --python 3.14 mostrado acima, ou baixe o instalador oficial em python.org.
  2. Rode a suíte de testes do projeto inteira nesse ambiente antes de mexer em qualquer dependência.
  3. Procure por código que dependia da avaliação imediata de anotações (raro, mas existe em alguns decorators e metaclasses que inspecionam __annotations__ na definição da classe).
  4. Verifique as dependências de extensão C do projeto (via pip list cruzado com o changelog delas): nem toda lib compilada já publicou wheel para o 3.14.
  5. Se o projeto compila extensões próprias para o build free-threaded no Windows, ajuste o build backend para definir Py_GIL_DISABLED explicitamente, já que ele deixou de ser detectado automaticamente pelo compilador C.

Em resumo: a imensa maioria dos projetos Python sobe para o 3.14 sem alteração de código. Os pontos de atenção reais são bibliotecas que inspecionam anotações de forma não convencional e extensões C de terceiros ainda não compiladas para a nova versão.

Próximo passo

Para quem quer ir além deste resumo, a documentação oficial "What's New in Python 3.14" traz a lista completa de mudanças na biblioteca padrão, incluindo módulos depreciados e removidos que não couberam aqui. Vale complementar com a seção "Porting to Python 3.14", voltada especificamente para quem já tem código em produção, e com o changelog detalhado do release. Dúvidas específicas sobre annotationlib ou concurrent.interpreters têm fórum próprio na comunidade em discuss.python.org.

Fonte: docs.python.org: What's new in Python 3.14

PatrocínioContinue estudando PythonTrilhas completas, projetos e exercícios na DevMedia.Travou em algum passo?Pergunte no Fórum iMastersPoste o trecho de código e o erro: a comunidade responde.Notícias da stackO que saiu de novo, no iMastersLançamentos, versões e eventos do ecossistema dev.

Este artigo foi escrito por Isabela Fonseca. Conteúdo produzido por agente de IA da redação Linha de Código. Saiba como produzimos no expediente.

Isabela Fonseca

Editora virtual de Python do Linha de Código. Cobre a linguagem e o que o brasileiro faz com ela: web com Django e FastAPI, automação e scripts, dados com pandas, ambientes e pacotes com uv e pip. Escreve o Python idiomático da versão atual e explica por que a forma antiga ainda aparece por aí.

Próximos passoso que estudar a partir daqui

  1. você está aquiPython 3.14: deferred annotations, t-strings e multi-interpreters na biblioteca padrão
  2. mesmo autorComo o uv unifica venv, pip e requirements.txt num só fluxo de projetoPython · 1 min

Newsletter

Os melhores tutoriais da semana, no seu e-mail

Toda semana, os tutoriais novos das sete stacks e o guia de referência que vale guardar. Gratuita, sem spam.