Creating NumPy Arrays

1. Pourquoi NumPy ? L'Avantage de la Vitesse et de la Puissance

Avant de plonger dans le code, il est crucial de comprendre pourquoi NumPy est si indispensable. Les listes Python sont flexibles, mais cette flexibilité a un coût : elles sont relativement lentes pour les opérations mathématiques sur de nombreux éléments.

NumPy (qui signifie "Numerical Python") résout ce problème avec son objet principal : le tableau n-dimensionnel (ndarray). Ces tableaux présentent deux avantages majeurs :

1. Homogénéité : Tous les éléments d'un tableau NumPy doivent être du même type (par exemple, que des entiers ou que des flottants). Cela permet à NumPy de stocker les données de manière beaucoup plus compacte et efficace en mémoire.
2. Opérations vectorisées : Les opérations mathématiques s'appliquent simultanément à tous les éléments du tableau, sans que vous ayez besoin d'écrire une boucle for. Ce code est exécuté en arrière-plan par des routines très optimisées (écrites en C), ce qui le rend des dizaines, voire des centaines de fois plus rapide.

La vidéo suivante, bien qu'en anglais, offre une excellente démonstration de cet avantage de performance et une introduction générale à NumPy.

Pour commencer à utiliser NumPy, la convention quasi universelle est de l'importer avec l'alias np. Toutes les fonctions de la bibliothèque seront alors accessibles via le préfixe np..

import numpy as np

2. Créer des Tableaux NumPy

Maintenant que nous savons pourquoi NumPy est si puissant, voyons comment créer ces fameux tableaux.

2.1. À partir d'une liste Python

La manière la plus simple de créer un tableau NumPy est de le faire à partir d'une liste Python existante en utilisant la fonction np.array().

Comme vous l'avez lu, la syntaxe est très directe :

import numpy as np




# Créer un tableau 1D à partir d'une liste d'entiers
ma_liste = [10, 20, 30, 40]
mon_tableau = np.array(ma_liste)

print(mon_tableau)



# Affiche : [10 20 30 40]

print(type(mon_tableau))



# Affiche : <class 'numpy.ndarray'>

Notez l'absence de virgules dans l'affichage, une signature visuelle des tableaux NumPy.

Une caractéristique importante des tableaux NumPy est leur type de données (ou dtype). NumPy détecte automatiquement le type le plus approprié. Si vous mélangez des entiers et des flottants, NumPy convertira tous les éléments en flottants pour préserver l'information.

liste_mixte = [1, 2.5, 3]
tableau_mixte = np.array(liste_mixte)

print(tableau_mixte)



# Affiche : [1.  2.5 3. ]
print(tableau_mixte.dtype)



# Affiche : float64

2.2. Avec les fonctions de création

Écrire des listes à la main est fastidieux pour de grands tableaux. NumPy fournit des fonctions très pratiques pour générer des tableaux de manière programmatique.

np.zeros() et np.ones()

Ces fonctions créent des tableaux remplis de zéros ou de uns. C'est extrêmement utile pour initialiser des tableaux dont vous remplirez les valeurs plus tard. L'argument est la "forme" (shape) du tableau. Pour un tableau 1D, c'est simplement le nombre d'éléments.

# Un tableau de 5 zéros (flottants par défaut)
zeros = np.zeros(5)
print(f"Tableau de zéros : {zeros}")




# Un tableau de 3 uns
ones = np.ones(3)
print(f"Tableau de uns : {ones}")




# Vous pouvez aussi spécifier le type de données
ones_int = np.ones(4, dtype=int)
print(f"Tableau de uns entiers : {ones_int}")

np.arange()

Cette fonction est l'équivalent NumPy de la fonction range() de Python, mais en plus puissant. Elle génère des valeurs dans un intervalle avec un pas défini. Contrairement à range(), elle peut utiliser des pas non entiers (flottants).

La syntaxe est np.arange(start, stop, step).

• start : La valeur de départ (incluse).
• stop : La valeur de fin (exclue).
• step : L'écart entre les valeurs (par défaut 1).

L'image suivante illustre parfaitement son fonctionnement :

Exemple concret :

# Nombres de 0 à 9 (10 est exclu)
arr1 = np.arange(10)
print(f"De 0 à 9 : {arr1}")




# Nombres de 5 à 10 (11 est exclu) avec un pas de 1
arr2 = np.arange(5, 11)
print(f"De 5 à 10 : {arr2}")




# Nombres de 0 à 1 (1.2 est exclu) avec un pas de 0.2
arr3 = np.arange(0, 1.2, 0.2)
print(f"Avec un pas flottant : {arr3}")

np.linspace()

Cette fonction est également utilisée pour créer des séquences de nombres, mais son approche est différente. Au lieu de spécifier un pas, vous spécifiez le nombre total d'éléments que vous souhaitez dans l'intervalle.

La syntaxe est np.linspace(start, stop, num).

• start : La valeur de départ (incluse).
• stop : La valeur de fin (incluse par défaut).
• num : Le nombre total de points à générer.

C'est une fonction particulièrement utile en science des données et en mathématiques pour générer des points afin de tracer une fonction.

# 5 points uniformément espacés entre 0 et 10 (inclus)
arr_lin1 = np.linspace(0, 10, 5)
print(f"5 points entre 0 et 10 : {arr_lin1}")




# 11 points entre 0 et 1 (inclus)
arr_lin2 = np.linspace(0, 1, 11)
print(f"11 points entre 0 et 1 : {arr_lin2}")

Résumé Visuel

L'aide-mémoire suivant (en français) est une excellente ressource à conserver. Il résume plusieurs des fonctions que nous venons de voir. Repérez les sections "CRÉATION D'UN TABLEAU À 1D" et "CRÉATION DE TABLEAUX PRÉDÉFINIS".

Si vous souhaitez un autre résumé en vidéo, et en arabe cette fois (comme mentionné dans vos préférences), la chaîne Elzero Web School que vous appréciez a une excellente vidéo sur le sujet.

3. Exercices Pratiques

Il est temps de mettre en pratique ces nouvelles connaissances.

Exercice 1 : Création Manuelle et Programmatique

1. Créez un tableau NumPy nommé tableau_a à partir de la liste Python [0.0, 0.5, 1.0, 1.5, 2.0].
2. Créez un second tableau NumPy nommé tableau_b qui contient exactement les mêmes valeurs, mais cette fois en utilisant la fonction np.arange().
3. Créez un troisième tableau NumPy nommé tableau_c qui contient aussi les mêmes valeurs, mais en utilisant la fonction np.linspace().
4. Affichez les trois tableaux pour vérifier qu'ils sont identiques.

Exercice 2 : Initialiser un Signal

Imaginez que vous préparez une simulation physique. Vous avez besoin de représenter un signal sur une durée de 5 secondes, avec une mesure toutes les 100 millisecondes (0.1 seconde).

1. Créez un tableau NumPy nommé temps qui représente les points temporels de 0s à 5s (inclus) avec un pas de 0.1s. Utilisez la fonction la plus appropriée pour cela.
2. Créez un tableau NumPy nommé mesures de la même taille que le tableau temps, mais rempli de zéros. Ce tableau servira à stocker les résultats de la simulation plus tard.
3. Affichez la taille du tableau temps (en utilisant temps.size) et le tableau mesures.

Solutions

Solution de l'exercice 1 :

import numpy as np




# 1. Création à partir d'une liste
tableau_a = np.array([0.0, 0.5, 1.0, 1.5, 2.0])




# 2. Création avec arange
# La valeur de fin doit être légèrement supérieure à 2.0 pour l'inclure, par ex. 2.1
tableau_b = np.arange(0.0, 2.1, 0.5)




# 3. Création avec linspace
# Il y a 5 points dans la séquence
tableau_c = np.linspace(0.0, 2.0, 5)




# 4. Vérification
print(f"Tableau A (depuis liste): {tableau_a}")
print(f"Tableau B (avec arange): {tableau_b}")
print(f"Tableau C (avec linspace): {tableau_c}")

Solution de l'exercice 2 :

import numpy as np




# 1. Création du tableau de temps avec arange
# Pour inclure 5.0, on met la fin à 5.1
temps = np.arange(0, 5.1, 0.1)




# Note : On aurait aussi pu utiliser linspace
# nombre de points = (5.0 - 0.0) / 0.1 + 1 = 51
# temps_alt = np.linspace(0, 5, 51)




# 2. Création du tableau de mesures
mesures = np.zeros(temps.size)




# 3. Affichage
print(f"Nombre de points temporels : {temps.size}")
print(f"Tableau de mesures initial : {mesures}")



# Affiche une partie du tableau pour ne pas surcharger la console
print(f"Début du tableau temps : {temps[:5]}...")

Conclusion

Félicitations ! Vous avez franchi la première étape, et la plus importante, dans le monde de NumPy. Vous comprenez maintenant non seulement pourquoi NumPy est essentiel, mais aussi comment créer ses objets fondamentaux, les tableaux.

Points clés à retenir :

• NumPy est la bibliothèque de base pour le calcul numérique en Python, offrant des performances bien supérieures aux listes standard.
• On importe NumPy avec la convention import numpy as np.
• Les tableaux NumPy (ndarray) sont homogènes (un seul type de données).
• On peut créer un tableau à partir d'une liste avec np.array().
• np.zeros() et np.ones() sont parfaits pour créer des tableaux d'initialisation.
• np.arange(début, fin, pas) est idéal pour des séquences avec un pas fixe (la fin est exclue).
• np.linspace(début, fin, nombre) est parfait pour des séquences avec un nombre de points défini (la fin est incluse).

Maintenant que nous savons comment créer des tableaux, la prochaine étape logique est d'apprendre à interagir avec eux. Dans la prochaine leçon, nous explorerons comment accéder aux éléments d'un tableau et les modifier en utilisant l'indexation et le découpage (slicing). C'est là que vous commencerez vraiment à sentir la puissance et la flexibilité de NumPy pour la manipulation de données.