# Versioni di Python: Python 2 e 3, novità dalla 3.10 alla 3.15 e quale versione installare

URL: https://skillaria.top/it/guides/python/versioni-python

La linea attuale è Python 3, l'ultima versione stabile è Python 3.15 (uscita il 9 ottobre 2026); Python 2 non è supportato dal 2020. Una nuova versione esce ogni ottobre e riceve correzioni per circa cinque anni, quindi per i nuovi progetti installate una 3.x recente, e per verificare la versione usate il comando python3 --version.

Oggi la linea attiva del linguaggio è una sola: Python 3. L'ultima versione stabile è Python 3.15, uscita il 9 ottobre 2026, mentre Python 2 ha ufficialmente chiuso già nel 2020. Qui sotto vediamo in cosa differiscono le versioni di Python, che cosa è cambiato in ciascuna delle 3.10–3.15, quale installare e come scoprire quella che avete.

## Come sono fatte le versioni di Python

Il numero di versione è composto da tre cifre: `3.15.0`. La prima è la versione principale (la linea del linguaggio), la seconda è la versione minore, in cui compaiono le nuove funzionalità, la terza è il numero della correzione, che contiene solo bugfix. Quando si parla di «versioni di Python» di solito si intendono quelle minori: 3.10, 3.11, 3.12 e così via.

Dal 2019 vale un ciclo annuale (PEP 602): una nuova versione minore esce ogni ottobre. Circa sei mesi prima del rilascio escono le alpha, poi le beta e i release candidate, e dopo il rilascio le correzioni del tipo 3.15.1, 3.15.2. Passare da una patch all'altra è sicuro: il comportamento del linguaggio nelle versioni patch non cambia.

Da qui anche la confusione nelle ricerche: «python 311» e «python 3.11» sono la stessa cosa, la versione 3.11. Il numero non è un decimale, quindi 3.10 è più recente di 3.9, e 3.15 è più recente di 3.2.

## Python 2 e Python 3: la differenza

Python 3 è uscito nel 2008 e ha volutamente rotto la compatibilità all'indietro per correggere vecchie scelte del linguaggio. Per questo il codice scritto per Python 2 spesso non gira in Python 3 senza modifiche. L'ultima versione della seconda linea è la 2.7: il supporto è terminato il 1° gennaio 2020, mentre la release finale 2.7.18 è uscita nell'aprile 2020.

| Aspetto | Python 2 | Python 3 |
| --- | --- | --- |

| Stampa | `print "hi"` — istruzione | `print("hi")` — funzione |

| Stringhe | byte di default, Unicode — `u"..."` | `str` — sempre Unicode, i byte sono `bytes` |

| Divisione | `7 / 2` dà 3 | `7 / 2` dà 3.5, divisione intera — `7 // 2` |

| Input | `raw_input()` | `input()` |

| Intervalli | `range` costruisce una lista, `xrange` è pigro | `range` è pigro |

| Supporto | assente dal 2020 | nuova versione ogni anno |

Se trovate un manuale o una risposta in cui `print` è scritto senza parentesi, si tratta di Python 2 — il materiale è superato. Oggi non ha senso studiare questa linea: non viene installata nei sistemi nuovi, le librerie da tempo non la supportano, e le conoscenze su di essa servono solo per portare codice vecchio.

## Novità da Python 3.10 a 3.15

Qui i punti principali di ogni versione, quelli che cambiano il codice di tutti i giorni. Gli elenchi completi delle modifiche si trovano nella sezione What's New della documentazione ufficiale.

### Python 3.10 (ottobre 2021)

- Pattern matching `match`/`case` (PEP 634) — analisi delle strutture dati invece delle catene di `if`/`elif`.
- Unione dei tipi con la barra verticale: `int | None` al posto di `Optional[int]` (PEP 604).
- Più gestori di contesto tra parentesi in un unico `with`.
- Messaggi di errore di sintassi molto più chiari.

```
def describe(point):
    match point:
        case (0, 0):
            return "origine delle coordinate"
        case (x, 0):
            return f"sull'asse X: {x}"
        case _:
            return "da qualche altra parte"

print(describe((3, 0)))  # sull'asse X: 3
```

### Python 3.11 (ottobre 2022)

- Velocità: il progetto Faster CPython ha accelerato l'interprete in media di circa un quarto, su alcuni compiti di più.
- Puntatori precisi nel traceback: le frecce `^^^^` mostrano quale espressione della riga ha causato l'errore (PEP 657).
- Gruppi di eccezioni e `except*` (PEP 654), note alle eccezioni tramite `add_note()`.
- Il modulo `tomllib` per leggere il formato TOML — per esempio `pyproject.toml`.

### Python 3.12 (ottobre 2023)

- Nuova sintassi per i tipi generici: `def first[T](items: list[T]) -> T` e l'istruzione `type` per gli alias di tipo (PEP 695).
- Le f-string hanno ora una grammatica completa (PEP 701): all'interno si possono usare le stesse virgolette, a capo e commenti.
- Dalla libreria standard è stato rimosso il vecchio `distutils`.
- Messaggi di errore ancora più dettagliati, per esempio «avete dimenticato di importare il modulo?».

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

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

songs = ["a", "b"]
print(f"Prima: {first(songs)!r}, in tutto {len(songs)}")
print(f"{"virgolette annidate"}")  # funziona dalla 3.12
```

A proposito della domanda frequente «le f-string da quale versione»: le f-string sono apparse già in Python 3.6, mentre la libertà con virgolette e a capo dentro le parentesi graffe è arrivata con la 3.12.

### Python 3.13 (ottobre 2024)

- Nuova console interattiva: colori, modifica su più righe, cronologia, comandi `exit` e `help` senza parentesi.
- Build sperimentale senza GIL (free-threaded, PEP 703) e JIT compiler sperimentale (PEP 744).
- Rimosse le «dead batteries», le «batterie scariche»: vecchi moduli come `cgi` e `telnetlib` (PEP 594).
- Il periodo di correzione degli errori per le nuove versioni è stato portato a due anni.

### Python 3.14 (ottobre 2025)

- Template string, t-string: `t"Ciao, {name}"` restituisce non una stringa pronta ma un oggetto template, che si può elaborare in sicurezza (PEP 750).
- Valutazione differita delle annotazioni (PEP 649) — meno problemi con i tipi dichiarati più in basso nel file.
- La build senza GIL non è più sperimentale e ha ricevuto il supporto ufficiale.
- Modulo `compression.zstd`, evidenziazione della sintassi nella console, `except A, B:` senza parentesi.

### Python 3.15 (9 ottobre 2026)

- Import pigro `lazy import` (PEP 810): il modulo viene caricato al primo utilizzo, non all'avvio. Nella misura del corso, uno script con `lazy import pandas` è partito in 14 ms invece di 280 ms.
- Dizionario immutabile integrato `frozendict` (PEP 814).
- Spacchettamento nelle list comprehension: `[*g for g in groups]` (PEP 798).
- Profiler a campionamento Tachyon nella libreria standard (PEP 799).
- UTF-8 come codifica predefinita per i file (PEP 686) — niente più sorprese con le codifiche su Windows.
- Nuovi suggerimenti «Did you mean» nei messaggi di errore.

```
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
```

Questo codice gira solo con la 3.15: nelle versioni precedenti `lazy import` e lo spacchettamento nelle comprehension danno `SyntaxError`, mentre `frozendict` genera `NameError`.

## Tempi di supporto delle versioni Python

Ogni versione vive circa cinque anni. Prima riceve le normali correzioni di errori e le release di patch regolari (dalla 3.13 per due anni), poi solo le correzioni di sicurezza fino alla fine del periodo. Dopodiché la versione è considerata end-of-life: nessuno chiude più le vulnerabilità.

| Versione | Uscita | Fine supporto | Stato a ottobre 2026 |
| --- | --- | --- | --- |

| 2.7 | 2010 | gennaio 2020 | non supportata |

| 3.9 | ottobre 2020 | ottobre 2025 | non supportata |

| 3.10 | ottobre 2021 | ottobre 2026 | supporto in chiusura |

| 3.11 | ottobre 2022 | ottobre 2027 | solo sicurezza |

| 3.12 | ottobre 2023 | ottobre 2028 | solo sicurezza |

| 3.13 | ottobre 2024 | ottobre 2029 | correzioni di errori |

| 3.14 | ottobre 2025 | ottobre 2030 | correzioni di errori |

| 3.15 | ottobre 2026 | ottobre 2031 | la più recente |

Lo stato aggiornato di ogni linea è pubblicato nella pagina Status of Python versions della Python Developer's Guide. Prima di scegliere una versione per un progetto di lunga durata conviene consultarla.

## Quale versione di Python installare

Per lo studio e per i nuovi progetti — l'ultima stabile, oggi Python 3.15. L'argomento «prendo la 3.10 che è collaudata» non regge: a ottobre 2026 smette di ricevere anche le correzioni di sicurezza, e studiare il linguaggio su una versione in uscita dal supporto significa doverlo reimparare in seguito. All'interno di Python 3 la compatibilità è buona: il codice scritto per una versione vecchia quasi sempre gira su una nuova, mentre il contrario non è vero.

Ci sono delle eccezioni. Se la libreria che vi serve non ha ancora pubblicato le wheel per la versione più recente (succede nelle prime settimane dopo il rilascio di ottobre, con i pacchetti che contengono estensioni in C), prendete la precedente — la 3.14. Su un server a lunga vita fate riferimento alla versione dei repository della distribuzione oppure installate quella che serve con il gestore uv. La regola principale è non scegliere una versione che termina il supporto entro un anno.

| Situazione | Cosa installare |
| --- | --- |

| Imparate il linguaggio da zero | l'ultima stabile (3.15) |

| Nuovo progetto | l'ultima o la penultima |

| La libreria non supporta la novità | la versione minore precedente |

| Vecchio progetto sulla 3.10 o inferiore | pianificare il passaggio a una versione supportata |

| Codice Python 2 | portare su Python 3 |

## Come scoprire la versione di Python

Per conoscere la Python version installata, nel terminale basta un comando. Su macOS e Linux di solito si usa `python3`, su Windows `python` oppure il launcher `py`.

```
$ python3 --version
Python 3.12.3        # versione vecchia — è ora di aggiornare

$ python3 -V
Python 3.15.0
```

Su Windows il launcher mostra subito tutte le versioni installate, mentre uv elenca le versioni che vede e che può installare:

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

Dall'interno di un programma la versione si ottiene dal modulo `sys`. La tupla `sys.version_info` si confronta comodamente, così lo script può verificare da solo se l'interprete è adatto:

```
import sys

print(sys.version)            # stringa completa con la data di build
print(sys.version_info[:3])   # per esempio (3, 15, 0)

if sys.version_info < (3, 10):
    raise SystemExit("Serve Python 3.10 o più recente")
```

Se `python3 --version` mostra una versione diversa da quella che avete installato, significa che nel PATH viene trovato per primo un altro interprete. Per capire quale, usate `which python3` su macOS e Linux oppure `where python` su Windows.

## Più versioni di Python sullo stesso computer

Tenere affiancate la 3.13 e la 3.15 è normale: ciascuna si installa nella propria cartella. Il modo più comodo per gestirle è uv: `uv python install 3.15` scarica la versione, mentre `uv python pin 3.15` la associa al progetto nel file `.python-version`. Il Python di sistema su Linux è meglio non toccarlo né aggiornarlo a mano — su di esso girano le utility del sistema operativo.

La versione minima di un progetto si indica in `pyproject.toml`, nel campo `requires-python`. In questo modo il gestore dei pacchetti non permette di installare il progetto su un interprete non adatto.

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

## Riepilogo

Le versioni attuali di Python appartengono alla linea 3, la più recente è la 3.15 con l'import pigro, `frozendict` e UTF-8 come codifica predefinita. Python 2 è terminato nel 2020, la 3.10 esce dal supporto nell'ottobre 2026, quindi conviene studiare e avviare i progetti su una versione recente. Per verificare la vostra usate `python3 --version`. Nel corso ogni argomento si chiude con un blocco «Novità dalla 3.10 alla 3.15», così le differenze tra le versioni vengono esercitate nella pratica.

## FAQ

**Che cos'è IDLE Python 3.10 64-bit nel menu Start?**

È l'ambiente di sviluppo semplice incluso nell'installazione da python.org; nel nome sono indicate la versione dell'interprete e la sua architettura. Se c'è la 3.10, avete una versione in chiusura del supporto: meglio installarne una recente.

**Posso aggiornare Python 3.12 a 3.15 installando sopra?**

Le versioni minori si installano affiancate, non sovrapposte: dopo l'installazione della 3.15 la vecchia resta, e può essere rimossa separatamente. Le librerie vanno installate di nuovo per la versione nuova, oppure va ricreato l'ambiente virtuale.

**Che differenza c'è tra la versione a 64 bit e quella a 32 bit?**

La versione a 64 bit può usare più memoria ed è adatta a tutti i computer moderni; la versione a 32 bit si sceglie solo per sistemi molto vecchi.

**A cosa servono le versioni alpha e beta?**

Sono build preliminari della versione successiva, usate per testare librerie e progetti; per lo studio e il lavoro installate solo le release finali.


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