Guide des tableaux en Python

Introduction

Imaginez que vous ayez une liste de lecture de vos chansons préférées sur votre téléphone. Cette playlist est une liste où chaque chanson est placée dans un ordre spécifique. Vous pouvez jouer la première chanson, passer à la seconde, passer à la cinquième, et ainsi de suite. Cette liste de lecture ressemble beaucoup à un tableau en programmation informatique.

Les tableaux constituent l’une des structures de données les plus fondamentales et les plus utilisées.

Essentiellement, un tableau est une manière structurée de stocker plusieurs éléments (comme des nombres, des caractères ou même d'autres tableaux) dans un ordre spécifique, et vous pouvez rapidement accéder, modifier ou supprimer n'importe quel élément si vous connaissez sa position (index).

Dans ce guide, nous vous donnerons un aperçu complet de la structure des données du tableau. Tout d’abord, nous examinerons ce que sont les tableaux et quelles sont leurs principales caractéristiques. Nous passerons ensuite au monde de Python, en explorant comment les tableaux sont implémentés, manipulés et appliqués dans des scénarios du monde réel.

Comprendre la structure des données du tableau

Les tableaux font partie des structures de données les plus anciennes et les plus fondamentales utilisées en informatique et en programmation. Leur simplicité, combinée à leur efficacité dans certaines opérations, en font un sujet incontournable pour quiconque se lance dans le domaine de la gestion et de la manipulation des données.

Un tableau est une collection d'éléments, généralement du type même type, stocké dans emplacements de mémoire contigus.

Ce stockage contigu permet aux tableaux de fournir un accès en temps constant à n'importe quel élément, compte tenu de son index. Chaque élément d'un tableau est appelé un élément, et la position d'un élément dans le tableau est définie par son indice, qui habituellement commence à zéro.

Par exemple, considérons un tableau d'entiers : [10, 20, 30, 40, 50]. Ici, l'élément 20 a un indice de 1:

Il y a plusieurs avantages d'utiliser des tableaux pour stocker nos données. Par exemple, en raison de leur disposition en mémoire, les tableaux permettent O (1) complexité temporelle (constante) lors de l’accès à un élément par son index. Ceci est particulièrement avantageux lorsque nous avons besoin d’un accès aléatoire aux éléments. De plus, les tableaux sont stockés dans emplacements de mémoire contigus, ce qui peut conduire à une meilleure localisation du cache et à des améliorations globales des performances dans certaines opérations. Un autre avantage notable de l'utilisation de tableaux est que, puisque les tableaux ont une taille fixe une fois déclarés, il est plus facile de gérer la mémoire et d'éviter les débordements inattendus ou les erreurs de mémoire insuffisante.

D'un autre côté, les baies sont livrées avec leur propre ensemble de limites. L'une des principales limites des baies traditionnelles réside dans leur taille fixe. Une fois un tableau créé, sa taille ne peut plus être modifiée. Cela peut entraîner des problèmes tels qu'une perte de mémoire (si le tableau est trop grand) ou la nécessité d'un redimensionnement (si le tableau est trop petit). De plus, l'insertion ou la suppression d'un élément au milieu d'un tableau nécessite le déplacement des éléments, ce qui conduit à O (n) complexité temporelle de ces opérations.

Pour résumer tout cela, illustrons les principales caractéristiques des tableaux à l'aide de l'exemple de playlist de chansons du début de ce guide. Un tableau est une structure de données qui :

• Est indexé : Tout comme chaque chanson de votre playlist possède un numéro (1, 2, 3,…), chaque élément d'un tableau possède un index. Mais, dans la plupart des langages de programmation, l’index commence à 0. Ainsi, le premier élément est à l’index 0, le second à l’index 1, et ainsi de suite.

• A une taille fixe: Lorsque vous créez une liste de lecture pour, disons, 10 chansons, vous ne pouvez pas ajouter une 11ème chanson sans en supprimer une au préalable. De même, les tableaux ont une taille fixe. Une fois que vous avez créé un tableau d'une certaine taille, vous ne pouvez pas ajouter plus d'éléments que sa capacité.

• Est homogène: Toutes les chansons de votre liste de lecture sont des morceaux de musique. De même, tous les éléments d’un tableau sont du même type. Si vous disposez d’un tableau d’entiers, vous ne pouvez pas y stocker soudainement une chaîne de texte.

• A un accès direct: Si vous souhaitez écouter la 7ème chanson de votre playlist, vous pouvez y accéder directement. De même, avec les tableaux, vous pouvez accéder instantanément à n’importe quel élément si vous connaissez son index.

• Mémoire contiguë: C'est un peu plus technique. Lorsqu'un tableau est créé dans la mémoire d'un ordinateur, il occupe un bloc de mémoire continu. Pensez-y comme à une rangée de casiers adjacents à l’école. Chaque casier est côte à côte, sans espace entre les deux.

Python et tableaux

Python, connu pour sa flexibilité et sa facilité d'utilisation, offre plusieurs façons de travailler avec des tableaux. Bien que Python ne dispose pas d'une structure de données de tableau native comme certains autres langages, il propose des alternatives puissantes qui peuvent fonctionner de manière similaire et même offrir des fonctionnalités étendues.

À première vue, La liste de Python Cela peut sembler synonyme de tableau, mais il existe des différences et des nuances subtiles à prendre en compte :

Liste	tableau
Une structure de données Python intégrée	Non natif en Python – ils proviennent du module `array`
Taille dynamique	Taille fixe (prédéfinie)
Peut contenir des éléments de différents types de données	Contenir des objets du même type
Fournir une gamme de méthodes intégrées de manipulation	Besoin d'importer des modules externes
O (1) complexité temporelle pour les opérations d'accès	O (1) complexité temporelle pour les opérations d'accès
Consommer plus de mémoire	Plus efficace en mémoire

En regardant ce tableau, il vient naturellement de se demander : "Quand utiliser lequel?". Eh bien, si vous avez besoin d'une collection qui peut s'agrandir ou se réduire de manière dynamique et contenir des types de données mixtes, la liste de Python est la voie à suivre. Cependant, pour les scénarios nécessitant une collection plus efficace en mémoire avec des éléments du même type, vous pouvez envisager d'utiliser Python. array module ou des bibliothèques externes comme NumPy.

Le tableau Module en Python

Lorsque la plupart des développeurs pensent aux tableaux en Python, ils pensent souvent par défaut aux listes. Cependant, Python propose une structure de tableau plus spécialisée grâce à son module intégré array module. Ce module fournit un stockage peu encombrant des types de données de base de style C en Python.

Bien que les listes Python soient incroyablement polyvalentes et puissent stocker n'importe quel type d'objet, elles peuvent parfois être excessives, en particulier lorsque vous n'avez besoin de stocker qu'une collection de types de données de base, comme des entiers ou des flottants. Le array Le module fournit un moyen de créer des tableaux plus efficaces en mémoire que des listes pour des types de données spécifiques.

Création d'un tableau

Pour utiliser la array module, vous devez d'abord l'importer :

from array import array

Une fois importé, vous pouvez créer un tableau à l'aide du array() constructeur:

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

Ici le 'i' L'argument indique que le tableau stockera les signatures entiers. Il existe plusieurs autres codes de type disponibles, tels que 'f' pour flotteurs et 'd' pour les doubles.

Accéder et modifier des éléments

Vous pouvez accéder et modifier les éléments d'un tableau comme vous le feriez avec une liste :

print(arr[2]) 

Et maintenant, modifions l'élément en changeant sa valeur en 6:

arr[2] = 6
print(arr) 

Méthodes de tableau

Le array Le module fournit plusieurs méthodes pour manipuler les tableaux :

• append() – Ajoute un élément à la fin du tableau :

  arr.append(7)
  print(arr) 

• extend() – Ajoute des éléments itérables à la fin :

  arr.extend([8, 9])
  print(arr) 

• pop() – Supprime et renvoie l'élément à la position donnée :

  arr.pop(2)
  print(arr) 

• remove(): Supprime la première occurrence de la valeur spécifiée :

  arr.remove(2)
  print(arr) 

• reverse(): Inverse l'ordre du tableau :

  arr.reverse()
  print(arr) 

Tandis que le array module offre un moyen plus efficace en mémoire pour stocker les types de données de base, il est essentiel de se souvenir de son limites. Contrairement aux listes, les tableaux sont homogène. Cela signifie que tous les éléments du tableau doivent être du même type. De plus, vous ne pouvez stocker que types de données de base de style C dans des tableaux. Si vous devez stocker des objets personnalisés ou d'autres types Python, vous devrez utiliser une liste ou une autre structure de données.

Tableaux NumPy

NumPy, abréviation de Numerical Python, est un package fondamental pour les calculs numériques en Python. L'une de ses principales caractéristiques est sa puissance Objet tableau à N dimensions, qui propose des opérations rapides sur les tableaux, notamment mathématiques, logiques, manipulation de forme, etc.

Les tableaux NumPy sont plus polyvalents que les tableaux intégrés de Python array module et sont un incontournable des projets de science des données et d’apprentissage automatique.

Pourquoi utiliser les tableaux NumPy ?

La première chose qui me vient à l'esprit est performant. Les tableaux NumPy sont implémentés en C et permettent un stockage de mémoire efficace et des opérations plus rapides grâce à des algorithmes optimisés et aux avantages du stockage en mémoire contiguë.

Alors que les listes et tableaux intégrés de Python sont unidimensionnels, les tableaux NumPy peuvent être multidimensionnel, ce qui les rend idéaux pour représenter des matrices ou des tenseurs.

Enfin, NumPy fournit un vaste gamme de fonctions pour opérer sur ces tableaux, de l'arithmétique de base aux opérations mathématiques avancées, en passant par le remodelage, le fractionnement, etc.

Création d'un tableau NumPy

Pour utiliser NumPy, vous devez d'abord l'installer (pip install numpy) puis importez-le :

import numpy as np

Une fois importé, vous pouvez créer un tableau NumPy à l'aide du array() fonction:

arr = np.array([1, 2, 3, 4, 5])
print(arr) 

Vous pouvez également créer des tableaux multidimensionnels :

matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(matrix)

Cela nous donnera :

[[1 2 3] [4 5 6] [7 8 9]]

Outre ces méthodes de base permettant de créer des tableaux, NumPy nous propose d'autres méthodes intelligentes permettant de créer des tableaux. Dont l'un est le arange() méthode. Il crée des tableaux avec des valeurs incrémentées régulièrement :

arr = np.arange(10)
print(arr) 

Un autre est le linspace() méthode, qui crée des tableaux avec un nombre spécifié d'éléments, espacés de manière égale entre les valeurs de début et de fin spécifiées :

even_space = np.linspace(0, 1, 5)
print(even_space) 

Accéder et modifier des éléments

L'accès et la modification des éléments d'un tableau NumPy sont intuitifs :

print(arr[2]) arr[2] = 6
print(arr) 

Faire à peu près la même chose pour les tableaux multidimensionnels :

print(matrix[1, 2]) matrix[1, 2] = 10
print(matrix)

Changera la valeur de l'élément dans la deuxième ligne (index 1) et la troisième colonne (index 2):

[[1 2 3] [4 5 20] [7 8 9]]

Changer la forme d'un tableau

NumPy propose de nombreuses fonctions et méthodes pour manipuler et opérer sur des tableaux. Par exemple, vous pouvez utiliser le reshape() méthode pour changer la forme d'un tableau. Disons que nous avons un tableau simple :

import numpy as np arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
print("Original Array:")
print(arr) 

Et nous voulons le remodeler en une matrice 3×4. Tout ce que vous avez à faire est d'utiliser le reshape() méthode avec les dimensions souhaitées passées en arguments :

reshaped_arr = arr.reshape(3, 4)
print("Reshaped Array (3x4):")
print(reshaped_arr)

Cela se traduira par:

Reshaped Array (3x4):
[[ 1 2 3 4] [ 5 6 7 8] [ 9 10 11 12]]

Multiplication matricielle

Le numpy.dot() méthode est utilisée pour multiplication matricielle. Il renvoie le produit scalaire de deux tableaux. Pour les tableaux unidimensionnels, c'est le produit intérieur des tableaux. Pour les tableaux à 2 dimensions, cela équivaut à multiplication matricielle, et pour ND, c'est un produit somme sur le dernier axe du premier tableau et l’avant-dernier du deuxième tableau.

Voyons voir comment ça fonctionne. Tout d’abord, calculons le produit scalaire de deux tableaux 1D (le produit scalaire des vecteurs) :

import numpy as np vec1 = np.array([1, 2, 3])
vec2 = np.array([4, 5, 6])
dot_product_1d = np.dot(vec1, vec2) print("Dot product of two 1-D arrays:")
print(dot_product_1d) 

Cela se traduira par:

Dot product of two 1-D arrays:
32

32 est, en fait, le produit interne des deux tableaux – (14 + 25 + 3*6). Ensuite, nous pouvons effectuer une multiplication matricielle de deux tableaux 2D :

mat1 = np.array([[1, 2], [3, 4]])
mat2 = np.array([[2, 0], [1, 3]])
matrix_product = np.dot(mat1, mat2) print("Matrix multiplication of two 2-D arrays:")
print(matrix_product) 

Ce qui nous donnera :

Matrix multiplication of two 2-D arrays:
[[ 4 6] [10 12]]

Les tableaux NumPy constituent une avancée significative par rapport aux listes intégrées de Python et aux array module, notamment pour les calculs scientifiques et mathématiques. Leur efficacité, combinée à la richesse des fonctionnalités fournies par la bibliothèque NumPy, en fait un outil indispensable pour quiconque cherche à effectuer des opérations numériques en Python.

Conclusion

Les baies, pierre angulaire de l'informatique et de la programmation, ont prouvé à maintes reprises leur valeur dans diverses applications et domaines. En Python, cette structure de données fondamentale, à travers ses différentes incarnations comme les listes, le array Le module et les puissantes baies NumPy offrent aux développeurs un mélange d'efficacité, de polyvalence et de simplicité.

Tout au long de ce guide, nous sommes passés des concepts fondamentaux des tableaux à leurs applications pratiques en Python. Nous avons vu comment les tableaux, avec leur nature contiguë à la mémoire, offrent des temps d'accès rapides, et comment les listes dynamiques de Python apportent une couche supplémentaire de flexibilité. Nous avons également plongé dans le monde spécialisé de NumPy, où les tableaux se transforment en outils puissants de calcul numérique.

• Contenu propulsé par le référencement et distribution de relations publiques. Soyez amplifié aujourd'hui.
• PlatoData.Network Ai générative verticale. Autonomisez-vous. Accéder ici.
• PlatoAiStream. Intelligence Web3. Connaissance Amplifiée. Accéder ici.
• PlatonESG. Carbone, Technologie propre, Énergie, Environnement, Solaire, La gestion des déchets. Accéder ici.
• PlatoHealth. Veille biotechnologique et essais cliniques. Accéder ici.
• La source: https://stackabuse.com/guide-to-arrays-in-python/