Les types de données NumPy (dtype)

Pourquoi le dtype est important

Contrairement aux listes Python qui acceptent n'importe quel mélange de types, un tableau NumPy stocke un seul type de données pour tous ses éléments. Ce choix permet le stockage compact en mémoire et les opérations vectorisées rapides — les deux forces de NumPy.

Le dtype influence directement trois choses : la précision des calculs, la mémoire consommée, et les erreurs silencieuses possibles (un entier qui déborde, un flottant tronqué…).

import numpy as np

# NumPy déduit le dtype automatiquement
t_int   = np.array([1, 2, 3])
t_float = np.array([1.0, 2.0, 3.0])
t_bool  = np.array([True, False, True])

print(t_int.dtype)    # int64
print(t_float.dtype)  # float64
print(t_bool.dtype)   # bool

# Un seul flottant dans la liste → tout devient float64
t_mixte = np.array([1, 2, 3.0])
print(t_mixte.dtype)  # float64
  

Les types numériques disponibles

NumPy propose des types entiers et flottants sur plusieurs tailles de bits. Le suffixe indique le nombre de bits utilisés pour stocker chaque valeur :

• Entiers signés : int8, int16, int32, int64 — peuvent stocker des valeurs négatives
• Entiers non signés : uint8, uint16, uint32, uint64 — uniquement positifs, plage doublée
• Flottants : float16, float32, float64, float128 — précision croissante
• Complexes : complex64, complex128 — partie réelle + imaginaire
• Booléen : bool — True ou False

# Forcer un dtype à la création
t8  = np.array([100, 200, 300], dtype=np.int16)
tf  = np.array([1, 2, 3], dtype=np.float32)
tc  = np.array([1+2j, 3+4j], dtype=np.complex128)

print(t8.dtype)   # int16
print(tf.dtype)   # float32
print(tc.dtype)   # complex128

# Voir les plages de valeurs d'un type entier
print(np.iinfo(np.int8))
# Machine parameters for int8
# min = -128, max = 127

# Voir la précision d'un type flottant
print(np.finfo(np.float32).precision)  # 6 chiffres significatifs
print(np.finfo(np.float64).precision)  # 15 chiffres significatifs
  

Convertir le dtype d'un tableau existant

La méthode astype() crée une copie du tableau avec le nouveau type. Le tableau original n'est pas modifié — c'est un comportement important à retenir pour éviter les confusions. Pour comprendre la différence entre copie et vue, voir la page Vues et copies.

t = np.array([1.7, 2.3, 3.9])
print(t.dtype)  # float64

# Convertir en entiers — la partie décimale est tronquée (pas arrondie)
t_int = t.astype(np.int32)
print(t_int)    # [1 2 3]

# Convertir en booléens — 0 → False, tout le reste → True
t2 = np.array([0, 1, 5, -3])
print(t2.astype(bool))  # [False  True  True  True]

# Débordement silencieux à surveiller
t3 = np.array([200], dtype=np.int8)
# int8 va de -128 à 127, donc 200 déborde !
print(t3)  # [-56] ← résultat inattendu
  

Quel dtype choisir en pratique ?

Dans la majorité des cas, laisser NumPy choisir (int64 ou float64) est le bon choix — précision maximale, compatibilité garantie. On choisit un type plus petit uniquement quand la mémoire est contrainte :

• Images : uint8 (valeurs 0–255 par canal)
• Machine learning : float32 pour les poids de réseaux (compatible GPU, deux fois moins de mémoire que float64)
• Grands tableaux d'entiers : int32 si les valeurs tiennent dans ±2 milliards

Pour aller plus loin sur la création de tableaux avec des types spécifiques, voir la page Créer un tableau NumPy. Pour les opérations sur les données, voir Opérations mathématiques.

Par carabde | Mis à jour le 28 avril 2026