Tableaux de taille fixe

9.1 Caractéristiques des tableaux de taille fixe

Les tableaux de taille fixe sont des tableaux dont la taille est définie lors de leur création et ne peut pas être modifiée pendant l'exécution du programme. En Python, tu peux créer des tableaux de taille fixe à l'aide de la bibliothèque array ou utiliser des listes. Bien que les listes en Python puissent changer de taille, elles sont utilisées de manière similaire aux tableaux dans d'autres langages.

Caractéristiques des tableaux de taille fixe :

• Taille fixe : La taille du tableau est définie lors de sa création et ne peut pas être modifiée.
• Homogénéité : Tous les éléments du tableau doivent être du même type.
• Accès rapide par index : L'accès aux éléments du tableau se fait en temps constant O(1).
• Invariabilité de la taille : Le nombre d'éléments dans le tableau reste constant, et l'ajout de nouveaux éléments est impossible.

Exemple de création d'un tableau de taille fixe en Python :

Avec la bibliothèque array :

import array

# Création d'un tableau d'entiers (type 'i' pour int)
arr = array.array('i', [1, 2, 3, 4, 5])

# Accès aux éléments
print(arr[2])  # Affiche : 3

# Modification de la valeur d'un élément
arr[2] = 10
print(arr)  # Affiche : array('i', [1, 2, 10, 4, 5])

Avec une liste (en imitant un tableau de taille fixe) :

# Création d'une liste de taille fixe
arr = [0] * 5

# Initialisation des éléments
arr[0] = 1
arr[1] = 2
arr[2] = 3
arr[3] = 4
arr[4] = 5

# Accès aux éléments
print(arr[2])  # Affiche : 3

# Modification de la valeur d'un élément
arr[2] = 10
print(arr)  # Affiche : [1, 2, 10, 4, 5]

9.2 Avantages et inconvénients des tableaux de taille fixe

Tout a ses forces et ses faiblesses, et les tableaux fixes ne font pas exception.

Avantages :

• Accès rapide par index : L'accès à n'importe quel élément du tableau se fait en temps constant O(1), ce qui rend les tableaux très efficaces pour la lecture de données.
• Simplicité de mise en œuvre : Les tableaux sont faciles à comprendre et à utiliser, et il est aisé de les implémenter et de les appliquer à diverses tâches.
• Utilisation efficace de la mémoire : Comme la taille du tableau est fixe, la mémoire est allouée immédiatement lors de la création du tableau, ce qui permet d'éviter les coûts de réallocation de mémoire.
• Prévisibilité : La taille fixe du tableau simplifie la gestion de la mémoire et la prévisibilité de l'utilisation des ressources.

Inconvénients :

• Invariabilité de la taille : La taille du tableau est définie lors de sa création et ne peut pas être modifiée. Cela signifie qu'il faut anticiper la taille nécessaire du tableau ou risquer une allocation excessive de mémoire.
• Coûts d'insertion et de suppression : L'insertion et la suppression d'éléments peuvent être coûteuses en temps, car elles nécessitent un décalage des éléments. Dans le pire des cas, l'insertion ou la suppression d'un élément au milieu du tableau prend O(n) temps.
• Utilisation inefficace de la mémoire : Si le tableau n'est pas entièrement utilisé, les cellules de mémoire restantes restent inoccupées, ce qui peut entraîner une utilisation inefficace de la mémoire.
• Flexibilité limitée : Les tableaux ne permettent pas de modifier dynamiquement leur taille, ce qui les rend moins flexibles par rapport aux structures de données dynamiques comme les listes.

9.3 Exemples d'utilisation et d'application

Voici quelques exemples d'utilisation et d'application des tableaux de taille fixe.

Exemple 1 : Tables et matrices

Les tableaux de taille fixe sont souvent utilisés pour représenter des tables et des matrices, dont la taille est connue à l'avance.

import numpy as np

# Création d'une matrice 3x3 de taille fixe
matrix = np.array([
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
])

# Accès aux éléments de la matrice
print(matrix[1][2])  # Affiche : 6

# Modification d'un élément de la matrice
matrix[1][2] = 10
print(matrix)
# Affiche :
# [[ 1  2  3]
#  [ 4  5 10]
#  [ 7  8  9]]

Exemple 2 : Buffers et caches

Les tableaux de taille fixe sont utilisés pour créer des buffers et des caches, où la taille du buffer est connue à l'avance et ne change pas.

# Buffer de taille fixe pour la lecture de données
buffer_size = 1024
buffer = bytearray(buffer_size)

# Remplissage du buffer avec des données
data = b"Hello, World!"
buffer[:len(data)] = data

print(buffer[:len(data)])  # Affiche : b'Hello, World!'

Exemple 3 : Stockage des données de temps et de dates

Les tableaux de taille fixe peuvent être utilisés pour stocker des données de temps et de dates, comme le nombre de jours dans chaque mois.

Dans cet exemple, nous imitons le comportement d'un tableau fixe à travers une classe list :

# Nombre de jours dans chaque mois (année non bissextile)
days_in_month = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]

# Accès aux données
month = 2  # Février
print(f"En février, il y a {days_in_month[month - 1]} jours")  # Affiche : En février, il y a 28 jours