# Versions de Python : différences entre Python 2 et 3, nouveautés de 3.10 à 3.15 et quelle version installer

URL: https://skillaria.top/fr/guides/python/quelle-version-python

Python existe aujourd'hui en une seule branche active, la 3, et la dernière version stable est Python 3.15, sortie le 9 octobre 2026. Python 2 est abandonné depuis 2020 ; chaque version 3.x reçoit des correctifs pendant environ cinq ans. Cet article présente les nouveautés de 3.10 à 3.15, les dates de fin de support, la version à installer et la façon de vérifier celle que vous avez déjà.

Aujourd'hui, une seule branche du langage est vivante : Python 3. La dernière version stable est Python 3.15, sortie le 9 octobre 2026, tandis que Python 2 a officiellement cessé d'être maintenu dès 2020. Voici les différences entre les versions de Python, ce qui est apparu dans chacune des versions 3.10 à 3.15, laquelle installer et comment savoir celle que vous possédez déjà.

## Comment sont numérotées les versions de Python

Un numéro de version comporte trois nombres : `3.15.0`. Le premier est la version majeure (la branche du langage), le deuxième la version mineure, qui apporte de nouvelles fonctionnalités, et le troisième le numéro de correctif, qui ne contient que des corrections de bogues. Quand on parle des « versions de Python », on désigne en général les versions mineures : 3.10, 3.11, 3.12, etc.

Depuis 2019, un cycle annuel s'applique (PEP 602) : une nouvelle version mineure sort chaque année en octobre. Environ six mois avant la sortie, paraissent des versions alpha, puis bêta et candidates à la sortie ; après la sortie, viennent les correctifs du type 3.15.1, 3.15.2. Passer d'une version de correctif à l'autre est sans risque : le comportement du langage ne change pas entre elles.

D'où une certaine confusion dans les recherches : « python 311 » et « python 3.11 » désignent la même version, 3.11. Le numéro n'est pas un nombre décimal : 3.10 est plus récent que 3.9, et 3.15 est plus récent que 3.2.

## Python 2 et Python 3 : quelle différence

Python 3 est sorti en 2008 et a volontairement rompu la compatibilité ascendante pour corriger d'anciens choix du langage. Le code écrit pour Python 2 ne fonctionne donc souvent pas tel quel avec Python 3. La dernière version de la branche 2 est la 2.7 : son support a pris fin le 1er janvier 2020, et la version finale 2.7.18 est sortie en avril 2020.

| Élément | Python 2 | Python 3 |
| --- | --- | --- |

| Affichage | `print "hi"` — instruction | `print("hi")` — fonction |

| Chaînes | octets par défaut, Unicode avec `u"..."` | `str` — toujours Unicode, octets avec `bytes` |

| Division | `7 / 2` donne 3 | `7 / 2` donne 3.5, division entière avec `7 // 2` |

| Saisie | `raw_input()` | `input()` |

| Intervalles | `range` construit une liste, `xrange` est paresseux | `range` est paresseux |

| Support | absent depuis 2020 | nouvelle version chaque année |

Si vous trouvez un tutoriel ou une réponse où `print` s'écrit sans parenthèses, il s'agit de Python 2 : le contenu est dépassé. Apprendre cette branche aujourd'hui n'a guère d'intérêt : elle n'est plus installée sur les systèmes neufs, les bibliothèques ont abandonné sa prise en charge, et ses connaissances ne servent qu'à migrer du code ancien.

## Nouveautés de Python 3.10 à 3.15

Voici l'essentiel de chaque version, ce qui change le code du quotidien. Les listes complètes des modifications figurent dans la section What's New de la documentation officielle.

### Python 3.10 (octobre 2021)

- Filtrage par motifs `match`/`case` (PEP 634) — analyser des structures de données au lieu d'enchaîner des `if`/`elif`.
- Union de types avec la barre verticale : `int | None` au lieu de `Optional[int]` (PEP 604).
- Plusieurs gestionnaires de contexte entre parenthèses dans un seul `with`.
- Messages d'erreur de syntaxe nettement plus clairs.

```
def describe(point):
    match point:
        case (0, 0):
            return "origine"
        case (x, 0):
            return f"sur l'axe X : {x}"
        case _:
            return "ailleurs"

print(describe((3, 0)))  # sur l'axe X : 3
```

### Python 3.11 (octobre 2022)

- Vitesse : le projet Faster CPython a accéléré l'interpréteur d'environ un quart en moyenne, davantage sur certaines tâches.
- Repères précis dans la trace d'erreur : les flèches `^^^^` indiquent l'expression exacte qui a échoué (PEP 657).
- Groupes d'exceptions et `except*` (PEP 654), notes sur les exceptions via `add_note()`.
- Module `tomllib` pour lire le format TOML — par exemple `pyproject.toml`.

### Python 3.12 (octobre 2023)

- Nouvelle syntaxe des génériques : `def first[T](items: list[T]) -> T` et l'instruction `type` pour les alias de types (PEP 695).
- Les f-chaînes deviennent une grammaire complète (PEP 701) : à l'intérieur, on peut réutiliser les mêmes guillemets, mettre des retours à la ligne et des commentaires.
- Suppression du module `distutils`, obsolète, de la bibliothèque standard.
- Des suggestions encore plus détaillées dans les erreurs, par exemple « avez-vous oublié d'importer le module ? ».

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

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

songs = ["a", "b"]
print(f"Premier : {first(songs)!r}, au total {len(songs)}")
print(f"{"guillemets à l'intérieur"}")  # fonctionne à partir de 3.12
```

Au passage, sur la question fréquente « les f-chaînes depuis quelle version ? » : les f-chaînes elles-mêmes existent depuis Python 3.6, mais la liberté avec les guillemets et les retours à la ligne à l'intérieur des accolades date de 3.12.

### Python 3.13 (octobre 2024)

- Nouvelle console interactive : couleurs, édition sur plusieurs lignes, historique, commandes `exit` et `help` sans parenthèses.
- Version expérimentale sans GIL (free-threaded, PEP 703) et compilateur JIT expérimental (PEP 744).
- Suppression de « batteries mortes » — d'anciens modules comme `cgi` et `telnetlib` (PEP 594).
- La durée de correction des bogues des versions récentes passe à deux ans.

### Python 3.14 (octobre 2025)

- Chaînes de modèle, les t-chaînes : `t"Bonjour, {name}"` renvoient non pas une chaîne prête, mais un objet modèle qu'on peut traiter en toute sécurité (PEP 750).
- Évaluation différée des annotations (PEP 649) — moins de problèmes avec les types déclarés plus bas dans le fichier.
- La version sans GIL n'est plus expérimentale et bénéficie d'un support officiel.
- Module `compression.zstd`, coloration syntaxique dans la console, `except A, B:` sans parenthèses.

### Python 3.15 (9 octobre 2026)

- Import paresseux `lazy import` (PEP 810) : un module n'est chargé qu'à sa première utilisation, et non au démarrage. Dans la mesure faite pendant le cours, un script avec `lazy import pandas` démarre en 14 ms au lieu de 280 ms.
- Dictionnaire immuable intégré `frozendict` (PEP 814).
- Dépaquetage dans les compréhensions de listes : `[*g for g in groups]` (PEP 798).
- Profileur par échantillonnage Tachyon dans la bibliothèque standard (PEP 799).
- UTF-8 par défaut pour les fichiers (PEP 686) — fini les surprises d'encodage sous Windows.
- Nouvelles suggestions « Did you mean » dans les messages d'erreur.

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

Ce code ne fonctionne que sous 3.15 : sur les versions antérieures, `lazy import` et le dépaquetage dans une compréhension provoquent une `SyntaxError`, et `frozendict` une `NameError`.

## Dates de fin de support des versions de Python

Chaque version vit environ cinq ans. Elle reçoit d'abord les corrections de bogues habituelles et des versions de correctifs régulières (depuis 3.13, deux ans), puis seulement les correctifs de sécurité jusqu'à la fin de sa durée. Ensuite, elle est en fin de vie (end-of-life) : plus personne ne corrige ses failles.

| Version | Sortie | Fin de support | Statut en octobre 2026 |
| --- | --- | --- | --- |

| 2.7 | 2010 | janvier 2020 | non maintenue |

| 3.9 | octobre 2020 | octobre 2025 | non maintenue |

| 3.10 | octobre 2021 | octobre 2026 | support qui se termine |

| 3.11 | octobre 2022 | octobre 2027 | sécurité uniquement |

| 3.12 | octobre 2023 | octobre 2028 | sécurité uniquement |

| 3.13 | octobre 2024 | octobre 2029 | corrections de bogues |

| 3.14 | octobre 2025 | octobre 2030 | corrections de bogues |

| 3.15 | octobre 2026 | octobre 2031 | la plus récente |

Le statut actuel de chaque branche est publié sur la page Status of Python versions du Python Developer's Guide. Avant de choisir une version pour un projet appelé à durer, mieux vaut la consulter.

## Quelle version de Python installer

Pour apprendre et pour les nouveaux projets, prenez la dernière version stable, aujourd'hui Python 3.15. L'argument « je prends la 3.10 qui est éprouvée » ne tient pas : en octobre 2026, elle ne reçoit même plus les correctifs de sécurité, et apprendre le langage sur une version en fin de vie oblige à réapprendre ensuite. Au sein de Python 3, la compatibilité est bonne : le code écrit pour une ancienne version fonctionne presque toujours sur une plus récente, l'inverse n'étant pas vrai.

Il existe des exceptions. Si une bibliothèque indispensable n'a pas encore publié de paquets pour la version la plus récente (cela arrive dans les premières semaines après la sortie d'octobre, pour les paquets qui contiennent des extensions en C), prenez la précédente, 3.14. Sur un serveur à longue durée de vie, suivez la version fournie par les dépôts de votre distribution, ou installez celle qu'il vous faut avec uv. La règle principale : ne choisissez pas une version dont la fin de support est dans moins d'un an.

| Situation | Que faut-il installer |
| --- | --- |

| Vous apprenez le langage à partir de zéro | la dernière stable (3.15) |

| Nouveau projet | la dernière ou l'avant-dernière |

| Une bibliothèque ne prend pas en charge la nouveauté | la version mineure précédente |

| Ancien projet en 3.10 ou antérieur | prévoir la migration vers une version supportée |

| Code en Python 2 | le migrer vers Python 3 |

## Comment connaître sa version de Python

Dans le terminal, une seule commande suffit. Sous macOS et Linux, on utilise en général `python3`, sous Windows `python` ou le lanceur `py`.

```
$ python3 --version
Python 3.12.3        # ancienne version, il est temps de mettre à jour

$ python3 -V
Python 3.15.0
```

Sous Windows, le lanceur affiche toutes les versions installées ; uv montre celles qu'il voit et peut installer :

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

Depuis un programme, la version est donnée par le module `sys`. Le tuple `sys.version_info` se compare facilement, ce qui permet à un script de vérifier lui-même que l'interpréteur lui convient :

```
import sys

print(sys.version)            # chaîne complète avec la date de compilation
print(sys.version_info[:3])   # par exemple (3, 15, 0)

if sys.version_info < (3, 10):
    raise SystemExit("Python 3.10 ou plus récent est requis")
```

Si `python3 --version` n'affiche pas la version que vous avez installée, c'est qu'un autre interpréteur est trouvé en premier dans le PATH. Pour savoir lequel, utilisez `which python3` sous macOS et Linux, ou `where python` sous Windows.

## Plusieurs versions de Python sur un même ordinateur

Garder côte à côte 3.13 et 3.15 est tout à fait normal : chaque version s'installe dans son propre dossier. Le plus pratique est de les gérer avec uv : `uv python install 3.15` télécharge la version, et `uv python pin 3.15` l'attache au projet via le fichier `.python-version`. Sous Linux, mieux vaut ne pas toucher au Python système ni le mettre à jour à la main : les utilitaires du système en dépendent.

La version minimale d'un projet se déclare dans `pyproject.toml`, dans le champ `requires-python`. L'installateur de paquets refusera alors de l'installer sur un interpréteur inadapté.

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

## Conclusion

Les versions actuelles de Python appartiennent à la branche 3 ; la plus récente, 3.15, apporte l'import paresseux, `frozendict` et l'UTF-8 par défaut. Python 2 a pris fin en 2020, Python 3.10 quitte son support en octobre 2026 : il vaut donc mieux apprendre et démarrer des projets sur une version récente. Pour connaître la vôtre, tapez `python3 --version`. Dans le cours, chaque thème se termine par un bloc « Nouveautés de 3.10 à 3.15 », pour voir l'évolution des versions en pratique.

## FAQ

**Qu'est-ce que IDLE Python 3.10 64-bit dans le menu Démarrer ?**

C'est l'environnement de développement simple installé avec Python depuis python.org ; le nom indique la version de l'interpréteur et son architecture 64 bits. Si vous voyez 3.10, votre version arrive en fin de support : mieux vaut installer une version récente.

**Peut-on passer de Python 3.12 à 3.15 par-dessus ?**

Les versions mineures s'installent côte à côte, et non l'une par-dessus l'autre : après l'installation de 3.15, l'ancienne reste présente et peut être désinstallée séparément. Les bibliothèques doivent être réinstallées pour la nouvelle version, ou bien il faut recréer l'environnement virtuel.

**Quelle différence entre les versions 64 bits et 32 bits ?**

La version 64 bits peut utiliser davantage de mémoire et convient à tous les ordinateurs actuels ; la version 32 bits ne se choisit que pour de très vieux systèmes.

**À quoi servent les versions alpha et bêta ?**

Ce sont des versions préliminaires de la prochaine version, destinées à tester les bibliothèques et les projets ; pour apprendre et travailler, installez uniquement les versions finales.


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