Les tableaux Python

Ce chapitre couvre le module array intégré de Python, qui fournit une séquence compacte à type restreint pour stocker des données numériques homogènes. Vous apprendrez ce que sont les typecodes, comment créer et indexer des tableaux, comment les modifier avec l'ensemble des méthodes disponibles, et — point crucial — quand un array est le meilleur choix par rapport à une liste Python ordinaire.

Qu'est-ce que le module array ?

Le module array de Python fournit un type de séquence qui stocke des éléments d'un unique type numérique compatible C. Contrairement à une liste, qui peut contenir n'importe quel mélange d'objets, chaque emplacement d'un array contient exactement le même type de valeur primitive (un entier, un flottant, etc.). Cette contrainte rend les tableaux plus efficaces en mémoire que les listes pour de grandes collections de nombres.

Points clés :

• Défini dans la bibliothèque standard — aucune installation requise.
• Tous les éléments doivent partager le même typecode (un seul caractère identifiant le type C).
• Prend en charge les opérations de séquence standard : indexation, découpage, itération, len() et test d'appartenance avec in.
• Utile lorsque vous avez besoin d'un stockage compact sans recourir à une bibliothèque tierce comme NumPy.

Si vous êtes déjà familier avec les listes Python, considérez un array comme une liste qui échange la flexibilité contre l'efficacité mémoire.

Typecodes

Chaque array est créé avec un typecode — une chaîne d'un seul caractère qui indique à Python quel type C utiliser pour chaque élément et donc combien d'octets occupe chaque emplacement.

La taille réelle en octets peut varier selon la plateforme. Utilisez array.itemsize pour l'inspecter à l'exécution.

Remarque sur 'u' (caractère Unicode) : Ce typecode a été déprécié dans Python 3.3 et supprimé dans Python 3.13. Ne l'utilisez pas dans du nouveau code — utilisez str ou bytes à la place.

Créer des tableaux

Importez le module et appelez array.array(typecode, initializer), où initializer est n'importe quel itérable de valeurs compatibles avec le typecode choisi.

import array as arr

# Array of signed integers
int_array = arr.array('i', [1, 2, 3, 4, 5])
print(int_array)          # array('i', [1, 2, 3, 4, 5])

# Array of double-precision floats
float_array = arr.array('d', [1.1, 2.2, 3.3])
print(float_array)        # array('d', [1.1, 2.2, 3.3])

# Inspect the typecode and bytes-per-element
print(int_array.typecode)   # i
print(int_array.itemsize)   # 4  (platform-dependent)

Vous pouvez également créer un tableau vide et le remplir ultérieurement :

import array as arr

empty = arr.array('i')   # empty integer array
empty.append(10)
empty.append(20)
print(empty)             # array('i', [10, 20])

Accéder aux éléments d'un tableau

L'indexation d'un array fonctionne exactement comme celle d'une liste : base zéro depuis la gauche, et les indices négatifs comptent depuis la droite.

Accéder à un index en dehors de la plage valide lève une IndexError, exactement comme pour les listes.

Découper des tableaux

Le découpage retourne un nouvel array du même typecode contenant les éléments sélectionnés. La syntaxe est a[start:stop:step] — identique à celle des listes et des chaînes.

Itérer sur un tableau

Vous pouvez itérer sur un array avec une boucle for, ou tester l'appartenance avec in :

import array as arr

a = arr.array('i', [10, 20, 30, 40, 50])

for item in a:
    print(item, end=' ')
# Output: 10 20 30 40 50

print()
print(30 in a)   # True
print(99 in a)   # False
print(len(a))    # 5

Modifier des tableaux

Les tableaux sont mutables — vous pouvez modifier, ajouter et supprimer des éléments après leur création.

Modifier un élément

Affectez une nouvelle valeur directement à un index :

Ajouter des éléments

Utilisez append() pour ajouter un seul élément à la fin, ou extend() pour ajouter plusieurs éléments depuis n'importe quel itérable :

Utilisez insert(index, value) pour placer un élément à une position spécifique :

import array as arr

a = arr.array('i', [1, 2, 3, 4, 5])

a.insert(2, 10)   # insert 10 before index 2
print(a)          # array('i', [1, 2, 10, 3, 4, 5])

Supprimer des éléments

remove(value) supprime la première occurrence de la valeur donnée et lève une ValueError si elle n'est pas trouvée :

pop(index) supprime et retourne l'élément à index (par défaut le dernier élément) :

import array as arr

a = arr.array('i', [1, 2, 3, 4, 5])

last = a.pop()     # removes and returns 5
print(last)        # 5
print(a)           # array('i', [1, 2, 3, 4])

second = a.pop(1)  # removes and returns element at index 1
print(second)      # 2
print(a)           # array('i', [1, 3, 4])

Recherche et comptage

index(value) retourne l'index de la première occurrence de value (lève une ValueError si absente) :

import array as arr

a = arr.array('i', [10, 20, 30, 20, 40])

print(a.index(20))   # 1 — first occurrence
print(a.index(30))   # 2

count(value) retourne le nombre de fois que value apparaît :

import array as arr

a = arr.array('i', [1, 2, 2, 3, 2, 4])

print(a.count(2))   # 3
print(a.count(9))   # 0

Inverser un tableau

reverse() inverse le tableau en place :

import array as arr

a = arr.array('i', [1, 2, 3, 4, 5])

a.reverse()
print(a)   # array('i', [5, 4, 3, 2, 1])

Convertir entre tableaux et listes

tolist() convertit un array en liste Python standard. Pour faire l'inverse, passez une liste à array.array() :

import array as arr

a = arr.array('i', [1, 2, 3, 4, 5])

# array → list
my_list = a.tolist()
print(my_list)          # [1, 2, 3, 4, 5]
print(type(my_list))    # <class 'list'>

# list → array
back = arr.array('i', my_list)
print(back)             # array('i', [1, 2, 3, 4, 5])

Changer le type des éléments

L'attribut typecode est en lecture seule. Pour stocker les mêmes valeurs sous un type différent, créez un nouvel array en utilisant l'original comme initialiseur :

Efficacité mémoire : tableaux vs. listes

La principale raison pratique d'utiliser le module array plutôt qu'une liste est la mémoire. Une liste stocke des références vers des objets Python ; un array stocke directement les valeurs C brutes.

import array as arr
import sys

n = 1000
my_list  = list(range(n))
my_array = arr.array('i', range(n))

print('List  size:', sys.getsizeof(my_list),  'bytes')
print('Array size:', sys.getsizeof(my_array), 'bytes')
# Example output (64-bit platform):
# List  size: 8056 bytes
# Array size: 4096 bytes

Pour de grands ensembles de données (des centaines de milliers d'entiers), les économies s'accumulent de manière significative. Si vous avez besoin de fonctionnalités encore plus avancées — calculs vectorisés, tableaux multidimensionnels — envisagez NumPy.

Quand utiliser les tableaux vs. les listes

Utilisez le module array lorsque :

• Vous stockez un grand nombre de valeurs numériques homogènes (lectures de capteurs, données de pixels, tampons réseau, etc.).
• L'utilisation de la mémoire est une préoccupation et vous ne pouvez pas utiliser une bibliothèque tierce.
• Vous lisez depuis ou écrivez vers des fichiers binaires ou des sockets réseau (les méthodes tofile() / fromfile() simplifient cette opération).

Restez avec les listes Python lorsque :

• Vous devez stocker des types mixtes ou des objets arbitraires.
• La collection est petite et la mémoire n'est pas un problème.
• Vous avez besoin de méthodes de liste riches telles que sort() avec une fonction clé.

Utilisez NumPy lorsque :

• Vous avez besoin d'opérations mathématiques sur des tableaux entiers (arithmétique vectorisée, algèbre matricielle, statistiques).
• Vous travaillez avec des données multidimensionnelles.

Référence des méthodes

Pratique