Introduction à Numpy

Présenté par:
Khalid Nassiri

Année Universitaire 2025-2026

 Numpy
Définition
 La bibiliothéque numpy permet d’effectuer des calculs sur des vecteurs ou des
matrices, élément par élément, via un nouveau type d’objet appelé array.
 Installer en utilisant la commande pip install numpy

 Pour charger numpy on utilise la commande import (numpy est souvent chargé
avec un nom raccourci « np »).

2
 Numpy
Créer un objet array
 Les objets de type array correspondent à des tableaux à une ou plusieurs
dimensions et permettent d’effectuer du calcul vectoriel.
 La fonction array() convertit un conteneur (comme une liste ou un tuple ou un de
type range) en un objet de type array.

3
 Numpy
Créer un objet array
 Les objets de type array correspondent à des tableaux à une ou plusieurs
dimensions et permettent d’effectuer du calcul vectoriel.
 La fonction array() convertit un conteneur (comme une liste ou un tuple ou un de
type range) en un objet de type array.

4
 Numpy
Tableaux NumPy à différentes dimensions
 Création d'un tableau 1D
 Un tableau 1D (une seule dimension) est simplement une séquence de valeurs,
comme une liste.
Tableau_1d = [Link](liste ou tuple)

 Création d'un tableau 2D

Un tableau 2D représente des données en lignes et colonnes, comme une matrice.
Tableau_1d = [Link](liste(liste/tuple) ou tuple(liste/tuple))

 Création d'un tableau 3D

Un tableau 3D est une collection de matrices empilées, comme un cube de données.
Tableau_1d = [Link](liste(liste(liste/tuple)/tuple(liste/tuple)) ou
tuple(liste(liste/tuple)/tuple(liste/tuple)))
5
 Numpy
Tableaux NumPy à différentes dimensions

Exemples :

import numpy as np

a = [Link]([1, 2, 3]) # Tableau 1D

b = [Link]([[1, 2, 3], [4, 5, 6]]) # Tableau 2D

c = [Link]([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]) # Tableau 3D

6
 Numpy
Créer un objet array
 Un objet array ne contient que des données homogènes, c’est-à-dire d’un type
identique.
 Il est possible de créer un objet array à partir d’une liste contenant des entiers et
des chaînes de caractères ou d’une liste constituée d’entiers et de floats.

 Créer un objet array à partir d’une liste

contenant des entiers et des chaînes de
caractères, mais toutes les valeurs seront
comprises par NumPy comme des chaînes
de caractères.

7
 Numpy
Créer un objet array
 Un objet array ne contient que des données homogènes, c’est-à-dire d’un type
identique.
 Il est possible de créer un objet array à partir d’une liste contenant des entiers et
des chaînes de caractères ou d’une liste constituée d’entiers et de floats.

 Créer un objet array à partir d’une liste

constituée d’entiers et de floats, mais
toutes les valeurs seront comprises par
NumPy comme des floats.

8
 Numpy
Comparaison entre ndarray et une liste

1 - Performance

 Liste Python :
 Les listes sont génériques et peuvent contenir des éléments de types
différents.
 Les opérations sur les listes Python sont lentes car elles ne sont pas
optimisées pour les calculs numériques.
 ndarray :
 Les tableaux NumPy sont optimisés pour contenir uniquement des données
de types homogènes (par exemple, uniquement des nombres).
 Ils utilisent une implémentation en C sous le capot, ce qui les rend beaucoup
plus rapides pour les calculs.
9
 Numpy
Comparaison entre ndarray et une liste

2 - Gestion de la mémoire

 Liste Python :

• Les listes utilisent une structure de données flexible, mais cela peut
consommer plus de mémoire.

 ndarray :

• Les tableaux NumPy sont compacts et occupent moins de mémoire grâce à

leur représentation fixe et optimisée.

10
 Numpy
Comparaison entre ndarray et une liste

3 - Fonctionnalités mathématiques avancées

 Liste Python :

• Les listes ne disposent pas de fonctions mathématiques intégrées.

• Pour effectuer des calculs complexes, vous devez écrire des boucles ou utiliser
d'autres bibliothèques.

 ndarray :

• NumPy propose une multitude de fonctions prêtes à l'emploi pour effectuer

des calculs mathématiques, statistiques et linéaires.
11
 Numpy
Comparaison entre ndarray et une liste

4 - Dimensions multiples

 Liste Python :

• Les listes peuvent être imbriquées pour créer des structures

multidimensionnelles, mais elles sont moins intuitives à manipuler.

 ndarray :

• Les tableaux NumPy sont naturellement multidimensionnels, avec des

fonctionnalités pour accéder, transformer et traiter facilement ces
dimensions.
12
 Numpy
ndim (Nombre de dimensions)

Renvoie le nombre de dimensions (ou axes) du tableau ndarray

import numpy as np

a = [Link]([1, 2, 3]) # Tableau 1D

print([Link]) # Résultat : 1

b = [Link]([[1, 2, 3], [4, 5, 6]]) # Tableau 2D

print([Link]) # Résultat : 2

c = [Link]([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]) # Tableau 3D

print([Link]) # Résultat : 3
13
 Numpy
shape (Forme du tableau)

Renvoie un tuple contenant la taille du tableau le long de chaque dimension.

a = [Link]([1, 2, 3]) # Tableau 2D

print([Link]) # Résultat : (3,)

b = [Link]([[1, 2, 3], [4, 5, 6]]) # Tableau 2D

print([Link]) # Résultat : (2, 3) -> 2 lignes, 3 colonnes

c = [Link]([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]) # Tableau 3D

print([Link]) # Résultat : (2, 2, 2)

14
 Numpy
size (Nombre total d'éléments)
Renvoie le nombre total d'éléments dans le tableau (produit de toutes les
dimensions).
a = [Link]([1, 2, 3]) # Tableau 2D
print([Link]) # Résultat : 3

b = [Link]([[1, 2, 3], [4, 5, 6]]) # Tableau 2D

print([Link]) # Résultat : 6 (2 lignes × 3 colonnes)

c = [Link]([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]) # Tableau 3D

print([Link]) # Résultat : 8 (2 × 2 × 2)

15
 Numpy
reshape (Modifier la forme du tableau)

 Crée une nouvelle vue (ou copie si nécessaire) du tableau avec une nouvelle
forme, tout en gardant les mêmes données.
• Le produit des dimensions de la nouvelle forme doit être égal au nombre
total d'éléments (size).
• Utile pour réorganiser les données sans les modifier.

a = [Link]([1, 2, 3, 4, 5, 6]) # Tableau 1D

b = [Link](2, 3) # Réorganise en 2 lignes et 3 colonnes
print(b)

c = [Link](3, 2) # Réorganise en 3 lignes et 2 colonnes

print(c)
16
[Link](4, 2) # Erreur, car 4 × 2 ≠ 6
 Numpy
resize (Redimensionner le tableau en place)
 Modifie la forme d’un tableau existant. Contrairement à reshape, il peut modifier
le tableau lui-même (en place) ou renvoyer un tableau redimensionné.
 Différences avec reshape :
• resize peut changer la taille totale du tableau.
• Si la nouvelle forme a plus d'éléments que le tableau d'origine, des zéros
seront ajoutés pour combler.

a = [Link]([1, 2, 3, 4, 5, 6])
[Link](2, 3) # Modifie en place
print(a)

[Link](3, 3) # Ajoute des zéros pour remplir

print(a)
17
 Numpy
[Link]() redimensionner un tableau, mais avec des particularités

 Crée un nouvel array avec le shape demandé.

 Si le nouveau shape demande plus d'éléments, les valeurs existantes sont
répétées pour remplir le tableau.
 Ne modifie pas l'objet d'origine.
 Syntaxe : [Link](array, new_shape)

18
 Numpy
dtype (abréviation de "data type")
 définit le type de données des éléments dans un tableau NumPy.
 optimiser le stockage et les calculs en fonction des types de données utilisés.
 Syntaxe : [Link]
 Définir le dtype lors de la création d'un tableau : [Link](data, dtype=<type>)

# Tableau d'entiers 32 bits

array_int32 = [Link]([1, 2, 3], dtype=np.int32)
print("Type des données :", array_int32.dtype) # Résultat : int32

# Tableau de flottants 64 bits

array_float64 = [Link]([1.5, 2.5, 3.5], dtype=np.float64)
print("Type des données :", array_float64.dtype) # Résultat : float64

# Tableau de booléens
array_bool = [Link]([True, False, True], dtype=np.bool_) 19
print("Type des données :", array_bool.dtype) # Résultat : bool
 Numpy
astype (Conversion des types de données)
 convertir le type de données d'un tableau à l'aide de la méthode astype

array = [Link]([1.5, 2.5, 3.5], dtype=np.float64)

# Conversion en entier 32 bits

array_int32 = [Link](np.int32)
print(array_int32) # Résultat : [1 2 3]
print(array_int32.dtype) # Résultat : int32

# Conversion en booléen
array_bool = [Link](np.bool_)
print(array_bool) # Résultat : [ True True True]
print(array_bool.dtype) # Résultat : bool

20
 Numpy
itemsize (la taille d’un élément du tableau en octets)
 itemsize donne la taille mémoire d'un élément du tableau, exprimée en octets.
 Chaque type de données (int, float, bool, etc.) a une taille fixe définie par le type
de données (dtype).

# Tableau d'entiers 32 bits

array_int32 = [Link]([1, 2, 3], dtype=np.int32)
print("Taille d'un élément (int32) :", array_int32.itemsize) # Résultat : 4 octets

# Tableau d'entiers 64 bits

array_int64 = [Link]([1, 2, 3], dtype=np.int64)
print("Taille d'un élément (int64) :", array_int64.itemsize) # Résultat : 8 octets

# Tableau de flottants 64 bits

array_float64 = [Link]([1.0, 2.0, 3.0], dtype=np.float64)
print("Taille d'un élément (float64) :", array_float64.itemsize) # Résultat : 8 octets

# Tableau de booléens
array_bool = [Link]([True, False, True], dtype=bool)
print("Taille d'un élément (bool) :", array_bool.itemsize) # Résultat : 1 octet 21
 Numpy
nbytes (nbytes)
 renvoie la taille totale en mémoire (en octets) occupée par tous les éléments du
tableau. Sa syntaxe : [Link]
 mesurer l'utilisation mémoire exacte d'un tableau.
 La taille mémoire d'un tableau est calculée en multipliant size × itemsize :
nbytes = size × itemsize
# Tableau d'entiers 8 bits
array_int8 = [Link]([1, 2, 3, 4], dtype=np.int8)
print("Int8 (8 bits) :", array_int8.nbytes) # Résultat : 4

# Tableau d'entiers 64 bits

array_int64 = [Link]([1, 2, 3, 4], dtype=np.int64)
print("Int64 (64 bits) :", array_int64.nbytes) # Résultat : 32

# Tableau de float32
array_float32 = [Link]([1.0, 2.0, 3.0, 4.0], dtype=np.float32)
print("Float32 :", array_float32.nbytes) # Résultat : 16
22
 Numpy
Autres méthodes pour créer et générer des tableaux : Génération de tableaux vides ou remplis
 [Link] : Crée une copie indépendante d’un tableau existant.
original_array = [Link]([1, 2, 3])
copied_array = [Link](original_array)

 [Link] : Crée un tableau sans initialiser les valeurs (contenu aléatoire).

empty_array = [Link]((2, 3)) # Tableau 2x3 avec contenu aléatoire

 [Link] : Crée un tableau rempli de zéros avec une forme et un type spécifiques
zeros_array = [Link]((3, 4), dtype=np.float32)
 [Link] : Crée un tableau rempli de 1 avec une forme et un type spécifiques.
ones_array = [Link]((2, 5), dtype=int)
 [Link] : Crée un tableau rempli avec une valeur spécifiée.
full_array = [Link]((3, 3), 7) # Rempli avec la valeur 7
23
 Numpy
Autres méthodes pour créer et générer des tableaux : Génération de séquences de nombres
 [Link] : Génère une séquence régulière de nombres, similaire à la fonction range de
Python, mais retourne un tableau NumPy.
 Syntaxe : [Link](debut, fin, pas)
arange_array = [Link](0, 10, 2) # De 0 à 10 (exclus), avec un pas de 2

 [Link] : Génère une séquence de nombres uniformément espacés entre deux

bornes.
 Syntaxe : [Link](debut, fin, quantité)

linspace_array = [Link](0, 1, 5) # 5 valeurs entre 0 et 1

 [Link] : Génère une séquence de nombres logarithmiquement espacés.

logspace_array = [Link](1, 3, 4, base=10) # De 10¹ à 10³ avec 4 valeurs 24

 Numpy
Autres méthodes pour créer et générer des tableaux : Génération de tableaux aléatoires
 [Link] : Génère un tableau rempli de nombres aléatoires uniformes entre 0 et 1.

random_uniform = [Link](3, 2) # Tableau 3x2

 [Link] : Génère un tableau rempli de nombres suivant une distribution normale

(moyenne = 0, écart-type = 1).

random_normal = [Link](2, 3) # Tableau 2x3

 [Link] : Génère un tableau rempli d'entiers aléatoires dans une plage donnée.

random_integers = [Link](0, 10, (2, 3)) # Entiers entre 0 et 10

25
 Numpy
Autres méthodes pour créer et générer des tableaux : Génération de tableaux spécifiques
 [Link] : Crée une matrice identité (1 sur la diagonale principale, 0 ailleurs).

identity_matrix = [Link](4) # Matrice identité 4x4

 [Link] : Crée une matrice diagonale à partir d'une liste ou extrait la diagonale d’un tableau.

diagonal_matrix = [Link]([1, 2, 3]) # Matrice diagonale

 [Link] : Crée une matrice triangulaire inférieure.

triangular_matrix = [Link](3) # Matrice 3x3 triangulaire inférieure

26
 Numpy
Méthodes pour la manipulation de données

Méthode Description Exemple

reshape Change la forme du tableau [Link](3, 2)
ravel Aplati le tableau en 1D [Link]()
flatten Crée une copie aplatie (1D) [Link]()
transpose Transpose les axes [Link]()
T Alias de la transposition array.T
resize Modifie la forme du tableau en place [Link](2, 2)
array = [Link]([[1, 2, 3], [4, 5, 6]])
print("Transposé :\n", array.T) # [[1, 4], [2, 5], [3, 6]]
print("Aplati :", [Link]()) # [1 2 3 4 5 6]

27
 Numpy
Méthodes pour la manipulation de données

Méthode Description Exemple

mean Moyenne des éléments [Link]()
sum Somme des éléments [Link]()
std Écart-type [Link]()
var Variance [Link]()
min Valeur minimale [Link]()
max Valeur maximale [Link]()
argmin Index de l’élément minimum [Link]()
argmax Index de l’élément maximum [Link]()
cumsum Somme cumulative [Link]()
cumprod Produit cumulatif [Link]()
array = [Link]([1, 2, 3, 4, 5])
print("Moyenne :", [Link]()) # 3.0
print("Écart-type :", [Link]()) # 1.414
print("Somme cumulative :", [Link]()) # [1 3 6 10 15]
28
 Numpy
Méthodes pour la manipulation de données

Méthode Description Exemple

sort Trie les éléments du tableau [Link]()
argsort Renvoie les indices qui trieraient le tableau [Link]()
unique Renvoie les valeurs uniques [Link](array)

array = [Link]([5, 2, 3, 2, 1])

print("Tableau trié :", [Link](array)) # [1 2 2 3 5]

print("Indices de tri :", [Link]()) # [4 1 3 2 0]

29
 Numpy
Méthodes pour la manipulation de données

Méthode Description Exemple

sort Trie les éléments du tableau [Link]()
argsort Renvoie les indices qui trieraient le tableau [Link]()
unique Renvoie les valeurs uniques [Link](array)

array = [Link]([5, 2, 3, 2, 1])

print("Tableau trié :", [Link](array)) # [1 2 2 3 5]

print("Indices de tri :", [Link]()) # [4 1 3 2 0]

30
 Numpy
Méthodes pour la manipulation de données

Méthode Description Exemple

dot Produit matriciel [Link](array2)
sqrt Racine carrée [Link](array)
log Logarithme naturel [Link](array)
exp Exponentielle [Link](array)

array = [Link]([1, 4, 9])

print("Racine carrée :", [Link](array)) # [1. 2. 3.]

31
 Numpy
Méthodes pour la manipulation de données : Gestion des valeurs manquantes

 [Link] : Vérifie si chaque élément d’un tableau est NaN (Not a Number).
 Retourne un tableau booléen où chaque position indique si l’élément
correspondant est NaN.

data = [Link]([1, [Link], 3, [Link], 5])

# Vérification des NaN

nan_mask = [Link](data)
print(nan_mask)
# Résultat : [False True False True False]

# Filtrage
filtered_data = data[~nan_mask]
print(filtered_data)
# Résultat : [1 3 5]
32
 Numpy
Méthodes pour la manipulation de données : Gestion des valeurs manquantes

 np.nan_to_num : Remplace les valeurs NaN par un nombre spécifique (par défaut 0). Peut
également gérer les infinis positifs (inf) et négatifs (-inf).
 Syantaxe : result = np.nan_to_num(array, copy=True, nan=0.0, posinf=None, neginf=None)

• array : Le tableau NumPy d’entrée contenant des valeurs à traiter.

• copy : (booléen, par défaut True) Si True, renvoie une copie du tableau d'origine. Si False,
modifie le tableau en place.
• nan : (valeur flottante, par défaut 0.0) La valeur par laquelle NaN sera remplacé.
• posinf : (valeur flottante, par défaut None) La valeur par laquelle inf sera remplacé (par
défaut, la valeur maximale d’un nombre flottant, généralement 1.7976931348623157e+308).
• neginf : (valeur flottante, par défaut None) La valeur par laquelle -inf sera remplacé.
array = [Link]([1, [Link], [Link], -[Link], 5])
print(np.nan_to_num(array, nan=0, posinf=999, neginf=-999))
# Résultat : [ 1. 0. 999. -999. 5.] 33
 Numpy
Méthodes pour la manipulation de données : Gestion des valeurs manquantes

 Les fonctions classiques comme [Link] ou [Link] échouent si des valeurs NaN
sont présentes dans le tableau. NumPy propose des variantes qui ignorent les NaN.
 [Link] : Calcule la moyenne en ignorant les NaN.
 [Link] : Calcule la somme en ignorant les NaN.
 [Link] : Calcule l’écart-type en ignorant les NaN.
 [Link] : Calcule la variance en ignorant les NaN.
 [Link] : Trouve la valeur minimale en ignorant les NaN.
 [Link] : Trouve la valeur maximale en ignorant les NaN.

array = [Link]([1, [Link], 3, [Link], 5])

print([Link](array)) # Résultat : 3.0
print([Link](array)) # Résultat : 9.0
print([Link](array)) # Résultat : 1.632993161855452
print([Link](array)) # Résultat : 2.6666666666666665
print([Link](array)) # Résultat : 1.0
print([Link](array)) # Résultat : 5.0 34
 Numpy
Méthodes pour la manipulation de données : Gestion des valeurs manquantes

array = [Link]([1, [Link], 3, [Link], 5])

array[[Link](array)] = 0 # Remplace NaN par 0
print(array) # Résultat : [1. 0. 3. 0. 5.]

array = [Link]([1, [Link], 3, [Link], 5]) array_2d = [Link]([[1, 2], [[Link], 4], [5, [Link]]])
clean_array = array[~[Link](array)] # Supprimer les lignes contenant des NaN
clean_2d = array_2d[~[Link](array_2d).any(axis=1)]
print(clean_array)
print(clean_2d)
# Résultat : [1. 3. 5.]
# Résultat :
# [[1. 2.]]

35
 Numpy
Méthodes pour la manipulation de données : Manipulation des axes dans un tableau
En machine learning, il est souvent nécessaire d'effectuer des calculs ou des transformations
sur un axe spécifique.
Méthode Description Exemple
sum(axis=...) Somme sur un axe spécifique [Link](axis=1)
mean(axis=...) Moyenne sur un axe spécifique [Link](axis=0)
argmax(axis=...) Index de l’élément max sur un axe [Link](axis=1)
cumsum(axis=...) Somme cumulative sur un axe [Link](axis=0)

array = [Link]([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

print("Somme par ligne :", [Link](axis=1)) # Résultat : [ 6 15 24]

print("Somme par colonne :", [Link](axis=0)) # Résultat : [12 15
18]
print("Index max par ligne :", [Link](axis=1)) # Résultat : [2 2 2] 36
 Numpy
Méthodes pour la manipulation de données : Empilement et découpage des tableaux
Ces techniques sont importantes pour combiner ou diviser des ensembles de données.
Méthode Description Exemple
vstack Empilement vertical (ajout de lignes) [Link]([a, b])
hstack Empilement horizontal (ajout de colonnes) [Link]([a, b])
split Découpage en sous-tableaux [Link](array, 3)
vsplit, hsplit Découpage vertical ou horizontal [Link](array, 2)

a = [Link]([[1, 2], [3, 4]]) # Découpage horizontal

b = [Link]([[5, 6], [7, 8]]) array = [Link]([[1, 2, 3, 4], [5, 6, 7, 8]])
print("Découpage horizontal :\n", [Link](array, 2))
# Empilement vertical
print("Empilement vertical :\n", [Link]([a, b]))
37
 Numpy
Indexing : Accéder aux éléments d'un tableau
 Pour récupérer un ou plusieurs élément(s) d’un objet array, on peut utiliser les
indices, de la même manière qu’avec les listes.

38
 Numpy
Indexing : Accéder aux éléments d'un tableau
 Pour récupérer un ou plusieurs élément(s) d’un objet array, on peut utiliser les
indices, de la même manière qu’avec les listes.

import numpy as np

# Création d'un tableau 1D

array_1d = [Link]([10, 20, 30, 40, 50])

# Accès au premier élément (index 0)

print(array_1d[0]) # Résultat : 10

# Accès au dernier élément (index -1)

print(array_1d[-1]) # Résultat : 50

39
 Numpy
Indices

 Dans le cas d’un objet array à deux dimensions, on peut récupérer une ligne complète
(d’indice i), une colonne complète (d’indice j) ou bien un seul élément.
 La syntaxe a[i,:] renvoie la ligne d’indice i,
 La syntaxe a[:,j] renvoie la colonne d’indice j.

40
 Numpy
Indices

 Dans le cas d’un objet array à deux dimensions, la syntaxe a[i, j] renvoie l’élément
à la ligne d’indice i et à la colonne d’indice j.

41
 Numpy
Slicing dans un tableau 2D Slicing : Extraire une sous-partie d'un tableau
array_2d = [Link]([[1, 2, 3, 4],
[5, 6, 7, 8],  Le slicing permet d'extraire une partie d'un tableau en utilisant
[9, 10, 11, 12]])
# Extraire les deux premières lignes la notation [start:end:step].
print(array_2d[:2, :])
# Résultat :
# [[1 2 3 4] Slicing dans un tableau 1D
# [5 6 7 8]] array_1d = [Link]([10, 20, 30, 40, 50, 60, 70])
# Extraire les colonnes 1 et 2 de toutes les
lignes # Extraire les éléments d'indice 1 à 4 (exclus)
print(array_2d[:, 1:3]) print(array_1d[1:4]) # Résultat : [20 30 40]
# Résultat :
# [[ 2 3]
# [ 6 7] # Prendre les 3 premiers éléments
# [10 11]] print(array_1d[:3]) # Résultat : [10 20 30]
# Inverser l’ordre des lignes
print(array_2d[::-1]) # Prendre un élément sur deux
# Résultat : print(array_1d[::2]) # Résultat : [10 30 50 70]
# [[ 9 10 11 12]
# [ 5 6 7 8] # Inverser l'ordre des éléments
# [ 1 2 3 4]]
print(array_1d[::-1]) # Résultat : [70 60 50 40 30 20 10] 42
 Numpy
Subsetting : Sélection conditionnelle

 NumPy permet de sélectionner des valeurs selon une condition logique.

Indexation booléenne Indexation avec une liste d’indices

array = [Link]([10, 15, 20, 25, 30]) array = [Link]([10, 20, 30, 40, 50])

# Sélectionner les éléments supérieurs à 15 # Sélectionner les éléments aux indices

print(array[array > 15]) # Résultat : [20 25 30] 0, 2 et 4
indices = [0, 2, 4]
# Sélectionner les éléments pairs print(array[indices]) # Résultat : [10 30
print(array[array % 2 == 0]) # Résultat : [10 20 30] 50]
43
 Numpy
Masques booléens
 Un masque booléen est un array contenant des valeurs booléennes (True ou
False), utilisé pour sélectionner ou manipuler des éléments spécifiques d’un array
en fonction d'une condition logique.
 Ces masques fonctionnent comme des "filtres" appliqués à un tableau.

44
 Numpy
Masques booléens
 Un masque booléen est appliqué à un tableau pour :
 Récupérer les éléments qui correspondent à une condition donnée.
 Modifier directement les éléments répondant à cette condition.

45
 Numpy
Masques booléens
 Un masque booléen est appliqué à un tableau pour :
 Récupérer les éléments qui correspondent à une condition donnée.
 Modifier directement les éléments répondant à cette condition.

46
 Numpy
Indexation avancée
 NumPy permet aussi une indexation plus complexe pour la manipulation efficace
des données.

Indexation multi-conditions Suppression des valeurs manquantes

array = [Link]([10, 15, 20, 25, 30])
array_with_nan = [Link]([1, [Link], 3, [Link], 5])
clean_array = array_with_nan[~[Link](array_with_nan)]
# Sélectionner les éléments entre 15 et 30
print(clean_array) # Résultat : [1. 3. 5.]
print(array[(array >= 15) & (array <= 30)]) # Résultat : [15 20 25
30]

47
 Numpy
Parcours d’un array (1D)
 NumPy permet d’itérer directement un array.

48
 Numpy
Parcours d’un array (2D)
 NumPy permet d’itérer un array 2D par ligne ou par colonne.

49
 Numpy
nditer() : parcourir efficacement un tableau
 NumPy propose la fonction [Link]() pour itérer efficacement sur un tableau
quel que soit son nombre de dimensions.
 Syntaxe : [Link](op, flags=None, order='C', ... )

Itération avec Options Itération simple

# Création d'un tableau 2D # Création d'un tableau 2D
array_2d = [Link]([[1, 2, 3], [4, 5, 6]]) array_2d = [Link]([[1, 2, 3], [4, 5, 6]])

# Itération en mode Fortran (colonne par colonne) # Utilisation de nditer pour itérer à travers le tableau
for x in [Link](array_2d, order='F'): for x in [Link](array_2d):
print(x) print(x)
op : Un tableau NumPy ou une liste de tableaux à
itérer.  Pourquoi nditer() est mieux que for ?
flags : Options pour l'itérateur (comme  Il fonctionne sur toutes les dimensions sans besoin d'imbriquer plusieurs
['multi_index', 'refs_ok']).
order : Définit l'ordre d'itération, soit 'C' (par
boucles.
défaut, ligne par ligne) ou 'F' (colonne par  Il est plus rapide et utilise une gestion optimisée de la mémoire. 50
colonne).
 Numpy
Modifier un tableau en itérant avec nditer()
 Par défaut, nditer() ne permet pas de modifier directement les valeurs du tableau.
Pour cela, utilisez op_flags=['readwrite'].

# Création d'un tableau 2D

array_2d = [Link]([[1, 2, 3], [4, 5, 6]])

# Utilisation de nditer avec le mode d'écriture

for x in [Link](array_2d, op_flags=['readwrite']):
x[...] += 10 # Ajouter 10 à chaque élément

print(array_2d)
51
 Numpy
[Link]()

 La fonction [Link] () permet de concaténer plusieurs arrays.

52
 Numpy
[Link]()
 Pour les arrays 2D, on peut concaténer des lignes ou des colonnes.
 On peut concaténer le long de l’axe 0 (les lignes) ou le long de l’axe 1 (les
colonnes).

53
 Exercices
Exercice 1 : Création de tableaux
1. Créez un tableau NumPy 1D contenant les nombres de 1 à 10.
2. Créez un tableau 2D de dimensions (3, 3) contenant uniquement des zéros.
3. Créez un tableau 3D contenant uniquement des uns avec une forme (2, 3, 3).

Exercice 2:
Écrivez un programme en Python qui réalise les étapes suivantes (utilisez le module Numpy) :
1. Crée un tableau (array) nommé array1, contenant des entiers aléatoires entre 5 et 20.
2. Trouve et affiche la valeur maximale (max), la valeur moyenne et la valeur minimale (min)
des entiers dans array1.
3. Crée un second tableau (array) nommé array2, contenant le carré des entiers de array1 qui
sont strictement supérieurs à 10.
4. Affiche les deux tableaux ainsi que les résultats trouvés.

54
 Exercice
Exercice 2 : Indexation et slicing
1. Accédez au 4ème élément du tableau [10, 20, 30, 40, 50, 60].
2. Sélectionnez les éléments pairs du tableau [1, 2, 3, 4, 5, 6].
3. Extrayez la sous-matrice suivante du tableau 2D :
[[4 5]
[7 8]]
du tableau :
[[1 2 3 4]
[4 5 6 7]
[7 8 9 10]]
Exercice 3 : Opérations sur les tableaux
1. Multipliez chaque élément du tableau [1, 2, 3, 4] par 5.
2. Trouvez la somme, la moyenne et l'écart-type du tableau [4, 8, 15, 16, 23, 42].
3. Remplacez tous les éléments négatifs du tableau [-5, 3, -1, 7, -2] par 0..
55
 Exercice
Exercice 4 : Manipulation avancée des matrices
1. Créez une matrice identité 4×4.
2. Calculez le produit matriciel de :
A = [[1, 2],
[3, 4]]

B = [[5, 6],
[7, 8]]
3. Obtenez la transposée de cette matrice :
[[1 2 3]
[4 5 6]]
Exercice 5 : Gestion des valeurs NaN
Trouvez et remplacez les valeurs NaN par la moyenne des valeurs restantes dans :
array = [Link]([10, [Link], 30, [Link], 50])
56
 Exercice
Exercice 5 : Gestion des valeurs NaN
Trouvez et remplacez les valeurs NaN par la moyenne des valeurs restantes dans :
array = [Link]([10, [Link], 30, [Link], 50])
Exercice 6 : Génération et tri de données aléatoires
1. Générez un tableau de 20 nombres aléatoires compris entre 1 et 100.
2. Trier ce tableau par ordre croissant.
Exercice 7 : Création de matrices
1. Créez une matrice 2D de 4x4 contenant des entiers de 1 à 16.
2. Créez une matrice 5x5 remplie de 7.
3. Créez une matrice diagonale de taille 5 avec la diagonale contenant les nombres [10, 20, 30,
40, 50].
Exercice 8 : Accès aux éléments d'une matrice
À partir de la matrice :
array_2d = [Link]([[10, 20, 30, 40],
[50, 60, 70, 80],
[90, 100, 110, 120],
57
[130, 140, 150, 160]])
 Exercice
1. Accédez à l'élément 110.
2. Sélectionnez la première colonne.
3. Sélectionnez la dernière ligne.
4. Extraire la sous-matrice suivante :
[[60, 70]
[100, 110]]
Exercice 9 : Calculs sur matrices
1. Multipliez tous les éléments de la matrice suivante par 2
matrix = [Link]([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])

1. Calculez la somme de chaque colonne.

2. Calculez la moyenne de chaque ligne.
3. Trouvez la valeur maximale et minimale de la matrice.
58
 Exercice
Exercice 10 : Tri et permutation
À partir de la matrice suivante :
array_2d = [Link]([[3, 8, 1],
[9, 5, 2],
[6, 4, 7]])
1. Trier chaque ligne de la matrice.
2. Trier chaque colonne de la matrice.
3. Inverser l’ordre des lignes.
4. Faire une rotation de 90° dans le sens des aiguilles d'une montre.
Exercice 11 : Sélection conditionnelle et filtrage
À partir de la matrice suivante :
array_2d = [Link]([[5, 12, 7],
[10, 15, 2],
[8, 6, 14]])
1. Sélectionnez les éléments supérieurs à 10.
2. Remplacez les valeurs impaires par 0.
59
3. Remplacez les valeurs supérieures à 10 par 99.
 Exercice
Exercice 2:

60
 Exercice : pandas
Exercice 1:
Écrivez un script Python qui crée une série à partir d'un dictionnaire contenant les moyennes
de 9 matières étudiées par un étudiant (le dictionnaire peut être déclaré ou saisi par
l'utilisateur). Ensuite, déterminez et affichez :
1. Les notes inférieures à 10.
2. Les notes comprises entre 12 et 14.
3. Les notes supérieures à 16.

61
 Exercice
Exercice 1:

62
63