Avant de commencer ce cours, vous devez posséder des compétences de base en programmation Python. Si vous n'avez pas encore appris Python, vous pouvez commencer par notre Parcours d'apprentissage Python.
Bienvenue dans le laboratoire sur les techniques fondamentales de création de tableaux NumPy. Avant de commencer à coder, comprenons ce qu'est NumPy et pourquoi il est essentiel pour le calcul scientifique.
Qu'est-ce que NumPy ?
NumPy (abréviation de Numerical Python) est la bibliothèque fondamentale pour le calcul scientifique en Python. Elle fournit des structures de données et des fonctions puissantes pour travailler avec de grands tableaux et matrices de données numériques.
Pourquoi NumPy plutôt que les listes Python ?
Bien que les listes intégrées de Python soient flexibles et faciles à utiliser, elles présentent des limitations lorsqu'il s'agit de travailler avec des données numériques :
Performance : Les tableaux NumPy sont beaucoup plus rapides pour les opérations mathématiques.
Efficacité mémoire : NumPy utilise moins de mémoire pour stocker la même quantité de données.
Commodité : NumPy fournit des centaines de fonctions mathématiques intégrées.
Fonctionnalité : NumPy prend en charge des opérations avancées telles que la multiplication matricielle, les transformées de Fourier, etc.
Dans ce laboratoire, vous apprendrez les méthodes les plus courantes pour créer des tableaux NumPy. Vous écrirez et exécuterez des scripts Python pour vous entraîner à convertir des séquences Python, à utiliser des fonctions NumPy intégrées, à manipuler des tableaux existants et à charger des données à partir de fichiers. Tout le codage sera effectué dans le WebIDE.
Ceci est un Guided Lab, qui fournit des instructions étape par étape pour vous aider à apprendre et à pratiquer. Suivez attentivement les instructions pour compléter chaque étape et acquérir une expérience pratique. Les données historiques montrent que c'est un laboratoire de niveau intermédiaire avec un taux de réussite de 69%. Il a reçu un taux d'avis positifs de 100% de la part des apprenants.
Création de tableaux à partir de séquences Python
La manière la plus basique de créer un tableau NumPy est de convertir une séquence Python, telle qu'une liste ou un tuple. La fonction numpy.array() prend une séquence comme argument et retourne un nouveau tableau NumPy.
Comprendre les tableaux NumPy
Avant de créer des tableaux, comprenons ce qui rend les tableaux NumPy spéciaux :
Dimensions des tableaux
Tableau 1D (Vecteur) : Une simple liste de nombres, comme [1, 2, 3, 4]
Tableau 2D (Matrice) : Une table de nombres avec des lignes et des colonnes, comme une feuille de calcul
Tableau 3D (Tenseur) : Un cube de nombres, utile pour les images ou les données 3D
Différences clés par rapport aux listes Python
Homogène : Tous les éléments doivent être du même type de données (généralement des nombres)
Taille fixe : Une fois créé, la taille ne peut pas être modifiée
Efficace : Beaucoup plus rapide pour les opérations mathématiques
Fonctionnalités riches : Prend en charge les opérations vectorisées (opérations sur des tableaux entiers à la fois)
Importer NumPy
En Python, nous importons NumPy en utilisant l'alias standard np :
import numpy as np
Cet alias np est une convention largement adoptée dans la communauté scientifique Python.
Créons maintenant quelques tableaux. Ouvrez le fichier array_from_sequence.py depuis l'explorateur de fichiers à gauche. Ajoutez-y le code suivant. Ce code importera la bibliothèque NumPy et créera des tableaux unidimensionnels (1D), bidimensionnels (2D) et tridimensionnels (3D) à partir de listes Python.
import numpy as np
## Créer un tableau 1D à partir d'une liste
a1D = np.array([1, 2, 3, 4])
print("Tableau 1D :")
print(a1D)
## Créer un tableau 2D à partir d'une liste de listes
a2D = np.array([[1, 2], [3, 4]])
print("\nTableau 2D :")
print(a2D)
## Créer un tableau 3D à partir de listes imbriquées
a3D = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
print("\nTableau 3D :")
print(a3D)
Suggestion : Vous pouvez copier le code ci-dessus dans votre éditeur de code, puis lire attentivement chaque ligne de code pour comprendre sa fonction. Si vous avez besoin d'explications supplémentaires, vous pouvez cliquer sur le bouton "Expliquer le code" 👆. Vous pouvez interagir avec Labby pour obtenir une aide personnalisée.
Après avoir ajouté le code, enregistrez le fichier. Exécutez maintenant le script depuis le terminal pour voir la sortie.
python array_from_sequence.py
Vous devriez voir la sortie suivante, qui affiche les tableaux que vous avez créés :
Les tableaux NumPy ont un type de données fixe pour tous les éléments, spécifié par le paramètre dtype. Ceci est différent des listes Python, où chaque élément peut avoir un type différent.
Pourquoi les types de données sont importants
Efficacité mémoire : Différents types utilisent différentes quantités de mémoire
Performance : Les opérations sont optimisées pour des types de données spécifiques
Précision : Contrôle la manière dont les nombres sont stockés et calculés
Types de données courants
int32 / int64 : Nombres entiers (32 ou 64 bits)
float32 / float64 : Nombres décimaux (32 ou 64 bits)
complex : Nombres complexes
bool : Valeurs Vrai/Faux
Vous pouvez spécifier le type de données lors de la création d'un tableau en utilisant le paramètre dtype, comme np.array([1, 2], dtype=complex). Si vous ne spécifiez pas de dtype, NumPy en choisira un approprié automatiquement en fonction des données d'entrée.
Utilisation des fonctions intrinsèques de création de tableaux
NumPy fournit plusieurs fonctions intégrées pour créer des tableaux à partir de zéro sans avoir besoin d'une séquence Python. Ces fonctions sont optimisées pour des cas d'utilisation spécifiques et sont beaucoup plus rapides que la création manuelle de tableaux à partir de listes.
Pourquoi utiliser ces fonctions ?
Au lieu d'écrire np.array([0, 0, 0, 0, 0]), vous pouvez simplement utiliser np.zeros(5). Ces fonctions sont :
Plus rapides : Code C optimisé en arrière-plan.
Plus lisibles : L'intention est claire d'après le nom de la fonction.
Efficaces en mémoire : Allocation mémoire directe.
Pratiques : Pas besoin de spécifier manuellement chaque élément.
Ouvrez le fichier intrinsic_creation.py et ajoutez le code suivant. Ce script démontre plusieurs fonctions de création courantes.
import numpy as np
## Create an array with a range of elements
## np.arange(start, stop, step) - similar to Python's range()
## Use case: Creating sequences for loops, generating indices
arr_range = np.arange(0, 10, 2) ## [0, 2, 4, 6, 8]
print("Array from arange:")
print(arr_range)
## Create an array with a specific number of elements between two points
## np.linspace(start, stop, num_elements) - evenly spaced points
## Use case: Creating points for plotting, sampling data
arr_linspace = np.linspace(0, 10, 5) ## 5 points from 0 to 10
print("\nArray from linspace:")
print(arr_linspace)
## Create an array filled with zeros
## np.zeros((rows, columns)) - initialize arrays for calculations
## Use case: Pre-allocating arrays before filling with computed values
arr_zeros = np.zeros((2, 3)) ## 2x3 array of zeros
print("\nArray of zeros:")
print(arr_zeros)
## Create an array filled with ones
## np.ones((rows, columns)) - initialize with ones
## Use case: Creating masks, scaling factors, or starting points for algorithms
arr_ones = np.ones((3, 2)) ## 3x2 array of ones
print("\nArray of ones:")
print(arr_ones)
## Create an identity matrix
## np.eye(size) - square matrix with 1s on diagonal, 0s elsewhere
## Use case: Linear algebra, resetting transformations, matrix multiplication
identity_matrix = np.eye(3) ## 3x3 identity matrix
print("\nIdentity matrix:")
print(identity_matrix)
Enregistrez le fichier et exécutez-le depuis le terminal.
python intrinsic_creation.py
La sortie affichera les différents tableaux créés par ces fonctions :
Vous pouvez également créer de nouveaux tableaux en modifiant, combinant ou divisant des tableaux existants. Cette section couvre deux concepts importants : vues vs copies et concaténation de tableaux.
Vues vs Copies : Comprendre le partage de mémoire
C'est l'un des concepts les plus importants en NumPy qui confond souvent les débutants.
Qu'est-ce qu'une vue ?
Une vue est une manière différente de regarder les mêmes données en mémoire. Lorsque vous créez une vue (comme par découpage ou "slicing"), vous ne créez pas un nouveau tableau ; vous créez simplement une nouvelle référence aux données existantes.
Qu'est-ce qu'une copie ?
Une copie crée un tableau entièrement nouveau en mémoire avec ses propres données. Les modifications apportées à une copie n'affectent pas le tableau d'origine, et vice versa.
Pourquoi c'est important
Les vues sont efficaces en mémoire : Elles ne dupliquent pas les données.
Les vues sont rapides : Pas de surcharge de copie.
Mais les vues peuvent causer des effets secondaires inattendus : Modifier une vue change les données d'origine.
Les copies sont plus sûres : Les modifications sont isolées mais utilisent plus de mémoire.
Explorons également comment joindre plusieurs tableaux en un seul tableau plus grand.
Ouvrez le fichier array_manipulation.py et ajoutez le code suivant :
import numpy as np
## --- Part 1: Views vs. Copies ---
a = np.arange(1, 5)
print("Original array 'a':", a)
## Create a view of the first two elements
b = a[:2]
b[0] = 99 ## Modify the view
print("Modified view 'b':", b)
print("Array 'a' after modifying the view:", a) ## 'a' is also changed
## Create a copy
c = a[:2].copy()
c[0] = 0 ## Modify the copy
print("\nModified copy 'c':", c)
print("Array 'a' after modifying the copy:", a) ## 'a' is unchanged
## --- Part 2: Joining Arrays ---
A = np.ones((2, 2))
B = np.eye(2) * 2
C = np.zeros((2, 2))
D = np.diag((-3, -4))
## Join arrays into a block matrix
block_matrix = np.block([
[A, B],
[C, D]
])
print("\nBlock matrix:")
print(block_matrix)
Enregistrez le fichier et exécutez-le depuis le terminal.
python array_manipulation.py
La sortie démontre comment la modification d'une vue affecte le tableau d'origine, tandis que la modification d'une copie ne le fait pas. Elle montre également le résultat de la combinaison de quatre petits tableaux en une seule matrice de blocs.
Une tâche courante en analyse de données consiste à charger des données à partir d'un fichier dans un tableau NumPy. NumPy excelle dans ce domaine car il peut lire efficacement de grands ensembles de données et les convertir automatiquement dans les formats numériques appropriés.
Pourquoi NumPy pour les entrées/sorties de fichiers ?
Vitesse : Beaucoup plus rapide que la lecture ligne par ligne avec Python
Inférence de type : Détecte automatiquement les types de données appropriés
Efficacité mémoire : Charge les données directement dans des tableaux optimisés
Commodité : Un seul appel de fonction au lieu d'un parsing complexe
Formats de fichiers courants
Fichiers CSV : Valeurs séparées par des virgules (le plus courant)
Fichiers TSV : Valeurs séparées par des tabulations
Fichiers texte : Séparés par des espaces ou un délimiteur personnalisé
Fichiers binaires : Pour de très grands ensembles de données (avancé)
Pour les fichiers texte simples comme les CSV (Comma-Separated Values), NumPy fournit la fonction np.loadtxt().
Le script d'installation de ce laboratoire a déjà créé un fichier nommé data.csv dans votre répertoire de projet. Son contenu est :
comments : Optionnel - spécifie le caractère de commentaire pour ignorer les lignes
Nous utilisons delimiter=',' pour spécifier que les colonnes sont séparées par des virgules et skiprows=1 pour ignorer la ligne d'en-tête.
import numpy as np
## Charger les données du fichier CSV
try:
## Les chemins relatifs entraîneront l'échec de la validation, veuillez utiliser des chemins absolus dans le laboratoire
data = np.loadtxt('/home/labex/project/data.csv', delimiter=',', skiprows=1)
print("Données chargées depuis data.csv :")
print(data)
except IOError:
print("Erreur : data.csv non trouvé.")
Enregistrez le fichier et exécutez-le depuis le terminal.
python read_from_file.py
Le script lira les données numériques de data.csv et les affichera sous forme de tableau NumPy.
Cette méthode est très efficace pour charger des données numériques structurées dans des tableaux pour un traitement ultérieur.
Résumé
Dans ce laboratoire, vous avez appris les techniques fondamentales pour créer des tableaux NumPy. Vous avez pratiqué la création de tableaux à partir de listes Python, l'utilisation de fonctions intrinsèques comme np.arange et np.zeros, la manipulation de tableaux existants via des vues, des copies et des jointures, ainsi que le chargement de données à partir d'un fichier texte à l'aide de np.loadtxt.
Ces compétences constituent les bases de presque toutes les tâches de calcul numérique et scientifique que vous effectuerez avec Python. Avec une solide compréhension de la création de tableaux, vous êtes maintenant prêt à explorer des manipulations de tableaux et des opérations mathématiques plus avancées dans NumPy.
