# Versões do Python: Python 2 e 3, novidades de 3.10 a 3.15 e qual versão instalar

URL: https://skillaria.top/pt/guides/python/versoes-python-2-3-novidades

A linha atual da linguagem é o Python 3; a versão mais recente é o Python 3.15 (lançado em 9 de outubro de 2026). O Python 2 não tem suporte desde 2020. Uma nova versão sai todo mês de outubro e recebe correções por cerca de cinco anos, por isso, para projetos novos, instale a 3.x mais recente; para descobrir a versão instalada, use o comando python3 --version.

Hoje a linha ativa da linguagem é uma só — o Python 3. A versão estável mais recente é o Python 3.15, lançada em 9 de outubro de 2026, e o Python 2 oficialmente deixou de existir em 2020. A seguir veja as diferenças entre as versões do Python, o que surgiu em cada uma das versões 3.10 a 3.15, qual instalar e como descobrir qual está no seu computador.

## Como funcionam as versões do Python

O número da versão tem três partes: `3.15.0`. O primeiro número é a versão principal (a linha da linguagem), o segundo é a versão secundária, na qual aparecem novos recursos, e o terceiro é o número de correção, que traz apenas correções de bugs. Quando se fala em "versões do Python", normalmente se referem às secundárias: 3.10, 3.11, 3.12 e assim por diante.

Desde 2019 vigora um ciclo anual (PEP 602): uma nova versão secundária sai todo mês de outubro. Cerca de seis meses antes do lançamento aparecem as versões alfa, depois as betas e os candidatos a lançamento, e após o lançamento vêm as correções do tipo 3.15.1, 3.15.2. Atualizar entre elas é seguro: o comportamento da linguagem nas versões de correção não muda.

Daí a confusão nas buscas: "python 311" e "python 3.11" são a mesma coisa, a versão 3.11. O número não é um decimal, então 3.10 é mais nova que 3.9, e 3.15 é mais nova que 3.2.

## Python 2 e Python 3: qual é a diferença

O Python 3 foi lançado em 2008 e quebrou a compatibilidade com a versão anterior de propósito, para corrigir decisões antigas da linguagem. Por isso, código escrito para o Python 2 muitas vezes não roda no Python 3 sem ajustes. A última versão da linha 2 foi a 2.7; o suporte terminou em 1º de janeiro de 2020, e a versão final, 2.7.18, saiu em abril de 2020.

| O quê | Python 2 | Python 3 |
| --- | --- | --- |

| Impressão | `print "oi"` — operador | `print("oi")` — função |

| Strings | bytes por padrão, Unicode — `u"..."` | `str` — sempre Unicode, bytes — `bytes` |

| Divisão | `7 / 2` dá 3 | `7 / 2` dá 3.5, divisão inteira — `7 // 2` |

| Entrada | `raw_input()` | `input()` |

| Intervalos | `range` cria uma lista, `xrange` é preguiçoso | `range` é preguiçoso |

| Suporte | não há desde 2020 | nova versão todo ano |

Se você encontrou um tutorial ou uma resposta em que o `print` aparece sem parênteses, é material de Python 2 — está desatualizado. Estudar a linha 2 hoje não faz sentido: ela não é instalada em sistemas novos, as bibliotecas há muito deixaram de oferecer suporte a ela, e o conhecimento dela serve no máximo para migrar código antigo.

## Novidades do Python 3.10 a 3.15

Abaixo estão os destaques de cada versão, aquilo que muda o código do dia a dia. As listas completas de alterações estão na seção What's New da documentação oficial.

### Python 3.10 (outubro de 2021)

- Correspondência de padrões `match`/`case` (PEP 634) — análise de estruturas de dados no lugar de cadeias de `if`/`elif`.
- União de tipos com barra vertical: `int | None` em vez de `Optional[int]` (PEP 604).
- Vários gerenciadores de contexto entre parênteses em um único `with`.
- Mensagens de erro de sintaxe bem mais claras.

```
def describe(point):
    match point:
        case (0, 0):
            return "origem das coordenadas"
        case (x, 0):
            return f"sobre o eixo X: {x}"
        case _:
            return "em outro lugar"

print(describe((3, 0)))  # sobre o eixo X: 3
```

### Python 3.11 (outubro de 2022)

- Velocidade: o projeto Faster CPython acelerou o interpretador em média cerca de um quarto, em algumas tarefas bem mais.
- Indicadores precisos no traceback: as setas `^^^^` mostram qual expressão exatamente causou a falha na linha (PEP 657).
- Grupos de exceções e `except*` (PEP 654), anotações para exceções via `add_note()`.
- Módulo `tomllib` para leitura de TOML — por exemplo, do `pyproject.toml`.

### Python 3.12 (outubro de 2023)

- Nova sintaxe de genéricos: `def first[T](items: list[T]) -> T` e o comando `type` para apelidos de tipos (PEP 695).
- As f-strings ganharam uma gramática completa (PEP 701): dentro delas podem ser usadas as mesmas aspas, quebras de linha e comentários.
- O obsoleto `distutils` foi removido da biblioteca padrão.
- Sugestões ainda mais detalhadas nos erros, por exemplo "esqueceu de importar o módulo?".

```
type Pair = tuple[int, int]

def first[T](items: list[T]) -> T:
    return items[0]

songs = ["a", "b"]
print(f"Primeira: {first(songs)!r}, no total {len(songs)}")
print(f"{"aspas dentro"}")  # funciona a partir da 3.12
```

A propósito, sobre a pergunta frequente "f-strings a partir de qual versão": as f-strings surgiram já no Python 3.6, e a liberdade com aspas e quebras de linha dentro das chaves foi acrescentada na 3.12.

### Python 3.13 (outubro de 2024)

- Novo console interativo: cores, edição de várias linhas, histórico, comandos `exit` e `help` sem parênteses.
- Build experimental sem GIL (free-threaded, PEP 703) e compilador JIT experimental (PEP 744).
- Removidos módulos antigos "baterias mortas", como `cgi` e `telnetlib` (PEP 594).
- O prazo de correções de bugs para as novas versões foi aumentado para dois anos.

### Python 3.14 (outubro de 2025)

- Template strings, t-strings: `t"Olá, {name}"` devolvem não uma string pronta, mas um objeto de template, que pode ser processado com segurança (PEP 750).
- Avaliação adiada das anotações (PEP 649) — menos problemas com tipos declarados mais abaixo no arquivo.
- O build sem GIL deixou de ser experimental e recebeu suporte oficial.
- Módulo `compression.zstd`, realce de sintaxe no console e `except A, B:` sem parênteses.

### Python 3.15 (9 de outubro de 2026)

- Importação preguiçosa `lazy import` (PEP 810): o módulo é carregado no primeiro uso, e não na inicialização. Na medição do curso, um script com `lazy import pandas` iniciou em 14 ms em vez de 280 ms.
- Dicionário imutável `frozendict`, embutido (PEP 814).
- Desempacotamento em listas por compreensão: `[*g for g in groups]` (PEP 798).
- Profiler por amostragem Tachyon na biblioteca padrão (PEP 799).
- UTF-8 por padrão ao trabalhar com arquivos (PEP 686) — acabaram as surpresas com codificação no Windows.
- Novas sugestões "Did you mean" nas mensagens de erro.

```
lazy import json                    # PEP 810
cfg = frozendict(limit=500)         # PEP 814
flat = [*g for g in [[1, 2], [3]]]  # PEP 798 -> [1, 2, 3]
print(flat, cfg["limit"])
# python -m profiling.sampling run app.py   # PEP 799, Tachyon
```

Este código roda apenas na 3.15: em versões mais antigas, `lazy import` e o desempacotamento em comprehension dão `SyntaxError`, e `frozendict` — `NameError`.

## Prazos de suporte das versões do Python

Cada versão vive cerca de cinco anos. No início ela recebe correções comuns de bugs e lançamentos regulares de correção (a partir da 3.13, dois anos), depois apenas correções de segurança até o fim do prazo. Em seguida a versão é considerada end-of-life: as vulnerabilidades nela não são mais corrigidas por ninguém.

| Versão | Lançamento | Fim do suporte | Situação em outubro de 2026 |
| --- | --- | --- | --- |

| 2.7 | 2010 | janeiro de 2020 | sem suporte |

| 3.9 | outubro de 2020 | outubro de 2025 | sem suporte |

| 3.10 | outubro de 2021 | outubro de 2026 | suporte terminando |

| 3.11 | outubro de 2022 | outubro de 2027 | apenas segurança |

| 3.12 | outubro de 2023 | outubro de 2028 | apenas segurança |

| 3.13 | outubro de 2024 | outubro de 2029 | correções de bugs |

| 3.14 | outubro de 2025 | outubro de 2030 | correções de bugs |

| 3.15 | outubro de 2026 | outubro de 2031 | mais recente |

Versões ainda mais antigas, como o Python 3.7 (fim do suporte em junho de 2023) e o 3.8 (outubro de 2024), também estão sem correções; aparecem apenas em sistemas legados.

O status atual de cada linha é publicado na página Status of Python versions do Python Developer's Guide. Antes de escolher a versão para um projeto de longa duração, vale consultá-la.

## Qual versão do Python instalar

Para estudar e para projetos novos, instale a versão estável mais recente, hoje o Python 3.15. O argumento "vou pegar a 3.10, que é testada" não funciona: em outubro de 2026 ela deixa de receber até correções de segurança, e aprender a linguagem numa versão que está saindo de cena significa reaprender depois. Dentro do Python 3 a compatibilidade é boa: o código de uma versão antiga quase sempre roda na nova, mas o contrário não é verdade.

Há exceções. Se a biblioteca necessária ainda não publicou pacotes para a versão mais recente (isso acontece nas primeiras semanas após o lançamento de outubro, em pacotes com extensões em C), use a anterior, a 3.14. Em um servidor de vida longa, siga a versão dos repositórios da distribuição ou instale a necessária pelo gerenciador uv. A regra principal é não escolher uma versão que tenha menos de um ano de suporte restante.

| Situação | O que instalar |
| --- | --- |

| Aprendendo a linguagem do zero | a estável mais recente (3.15) |

| Projeto novo | a mais recente ou a penúltima |

| Biblioteca não suporta a novidade | a secundária anterior |

| Projeto antigo na 3.10 ou inferior | planejar a migração para uma versão suportada |

| Código em Python 2 | migrar para o Python 3 |

## Como descobrir a versão do Python

No terminal basta um comando. No macOS e no Linux normalmente se usa `python3`; no Windows, `python` ou o lançador `py`.

```
$ python3 --version
Python 3.12.3        # versão antiga — hora de atualizar

$ python3 -V
Python 3.15.0
```

No Windows, o lançador mostra todas as versões instaladas de uma vez, e o uv mostra as versões que ele enxerga e pode instalar:

```
py --list
uv python list
```

Dentro de um programa, a versão é fornecida pelo módulo `sys`. A tupla `sys.version_info` é cômoda para comparação, para que o script verifique sozinho se o interpretador serve para ele:

```
import sys

print(sys.version)            # string completa com a data de build
print(sys.version_info[:3])   # por exemplo (3, 15, 0)

if sys.version_info < (3, 10):
    raise SystemExit("É necessário Python 3.10 ou mais novo")
```

Se o comando `python3 --version` mostra uma versão diferente da que você instalou, significa que o PATH encontra primeiro outro interpretador. Para ver qual é, use `which python3` no macOS e no Linux ou `where python` no Windows.

## Várias versões do Python no mesmo computador

Ter a 3.13 e a 3.15 lado a lado é normal: cada uma é instalada em sua própria pasta. Gerenciar essas versões é mais fácil com o uv: `uv python install 3.15` baixa a versão, e `uv python pin 3.15` a fixa para o projeto no arquivo `.python-version`. O Python do sistema no Linux é melhor não tocar nem atualizar manualmente — é nele que rodam as utilidades do próprio sistema operacional.

A versão mínima do projeto é indicada no `pyproject.toml`, no campo `requires-python`. Assim, o instalador de pacotes não deixa instalar o projeto em um interpretador inadequado.

```
[project]
name = "expenses"
version = "0.1.0"
requires-python = ">=3.15"
```

## Resumo

As versões atuais do Python pertencem à linha 3, e a mais nova é a 3.15, com lazy import, `frozendict` e UTF-8 por padrão. O Python 2 terminou em 2020, e a 3.10 sai de suporte em outubro de 2026, por isso estudar e começar projetos vale na versão recente. Para verificar a sua, use `python3 --version`. Em cada tema do curso há um bloco "O que há de novo em 3.10–3.15", então as mudanças de versão são vistas na prática.

## FAQ

**O que é o IDLE Python 3.10 64-bit no menu Iniciar?**

É o ambiente de desenvolvimento simples que o instalador do python.org adiciona; o nome indica a versão do interpretador e a arquitetura. Se aparece 3.10, você tem uma versão cujo suporte está terminando — é melhor instalar uma mais recente.

**Dá para atualizar do Python 3.12 para o 3.15 por cima?**

Versões secundárias são instaladas lado a lado, e não por cima: depois de instalar a 3.15 a antiga continua existindo, e pode ser removida separadamente. As bibliotecas precisam ser instaladas de novo na nova versão, ou o ambiente virtual deve ser recriado.

**Qual é a diferença entre as versões de 64 e 32 bits?**

A versão de 64 bits pode usar mais memória e serve para todos os computadores modernos; a de 32 bits é escolhida apenas para sistemas muito antigos.

**Para que servem as versões alfa e beta?**

São builds preliminares da próxima versão, para testar bibliotecas e projetos; para estudar e trabalhar, use apenas as versões finais.


---
Source: Skillaria.Top (https://skillaria.top)