Quels sont les types de données intégrés de Python ?

Question

Accepted Answer

Python dispose d'un ensemble riche de types intégrés couvrant les nombres, le texte, les collections et bien d'autres. Les connaître — et distinguer lesquels sont **mutables** par rapport aux **immuables** — est fondamental.

## Types numériques

```python
x = 42          # int  — arbitrary precision (no overflow!)
y = 3.14        # float
z = 2 + 3j      # complex
b = True        # bool (a subclass of int: True == 1)
```

Remarque : `int` en Python a une **précision arbitraire** — il ne déborde jamais (contrairement aux entiers de taille fixe en C/Java) ; `2 ** 1000` fonctionne simplement.

## Texte et bytes

```python
s = "hello"     # str  — Unicode text (immutable)
data = b"bytes" # bytes — raw binary (immutable)
```

## Types de collections

```python
lst = [1, 2, 3]            # list  — ordered, MUTABLE, allows duplicates
tup = (1, 2, 3)            # tuple — ordered, IMMUTABLE
d = {"a": 1, "b": 2}       # dict  — key→value, mutable, insertion-ordered
s = {1, 2, 3}              # set   — unordered, unique elements, mutable
fs = frozenset({1, 2})     # frozenset — immutable set
```

## Le type spécial None

```python
result = None   # NoneType — represents "no value" (like null)
if result is None:   # always compare to None with `is`, not ==
    ...
```

## Vérification des types

```python
type(x)             # <class 'int'>
isinstance(x, int)  # True — the preferred check (handles subclasses)
```

## Résumé mutable vs immuable

```text
Immutable: int, float, bool, str, tuple, frozenset, bytes, None
Mutable:   list, dict, set, bytearray
```

Cette distinction est très importante — les objets immuables peuvent être des clés dict et sont sûrs à partager ; les objets mutables peuvent changer de manière inattendue s'ils sont aliasés.

## Pourquoi c'est important

Les types intégrés sont le vocabulaire de tout code Python.

Connaître le but de chaque type (list pour les séquences ordonnées, dict pour les paires clé-valeur, set pour l'unicité, tuple pour les enregistrements fixes), les entiers à précision arbitraire et surtout la **distinction entre mutable et immuable** (qui gouverne les clés dict, les bugs d'aliasing et ce qui peut être partagé en toute sécurité) est fondamental.

Choisir le bon type pour la tâche — et comprendre sa mutabilité — est une compétence Python essentielle qui affecte la correction et la performance dans tout un programme.