Section 1 : Introduction à NumPy et ses

avantages

Objectif de cette section

À la fin de cette section, tu seras capable de :

1. Comprendre ce qu’est NumPy et à quoi il sert.

2. Installer et importer NumPy dans ton environnement VS Code.
3. Comprendre la différence entre listes Python et tableaux NumPy.
4. Saisir les avantages clés de NumPy pour les calculs et l’analyse de données.

1 Qu’est-ce que NumPy ?

● NumPy = Numerical Python

● C’est la librairie de base pour le calcul numérique en Python.

● Elle permet de créer des tableaux multidimensionnels (vecteurs, matrices, tensors).

● NumPy est ultra-rapide grâce à une implémentation en C derrière Python.

Différence entre liste Python et tableau NumPy

Caractéristique Liste Python Tableau NumPy

Taille Variable Fixe pour chaque dimension

Opérations Doivent être manuelles ou Vectorisées et rapides

mathématiques boucles

Performance Moyenne pour gros datasets Très rapide, adapté aux millions de lignes

Fonctions intégrées Peu Statistiques, algebra linéaire, trigonométrie,

etc.
 Exemple concret : vitesse
# Python pur
liste = list(range(1, 1000001)) somme
= 0
for x in liste:
somme += x

# NumPy
import numpy as np
tableau = [Link](1, 1000001)
somme_np = [Link](tableau)

💡 Même si le résultat est le même, NumPy est des dizaines de fois plus rapide.

2
Installation et importation
Si ce n’est pas déjà fait :

pip install numpy

Puis dans VS Code :

import numpy as np # np = alias standard

📌 L’alias np est utilisé partout en entreprise et dans les tutoriels officiels.

3 Pourquoi NumPy pour un Data Analyst ?

1. Calculs rapides sur de grands ensembles de données

2. Manipulation facile des vecteurs et matrices

3. Base pour Pandas et toutes les librairies de Machine Learning

4. Fonctions mathématiques et statistiques intégrées

5. Traitement vectorisé → pas besoin de boucles lentes

6. Gestion des tableaux multidimensionnels (1D, 2D, 3D)

Exemple concret : vectorisation
import numpy as np

a = [Link]([1, 2, 3, 4])
b = [Link]([10, 20, 30, 40])

# Addition élément par élément (vectorisée)

c = a + b
print(c) # [11 22 33 44]

💡 En Python pur, tu aurais dû faire une boucle, mais NumPy le fait en une seule ligne et
beaucoup plus vite.

4 Cas d’usage Data Analyst

● Calculer rapidement des indicateurs clés (moyenne, mediane, somme, variance).

● Filtrer ou transformer des données massives sans boucles.

● Préparer les données pour Pandas ou la visualisation.

● Simulations ou tests statistiques rapides sur des milliers de lignes.

5 Bonnes pratiques
● Toujours utiliser l’alias np : import numpy as np

● Préférer les tableaux NumPy aux listes Python pour les calculs massifs

● Utiliser les fonctions vectorisées et éviter les boucles quand c’est possible

● Séparer création, nettoyage, calcul pour garder le code lisible

Mini-exercice pratique

1. Crée un tableau NumPy de 10 entiers : [5, 10, 15, …, 50]

2. Calcule la somme, la moyenne et la variance du tableau avec NumPy

3. Compare les résultats avec les méthodes Python natives (sum(), [Link])

💡 A retenir :

● NumPy = base du calcul numérique pour Data Analysts

● Plus rapide, plus pratique et vectorisé

● Fondamental pour Pandas et toutes les analyses avancées

● Premier contact concret avec les tableaux NumPy

Section 2 : Création et manipulation de

tableaux 1D et 2D avec NumPy
À la fin de cette section, tu seras capable de :

1. Créer des tableaux 1D et 2D en NumPy.

2. Comprendre les dimensions et formes (shape) des tableaux.
3. Manipuler les données de manière rapide et vectorisée.
4. Extraire, modifier et ajouter des données dans tes tableaux.
5. Préparer tes bases pour les calculs statistiques et la visualisation.
1 Création de tableaux 1D
import numpy as np

# À partir d’une liste Python

tableau1d = [Link]([10, 20, 30, 40, 50])
print("Tableau 1D :", tableau1d)

# Vérifier les caractéristiques

print("Type :", type(tableau1d))
print("Dimensions :", [Link]) # 1D
print("Forme :", [Link]) # (5,)
print("Taille :", [Link]) # 5 éléments

💡 Astuce Data Analyst : Toujours vérifier shape et ndim pour comprendre vos données.

2 Création de tableaux 2D
# À partir d’une liste de listes
tableau2d = [Link]([[10, 20, 30],
[40, 50, 60],
[70, 80, 90]])
print("Tableau 2D :\n", tableau2d)

print("Dimensions :", [Link]) # 2D

print("Forme :", [Link]) # (3,3)
print("Taille :", [Link]) # 9 éléments

💡 En Data Analysis, les datasets tabulaires se représentent souvent comme des tableaux 2D
:

● lignes = observations

● colonnes = variables
3 Création de tableaux spéciaux

● Zeros et Ones

zeros = [Link]((3,4))
ones = [Link]((2,5))

● Tableaux avec un intervalle spécifique

seq = [Link](10, 101, 10) # 10 à 100 par pas de 10

● Tableaux avec valeurs aléatoires

rand = [Link](3,3) # valeurs entre 0 et 1

💡 Utile pour simulations ou tests de pipelines.

4 Accéder aux éléments (Indexation)

1D
tableau1d = [Link]([10, 20, 30, 40, 50])
print(tableau1d[0]) # Premier élément → 10

print(tableau1d[-1]) # Dernier élément → 50

2D
tableau2d = [Link]([[1,2,3],[4,5,6],[7,8,9]])
print(tableau2d[0,1]) # 1ère ligne, 2ème colonne → 2
print(tableau2d[2,0]) # 3ème ligne, 1ère colonne → 7

💡 En Data Analyst : la ligne = observation, colonne = variable.

5 Modifier des valeurs

tableau1d[2] = 35 # Modifier 3ème élément
tableau2d[0,1] = 22 # Modifier 1ère ligne, 2ème colonne
6 Slicing (extraire des sous-tableaux)

1D
print(tableau1d[1:4]) # index 1 à 3 → [20 35 40]
print(tableau1d[:3]) # début à 2ème index → [10 20 35]
print(tableau1d[::2]) # tous les 2 éléments → [10 35 40]

2D
print(tableau2d[0:2, 1:3]) # lignes 0-1, colonnes 1-2

💡 Le slicing est essentiel pour filtrer et manipuler des datasets massifs.

7 Ajouter / supprimer des éléments

● Ajouter des colonnes ou lignes

ligne = [Link]([[100, 200, 300]])

tableau2d = [Link]((tableau2d, ligne)) # ajouter ligne
colonne = [Link]([[10],[20],[30],[40]])
tableau2d = [Link]((tableau2d, colonne)) # ajouter colonne

● Supprimer des éléments

tableau2d = [Link](tableau2d, 0, axis=0) # supprimer 1ère ligne

💡 Utile pour nettoyer ou restructurer tes données avant analyse.

8 Conversion types Python ↔ NumPy

# Liste → tableau
lst = [1,2,3]
arr = [Link](lst)

# Tableau → liste
lst2 = [Link]()

💡 Important pour passer entre NumPy et d’autres librairies comme Pandas.

9 Bonnes pratiques Data Analyst

1. Toujours vérifier shape et ndim avant toute opération

2. Préférer tableaux 2D pour datasets tabulaires

3. Utiliser slicing et indexation plutôt que boucles lentes

4. Préparer les tableaux pour calculs vectorisés dès le départ

5. Séparer création / modification / extraction pour garder un pipeline clair

10 Mini-exercice pratique
 1. Crée un tableau 1D : [5, 10, 15, 20, 25, 30]

2. Crée un tableau 2D : 3x3 avec valeurs de 1 à 9

3. Modifie la 2ème colonne du tableau 2D en [10, 20, 30]

4. Extrais les lignes 1 à 2 et colonnes 0 à 1

5. Ajoute une nouvelle ligne [100, 200, 300] au tableau 2D

💡 A retenir :

● Tu sais maintenant créer et manipuler des tableaux 1D et 2D.

● Tu peux extraire, modifier, ajouter et supprimer des données rapidement.

● Tu es prêt à faire des calculs vectorisés et à passer aux statistiques et

opérations mathématiques (Section 3).

Section 3 : Opérations mathématiques et

statistiques avec NumPy
À la fin de cette section, tu seras capable de :

1. Effectuer des opérations mathématiques sur tout un tableau sans boucle.

2. Calculer des indicateurs statistiques de base et avancés.
3. Comprendre les fonctions vectorisées pour accélérer l’analyse.
4. Appliquer ces opérations dans un contexte Data Analyst pour obtenir des insights.

1 Opérations élémentaires sur tableaux

NumPy permet d’appliquer des opérations directement élément par élément.

import numpy as np

a = [Link]([10, 20, 30, 40])

b = [Link]([1, 2, 3, 4])

# Addition
print("Addition :", a + b) # [11 22 33 44]

# Soustraction
print("Soustraction :", a - b) # [9 18 27 36]

# Multiplication
print("Multiplication :", a * b) # [10 40 90 160]

# Division
print("Division :", a / b) # [10. 10. 10. 10.]

💡 Astuce Data Analyst : fini les boucles pour additionner ou multiplier des colonnes !

2 Fonctions statistiques de base

NumPy fournit des fonctions vectorisées et rapides :

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

print("Somme :", [Link](arr)) # 150

print("Moyenne :", [Link](arr)) # 30.0
print("Médiane :", [Link](arr)) # 30.0
print("Minimum :", [Link](arr)) # 10
print("Maximum :", [Link](arr)) # 50
print("Écart-type :", [Link](arr)) # 14.142
print("Variance :", [Link](arr)) # 200.0

3 Fonctions cumulatives

● Somme cumulative

print("Somme cumulative :", [Link](arr)) # [10 30 60 100 150]

 ● Produit cumulative

print("Produit cumulative :", [Link](arr)) # [10 200 6000 240000

12000000]

💡 Très utile pour calculer des indicateurs financiers cumulés (CA, ventes, stocks).

4 Opérations sur tableaux 2D

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

print("Somme totale :", [Link](mat)) # 45

print("Somme par ligne :", [Link](mat, axis=1)) # [6 15 24]
print("Somme par colonne :", [Link](mat, axis=0)) # [12 15 18]

💡 axis=0 → colonnes, axis=1 → lignes

5 Opérations élémentaires universelles (ufuncs)

NumPy propose des fonctions mathématiques rapides et vectorisées :

arr = [Link]([1, 4, 9, 16])

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

print("Exposant :", [Link](arr)) # [2.718 54.598 ...]
print("Logarithme :", [Link](arr)) # [0. 1.386 2.197 2.772]
print("Sinus :", [Link](arr)) # [0.841 -0.757 ...]

💡 Très utile pour transformer des variables ou normaliser des données.

6 Comparaisons et filtrage
Les opérations logiques permettent de filtrer les données sans boucle :

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

# Filtrer valeurs > 25

mask = arr > 25
print("Masque :", mask) # [False False True True True]
print("Valeurs filtrées :", arr[mask]) # [30 40 50]

💡 Indispensable pour sélectionner des lignes dans un dataset.

7 Opérations combinées
arr = [Link]([1, 2, 3, 4, 5])

# Ajouter 10 puis multiplier par 2

result = (arr + 10) * 2
print("Résultat :", result) # [22 24 26 28 30]

💡 Très pratique pour calculer de nouveaux indicateurs à partir des colonnes existantes.

8 Cas concret Data Analyst

Supposons un tableau des ventes en milliers :

ventes = [Link]([100, 200, 150, 300, 250])

# Chiffre d'affaires total

print("CA total :", [Link](ventes))

# Moyenne par vente

print("CA moyen :", [Link](ventes))
# Ventes supérieures à 180
print("Ventes > 180 :", ventes[ventes > 180])

💡 En quelques lignes, tu obtiens les KPIs essentiels.

9 Bonnes pratiques Data Analyst

1. Préférer opérations vectorisées plutôt que boucles.

2. Toujours vérifier la dimension du tableau avant un calcul (shape, ndim).

3. Utiliser les fonctions ufunc pour transformations et normalisations.

4. Toujours filtrer et nettoyer avant de calculer.

5. Documenter les transformations pour garder un pipeline clair.

10 Mini-exercice pratique
1. Crée un tableau 1D notes : [12, 15, 10, 18, 20]

2. Calcule la moyenne, médiane, écart-type, minimum et maximum

3. Affiche les notes supérieures à la moyenne

4. Crée un tableau bonus qui ajoute 2 points à toutes les notes

5. Calcule la somme cumulée des notes

💡 A retenir :

● NumPy permet de calculer des indicateurs rapidement

 ● Statistiques, filtres et transformations se font sans boucle

● Base solide pour analyser des datasets massifs

● Prépare à Pandas et visualisation de données

Section 4 : Fonctions universelles

(ufuncs) et vectorisation pour un Data
Analyst
À la fin de cette section, tu seras capable de :

1. Comprendre ce que sont les fonctions universelles (ufuncs) dans NumPy.

2. Appliquer des transformations vectorisées sur des tableaux 1D et 2D.
3. Combiner des opérations mathématiques et logiques en une seule ligne.
4. Accélérer tes calculs et analyses sur des datasets massifs.

1 Qu’est-ce qu’une ufunc ?

● Une ufunc (Universal Function) est une fonction NumPy qui opère
élément par élément sur des tableaux.

● Elle est très rapide car optimisée en C derrière Python.

● Permet d’éviter les boucles lentes en Python pur.

Exemple simple :

import numpy as np

arr = [Link]([1, 4, 9, 16]) #

Racine carrée
racine = [Link](arr) print(racine)
# [1. 2. 3. 4.]
# Exponentielle
exp = [Link](arr)
print(exp)

2 Autres ufuncs mathématiques courantes

● [Link]() → valeur absolue

● [Link]() → logarithme naturel

● np.log10() → logarithme base 10

● [Link](), [Link](), [Link]() → trigonométrie

● [Link]() → carré

● [Link](arr, n) → puissance

arr = [Link]([-1, -2, 3, 4])

print([Link](arr)) # [1 2 3 4]
print([Link](arr)) # [1 4 9 16]
print([Link](arr, 3)) # [-1 -8 27 64]

💡 Pour un Data Analyst, très utile pour normaliser, transformer ou coder des variables.

3 Vectorisation
● Vectorisation = appliquer une opération sur tous les éléments du tableau
en une seule ligne.

● Évite les boucles for lentes et rend le code plus lisible et rapide.

arr = [Link]([10, 20, 30, 40])

# Ajouter 5 à chaque élément
arr_plus_5 = arr + 5
print(arr_plus_5) # [15 25 35 45]

# Multiplier chaque élément par 2

arr_x2 = arr * 2
print(arr_x2) # [20 40 60 80]

💡 Même chose sur un tableau 2D :

mat = [Link]([[1,2,3],[4,5,6]])
mat_plus_10 = mat + 10
print(mat_plus_10)

4 Combiner plusieurs ufuncs

On peut chaîner plusieurs fonctions en une seule ligne :

arr = [Link]([1, 4, 9, 16])

# Transformation combinée : racine puis

carré result = [Link]([Link](arr))
print(result) # [1 4 9 16]

💡 Utile pour préparer les données avant modélisation ou visualisation.

5 Comparaisons vectorisées et masques

● Comparer tous les éléments en une seule opération :

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

mask = arr > 25 # True/False pour chaque élément

print(mask) # [False False True True True]
# Extraire les valeurs > 25
print(arr[mask]) # [30 40 50]

💡 Très pratique pour filtrer automatiquement des lignes d’un dataset.

6 Fonctions conditionnelles vectorisées

NumPy propose [Link](condition, valeur_si_vrai, valeur_si_faux) :

arr = [Link]([100, 200, 150, 300, 250])

# Si vente > 200 → "Haute", sinon "Basse"

categorie = [Link](arr > 200, "Haute", "Basse")
print(categorie) # ['Basse' 'Basse' 'Basse' 'Haute' 'Haute']

💡 Très utile pour créer de nouvelles colonnes ou KPI automatiquement.

7 Réductions et agrégations
Les ufuncs permettent aussi de réduire un tableau à un indicateur :

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

print([Link](arr)) # 15
print([Link](arr)) # 3.0
print([Link](arr)) # 5
print([Link](arr)) # 1
print([Link](arr)) # écart-type

8 Applications concrètes Data Analyst

Exemple : pipeline de ventes en milliers :
ventes = [Link]([100, 200, 150, 300, 250])

# Transformation : appliquer taxe 20%

ventes_taxe = ventes * 1.2

# Identifier ventes élevées

mask = ventes_taxe > 300
ventes_elevees = ventes_taxe[mask]

print("Ventes après taxe :", ventes_taxe)

print("Ventes élevées :", ventes_elevees)

💡 Quelques lignes suffisent pour préparer, transformer et filtrer les données.

9 Bonnes pratiques pour Data Analyst

1. Toujours vectoriser plutôt que boucler

2. Vérifier la dimension du tableau (ndim, shape) avant les opérations

3. Utiliser [Link] et masques pour filtrer et créer des colonnes automatiquement

4. Combiner ufuncs pour préparer des KPI complexes en une ligne

5. Toujours documenter la logique pour le pipeline

10 Mini-exercice pratique
1. Crée un tableau ventes : [120, 250, 180, 400, 300]

2. Applique une remise de 10 % à toutes les ventes

3. Identifie les ventes supérieures à 200 avec un masque

 4. Crée une nouvelle colonne categorie : "Haute" si > 250, "Moyenne" sinon

5. Calcule la somme, moyenne, min et max des ventes après remise

💡 A retenir :

● Les ufuncs permettent de transformer et calculer des données massives en

une seule ligne

● La vectorisation remplace les boucles lentes

● Masques et [Link] permettent de filtrer et créer de nouvelles colonnes

● Base essentielle pour Pandas, statistiques et visualisation

Section 5 : Reshape, flatten et

concaténation des tableaux NumPy
À la fin de cette section, tu seras capable de :

1. Changer la forme d’un tableau (reshape) pour l’adapter aux besoins.

2. Aplatir un tableau multidimensionnel (flatten) pour des calculs ou exports.

3. Concaténer ou empiler des tableaux horizontalement et verticalement.

4. Préparer tes tableaux pour Pandas, visualisations ou calculs statistiques avancés.

1 Reshape : changer la forme d’un tableau

● reshape() permet de modifier la dimension d’un tableau sans en
changer les valeurs.
 ● Très pratique pour passer de 1D → 2D, ou préparer un dataset pour ML.

import numpy as np #

Tableau 1D
arr1d = [Link](1, 13) # [1 2 3 ... 12]
print("Original :", arr1d)

# Reshape en 3 lignes et 4 colonnes

arr2d = [Link](3, 4)
print("Reshape 3x4 :\n", arr2d)

# Reshape en 2 lignes et 6 colonnes

arr2d_alt = [Link](2, 6)
print("Reshape 2x6 :\n", arr2d_alt)

💡 Pour un Data Analyst : reshape est souvent utilisé pour transformer des vecteurs en
matrices exploitables.

2 Flatten : aplatir un tableau

● flatten() transforme un tableau multidimensionnel → 1D

arr2d = [Link]([[1,2,3],[4,5,6],[7,8,9]])
arr1d = [Link]()
print("Flatten :", arr1d) # [1 2 3 4 5 6 7 8 9]

● Alternative : ravel() → similaire mais plus mémoire optimisée

💡 Utile pour préparer des colonnes pour export CSV ou Pandas.

3 Concaténation de tableaux
a) Concaténation verticale (vstack)
a = [Link]([[1,2,3]])
b = [Link]([[4,5,6]])
c = [Link]((a, b))
print(c)

Résultat :

[[1 2 3]
[4 5 6]]

b) Concaténation horizontale (hstack)

a = [Link]([[1],[2],[3]])
b = [Link]([[4],[5],[6]])
c = [Link]((a, b))
print(c)

Résultat :

4]
5]
6]]

💡 En Data Analyst : concaténation utile pour fusionner des colonnes de variables

ou ajouter des observations.

4 Empiler : stack, column_stack et row_stack

● np.column_stack((a,b)) → combine 1D ou 2D en colonnes

● np.row_stack((a,b)) → combine 1D ou 2D en lignes

a = [Link]([1,2,3])
b = [Link]([4,5,6])
# colonne
c = np.column_stack((a,b))
print(c)
# lignes
d = np.row_stack((a,b))
print(d)

💡 Idéal pour préparer un dataset avec plusieurs variables.

5 Redimensionnement automatique
● On peut utiliser -1 pour laisser NumPy calculer automatiquement la
dimension restante

arr = [Link](1, 13)

arr_reshape = [Link](3, -1) # 3 lignes, colonnes calculées
automatiquement
print(arr_reshape)

Résultat : 3x4, car 12 / 3 = 4 colonnes

💡 Gain de temps sur datasets dont on ne connaît pas exactement la structure.

6 Répéter des tableaux : tile et repeat

● Répéter un tableau entier : tile

● Répéter chaque élément : repeat

arr = [Link]([1,2,3])
print([Link](arr, 2)) # [1 2 3 1 2 3]
print([Link](arr, 2)) # [1 1 2 2 3 3]
💡 Utile pour aligner des datasets ou créer des colonnes de référence.

7 Applications concrètes Data Analyst

● Fusionner des colonnes de ventes, coûts et marges en une matrice unique

● Transformer un vecteur de mesures en tableau 2D pour calculs

statistiques par groupe

● Aplatir un tableau pour export CSV ou création de DataFrame Pandas

● Créer des datasets tests pour simulations ou KPI automatisés

8 Bonnes pratiques Data Analyst

1. Toujours vérifier shape après reshape ou concaténation.

2. Préférer vstack/hstack pour fusionner tableaux 2D.

3. Utiliser flatten ou ravel pour exporter ou préparer les données.

4. Préparer les tableaux avant les calculs statistiques pour éviter les
erreurs de dimension.

5. Documenter la logique de fusion ou reshape pour garder le pipeline clair.

9 Mini-exercice pratique
1. Crée un tableau 1D a de 1 à 12.

2. Reshape-le en 3 lignes et 4 colonnes.

 3. Aplatis-le avec flatten.

4. Crée un second tableau b = [[100,200,300,400]]

5. Concatène verticalement a et b.

6. Concatène horizontalement les deux premiers colonnes de a avec b (utiliser

hstack ou
column_stack).

💡 A retenir :

● reshape : change la forme des tableaux

● flatten / ravel : aplatir pour calculs ou export

● vstack, hstack, column_stack : fusionner et combiner des tableaux

● Base indispensable pour préparer les datasets pour Pandas, visualisation

ou statistiques avancées

Section 6 : Masques et filtrage de données

avec NumPy
À la fin de cette section, tu seras capable de :

1. Créer des masques booléens pour filtrer des données.

2. Appliquer des conditions simples et combinées.
3. Filtrer tableaux 1D et 2D sans boucle.
4. Préparer des colonnes et datasets pour analyse ou visualisation.

1 Qu’est-ce qu’un masque ?

● Un masque est un tableau de booléens (True / False) de la même
dimension que ton tableau de données.
 ● Il permet de sélectionner uniquement les éléments qui respectent une condition.

Exemple simple :

import numpy as np

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

Masque : valeurs > 25

mask = arr > 25
print(mask) # [False False True True True]

# Appliquer le masque
print(arr[mask]) # [30 40 50]

💡 Très utile pour filtrer rapidement des KPI ou observations pertinentes.

2 Conditions multiples
● On peut combiner plusieurs conditions avec & (and), | (or), ~ (not)

● ⚠ Toujours entourer chaque condition avec des parenthèses

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

Valeurs > 20 ET < 50

mask = (arr > 20) & (arr < 50)
print(arr[mask]) # [30 40]

# Valeurs < 20 OU > 40

mask2 = (arr < 20) | (arr > 40)
print(arr[mask2]) # [10 50]

💡 Indispensable pour segmenter des données selon des critères métiers.

3 Filtrage sur tableaux 2D
mat = [Link]([[10, 20, 30],
[40, 50, 60],
[70, 80, 90]])

# Masque pour valeurs >

50 mask = mat > 50
print(mask)
print(mat[mask]) # [60 70 80 90]

● On peut filtrer par ligne ou colonne en combinant axis ou en utilisant des

fonctions comme any() et all()

# Lignes avec au moins une valeur > 50

rows = mat[[Link](mat > 50, axis=1)]
print(rows)

4 Masques avancés avec [Link]

● [Link](condition, valeur_si_vrai, valeur_si_faux) permet de
créer de nouvelles colonnes ou tableaux transformés :

ventes = [Link]([100, 250, 180, 400, 300])

# Catégoriser ventes
categorie = [Link](ventes > 250, "Haute", "Basse")
print(categorie) # ['Basse' 'Basse' 'Basse' 'Haute' 'Haute']

💡 Utile pour créer des KPI ou labels automatiquement.

5 Masques combinés et filtrage conditionnel

ventes = [Link]([100, 250, 180, 400, 300])
# Filtrer ventes > 150 ET < 350
mask = (ventes > 150) & (ventes < 350)
ventes_filtrees = ventes[mask]
print(ventes_filtrees) # [250 180 300]

# Transformation conditionnelle
ventes_modifiees = [Link](ventes > 300, ventes*0.9, ventes)
print(ventes_modifiees) # Applique remise 10% si vente > 300

💡 Combine filtrage et transformation pour préparer des pipelines d’analyse automatisés.

6 Applications concrètes Data Analyst

● Filtrer des ventes supérieures à un seuil pour calculer des indicateurs ciblés

● Identifier des clients à risque ou VIP selon plusieurs critères

● Créer des colonnes dérivées directement à partir des données brutes

● Segmenter des datasets pour visualisation ou export CSV

7 Bonnes pratiques
1. Toujours vérifier la dimension du tableau avant d’appliquer un masque (ndim, shape)

2. Parenthèses obligatoires autour des conditions multiples

3. Préférer les masques vectorisés plutôt que les boucles pour filtrer

4. Documenter la logique de filtrage pour maintenir un pipeline clair et reproductible

 8 Mini-exercice pratique
1. Crée un tableau ventes : [120, 250, 180, 400, 300]

2. Filtre les ventes supérieures à 200

3. Crée un masque pour les ventes inférieures à 200 ou supérieures à 350

4. Transforme le tableau : ventes > 300 → appliquer une remise de 10%

5. Crée une nouvelle colonne categorie : "Haute" si > 250, "Moyenne" sinon

💡 A retenir :

● Masques = outil essentiel pour filtrer et segmenter des données rapidement

● [Link] permet de créer de nouvelles colonnes selon conditions

● Base pour préparer des datasets pour analyse et visualisation

● Permet d’automatiser les calculs conditionnels sur de grands tableaux

Section 7 : Génération de données

aléatoires et simulations avec NumPy
À la fin de cette section, tu seras capable de :

1. Générer des tableaux de données aléatoires avec différentes distributions.

2. Créer des datasets simulés pour tests et analyses.
3. Contrôler la reproductibilité avec des seeds.
4. Simuler des scénarios métier réalistes pour KPIs et prévisions.

1 Générer des nombres aléatoires

a) Nombres aléatoires flottants entre 0 et 1
import numpy as np

rand_float = [Link](5)
print(rand_float) # Ex : [0.5488135 0.71518937 0.60276338 0.54488318
0.4236548 ]

b) Nombres aléatoires entiers dans un intervalle

rand_int = [Link](10, 50, size=5) # 5 valeurs entre 10 et
50
print(rand_int)

💡 Utile pour simuler ventes, scores ou quantités.

2 Contrôler la reproductibilité
● Pour que les résultats aléatoires soient identiques à chaque exécution, utiliser
seed() :

[Link](42)
print([Link](5))

💡 Fondamental pour tests reproductibles et comparaisons d’analyses.

3 Distributions statistiques
NumPy permet de générer des données selon différentes distributions :

● Normale (gaussienne)

data_norm = [Link](loc=50, scale=10, size=1000) #

moyenne=50, écart-type=10
 ● Uniforme

data_uniform = [Link](low=0, high=100, size=100)

● Binomiale (succès/échec)

data_binom = [Link](n=1, p=0.3, size=10) # ex : succès=1,

échec=0

💡 Très utile pour simuler ventes, probabilités ou tests statistiques.

4 Mélanger et échantillonner des données

● Mélanger un tableau : [Link]()

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

[Link](arr)
print(arr) # Tableau mélangé

● Échantillonner un tableau : [Link]()

echantillon = [Link](arr, size=3, replace=False) # 3

éléments uniques
print(echantillon)

💡 Utile pour tests A/B ou tirages aléatoires dans un dataset.

5 Générer des matrices aléatoires

# Matrice 3x4 de flottants 0-1
mat_rand = [Link](3,4)
print(mat_rand)

# Matrice 3x4 d'entiers 10-50

mat_rand_int = [Link](10, 50, size=(3,4))
print(mat_rand_int)

💡 Utile pour simuler un dataset complet avec plusieurs variables.

6 Simuler des scénarios métiers

Exemple : ventes simulées pour 30 jours

[Link](42)
ventes_journalieres = [Link](loc=200, scale=50, size=30)
ventes_journalieres = [Link](ventes_journalieres)
print(ventes_journalieres)

● On peut ajouter des conditions : si vente < 0 → 0

ventes_journalieres = [Link](ventes_journalieres < 0, 0,

ventes_journalieres)

💡 Cela permet de tester ton pipeline sur des données réalistes avant d’avoir les vrais.

7 Combiner plusieurs colonnes simulées

Exemple : créer un mini dataset client :

clients = [Link](1,11) # ID client

achats = [Link](100, 500, 10) # montant achats
fidelite = [Link]([0,1], size=10) # 0=non, 1=oui
dataset = np.column_stack((clients, achats, fidelite))
print(dataset)

💡 Prépare des datasets simulés pour tests, visualisation ou analyses.

8 Bonnes pratiques Data Analyst

1. Toujours utiliser seed() pour reproductibilité

2. Vérifier shape et type des tableaux générés

3. Utiliser [Link]() pour rendre les données réalistes

4. Simuler en respectant les contraintes métiers (ex : ventes ≥ 0)

5. Documenter la logique de simulation pour transparence et reproductibilité

9 Mini-exercice pratique
1. Crée un tableau aléatoire de 20 ventes journalières (normal, moyenne=200,
écart=50)

2. Arrondis les valeurs à l’entier le plus proche

3. Remplace les valeurs négatives par 0

4. Crée un tableau client_id de 1 à 20

5. Combine client_id et ventes_journalieres en un tableau 2D (dataset test)

💡 A retenir :

● Génération aléatoire = base pour simulations et tests

 ● Seed = reproductibilité

● Distributions normales, uniformes, binomiales pour scénarios métiers

● Combine plusieurs tableaux pour créer datasets simulés complets

● Indispensable pour préparer, tester et automatiser l’analyse

Section 8 : Indexation avancée et sélection

conditionnelle sur tableaux 2D
À la fin de cette section, tu seras capable de :

1. Sélectionner des lignes, colonnes ou éléments spécifiques dans un tableau 2D.

2. Appliquer des conditions complexes sur plusieurs colonnes.

3. Créer des sous-tableaux filtrés sans boucle.

4. Préparer tes données pour analyses statistiques ou visualisations.

1 Sélection simple de lignes et colonnes

import numpy as np

mat = 30],
[Link](
[[10,
[40, 60],
[70, 90]])

# Sélection d’une ligne

print(mat[1]) # 2ème ligne → [40 50 60]

# Sélection d’une colonne

print(mat[:, 2]) # 3ème colonne → [30 60 90] #

Sélection d’un élément précis

print(mat[0,1]) # 1ère ligne, 2ème colonne → 20

💡 Base pour extraire observations et variables dans un dataset.

2 Indexation par liste d’indices

● Sélectionner plusieurs lignes ou colonnes spécifiques :

# Lignes 0 et 2
print(mat[[0,2]])

# Colonnes 0 et 2
print(mat[:, [0,2]])

💡 Utile pour extraire un sous-ensemble de colonnes pour analyse ou visualisation.

3 Sélection conditionnelle sur colonnes

● On peut créer des masques sur une ou plusieurs colonnes :

# Sélection des lignes où 2ème colonne > 50

mask = mat[:,1] > 50
print(mat[mask])

Résultat :

[[70 80 90]]

💡 Très pratique pour filtrer des observations selon un KPI spécifique.

4 Conditions multiples sur 2 colonnes

# Lignes où 1ère colonne > 20 ET 3ème colonne < 70
mask = (mat[:,0] > 20) & (mat[:,2] < 70)
print(mat[mask])

💡 Utile pour segmenter les clients ou ventes selon plusieurs critères.

5 Utilisation de [Link] sur 2D

● Créer des nouveaux tableaux conditionnels :

# Marquer "Haut" si valeur > 50, sinon "Bas"

labels = [Link](mat > 50, "Haut", "Bas")
print(labels)

💡 Permet de transformer un tableau brut en tableau catégoriel pour visualisation ou

reporting.

6 Extraction avec conditions combinées et colonnes

multiples
Exemple : dataset ventes

data = [Link]([
100
0], # ID, ventes, VIP

250
1],

180
0],

400
1]

])

# Sélection des clients VIP (3ème colonne = 1) ET ventes > 200

mask = (data[:,2] == 1) & (data[:,1] > 200)
print(data[mask])
Résultat :

[[ 2 250 1]
[ 4 400 1]]

💡 Très pratique pour sélectionner des sous-groupes pour reporting ou visualisation.

7 Modification conditionnelle de valeurs

# Ajouter 10% aux ventes supérieures à 200
data[:,1] = [Link](data[:,1] > 200, data[:,1]*1.1, data[:,1])
print(data)

💡 Utile pour ajuster automatiquement les KPI ou projections.

8 Masques sur plusieurs colonnes pour filtrage avancé

● Extraire les lignes selon plusieurs conditions :

# Ventes entre 150 et 300 ET non VIP

mask = (data[:,1] >= 150) & (data[:,1] <= 300) & (data[:,2]==0)
print(data[mask])

Résultat :

[[ 3 180 0]]

💡 Combine filtrage et logique métier pour préparer des datasets prêts à analyser.

9 Bonnes pratiques
 1. Vérifier toujours shape et ndim avant de filtrer

2. Encadrer chaque condition par parenthèses

3. Utiliser des masques vectorisés pour éviter les boucles lentes

4. Documenter la logique pour pipeline clair et reproductible

5. Préparer les données filtrées pour statistiques ou visualisations ultérieures

10 Mini-exercice pratique
1. Crée un tableau data 2D : [ID, ventes, VIP] avec 5 clients

2. Sélectionne uniquement les clients VIP

3. Sélectionne les clients dont les ventes sont > 200

4. Crée une colonne categorie : "Haut" si ventes > 250, sinon "Bas"

5. Filtre les clients non VIP et ventes entre 150 et 300

💡 A retenir :

● Indexation avancée = extraire lignes, colonnes ou sous-tableaux selon

conditions complexes

● Masques et [Link] permettent filtrage et transformation simultanés

● Base indispensable pour préparer un dataset pour Pandas, statistiques

ou visualisation

Section 9 : Sauvegarde et chargement des

tableaux NumPy
À la fin de cette section, tu seras capable de :

1. Sauvegarder des tableaux NumPy dans différents formats (.npy, .npz, .csv).
2. Charger ces tableaux rapidement pour reprendre l’analyse.
3. Préparer des fichiers reproductibles et partagés.
4. Gérer efficacement les pipelines Data Analyst avec NumPy.

1 Sauvegarder un tableau avec [Link]

● Sauvegarde un tableau 1D ou 2D dans un fichier binaire .npy

import numpy as np

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

[Link]("[Link]", arr)

● Le fichier .npy est rapide à lire et écrit en format NumPy natif

# Charger le tableau
arr_loaded = [Link]("[Link]")
print(arr_loaded)

💡 Utile pour préserver des données brutes ou transformées entre sessions.

2 Sauvegarder plusieurs tableaux avec [Link]

● Permet de sauvegarder plusieurs tableaux dans un seul fichier .npz

a = [Link]([1,2,3])
b = [Link]([4,5,6])
[Link]("multi_tableaux.npz", arr1=a, arr2=b)
 ● Chargement :

loaded = [Link]("multi_tableaux.npz")
print(loaded["arr1"]) # [1 2 3]
print(loaded["arr2"]) # [4 5 6]

💡 Parfait pour garder un dataset complet avec plusieurs variables.

3 Sauvegarde au format CSV

● NumPy permet de sauvegarder sous format texte pour Excel, Pandas ou autres outils
:

arr2d = [Link]([[10,20,30],[40,50,60]])
[Link]("[Link]", arr2d, delimiter=",", fmt="%d")

● Lecture :

loaded_csv = [Link]("[Link]", delimiter=",")

print(loaded_csv)

💡 Idéal pour exporter des données pour reporting ou visualisation.

4 Lecture de fichiers CSV existants

● Charger un dataset existant :

data = [Link]("[Link]", delimiter=",")

print(data)
 ● Pour données mixtes ou texte, mieux vaut utiliser Pandas (on verra plus tard).

5 Sauvegarder avec compression

(np.savez_compressed)
● Pour économiser de l’espace :

np.savez_compressed("multi_compress.npz", arr1=a, arr2=b)

💡 Indispensable pour datasets volumineux.

6 Gestion des chemins de fichiers

● Toujours utiliser des chemins relatifs ou absolus :

[Link]("data/[Link]", arr)
arr_loaded = [Link]("data/[Link]")

● Vérifier que le dossier existe ([Link]("data", exist_ok=True))

💡 Bonnes pratiques pour workflow reproductible et partageable.

7 Applications concrètes Data Analyst

● Sauvegarder un dataset transformé après nettoyage

● Préparer un dataset simulé pour tests (section 7)

● Partager un fichier .npy ou .csv avec une équipe

 ● Réutiliser un tableau pour analyse, visualisation ou modélisation

8 Bonnes pratiques
1. Préférer .npy ou .npz pour travail interne NumPy → rapidité et fiabilité

2. .csv pour partage avec Excel, Pandas ou reporting

3. Toujours nommer les fichiers clairement (dataset_cleaned.npy)

4. Documenter le contenu du fichier pour éviter toute confusion

5. Pour gros datasets, utiliser np.savez_compressed

9 Mini-exercice pratique
1. Crée un tableau ventes aléatoire de 20 valeurs (section 7)

2. Sauvegarde-le en .npy

3. Crée un deuxième tableau clients avec 1 à 20

4. Sauvegarde les deux dans un .npz

5. Charge les fichiers et vérifie que les données sont intactes

6. Sauvegarde un tableau 2D sous .csv et relis-le

💡 A retenir :

● [Link] / [Link] = sauvegarde et lecture rapide de tableaux uniques

● [Link] / np.savez_compressed = multiple tableaux, compressés

● [Link] / [Link] = format CSV pour export ou partage

 ● Base essentielle pour préparer les données pour Pandas, visualisation et
analyses futures

Section 10 : Mini-projet Jour 3 : Pipeline

NumPy complet pour Data Analyst

À la fin de ce mini-projet, tu seras capable de :

1. Générer et manipuler un dataset simulé complet avec NumPy.

2. Appliquer des transformations vectorisées et des masques conditionnels.
3. Réorganiser et filtrer les données selon des critères métiers.
4. Sauvegarder et charger les données pour réutilisation future.
5. Automatiser un mini-pipeline Data Analyst entièrement en NumPy.

1 Description du scénario métier

Tu es Data Analyst dans une entreprise de e-commerce.
On te demande de créer un dataset simulé des ventes mensuelles pour 30 clients, avec les
informations suivantes :

● client_id : 1 à 30
● ventes : nombre aléatoire de ventes entre 100 et 500
● VIP : 0 ou 1 (client VIP ou non)
● remise_appliquee : True si ventes > 400 → appliquer une remise de 10%
● categorie : "Haute" si ventes > 350, "Moyenne" si ventes entre 200 et
350, "Basse" sinon

Le tout doit être sauvegardé pour réutilisation et visualisation ultérieure.

2 Étapes du pipeline NumPy

a) Générer les données
import numpy as np
[Link](42)

# client_id
client_id = [Link](1,31)

# ventes
ventes = [Link](100, 501, size=30)

# VIP
VIP = [Link]([0,1], size=30)

print(client_id)
print(ventes)
print(VIP)

b) Appliquer remise avec vectorisation et [Link]

# Remise de 10% si ventes > 400
ventes_finales = [Link](ventes > 400, ventes*0.9, ventes)

c) Créer la catégorie des ventes

categorie = [Link](ventes_finales > 350, "Haute",
[Link](ventes_finales >= 200, "Moyenne", "Basse"))

d) Créer un tableau 2D complet

dataset = np.column_stack((client_id, ventes_finales, VIP, categorie))
print(dataset)

💡 Résultat : un tableau prêt pour analyse, filtrage ou export.

e) Filtrer les clients VIP avec ventes > 300

mask = (dataset[:,2].astype(int) == 1) & (dataset[:,1].astype(float) >
300)
VIP_haut_ventes = dataset[mask]
print(VIP_haut_ventes)

f) Sauvegarder le dataset
# Sauvegarde en .npy
[Link]("[Link]", dataset)

# Sauvegarde multiple
[Link]("dataset_complet.npz",
client_id=client_id, ventes=ventes_finales,
VIP=VIP, categorie=categorie)

g) Charger le dataset
loaded_data = [Link]("[Link]", allow_pickle=True)
print(loaded_data)

3 Bonnes pratiques appliquées

1. Utiliser seed() pour reproductibilité
2. Masques vectorisés pour filtrage rapide
3. [Link] pour transformation conditionnelle
4. column_stack pour assembler les données en tableau exploitable
5. Sauvegarde et chargement pour réutiliser les datasets sans les régénérer

4 Mini-exercice supplémentaire
1. Crée un nouveau champ "bonus" : 50 si VIP et ventes > 250, sinon 0
2. Calcule la moyenne des ventes par catégorie ("Basse", "Moyenne", "Haute")
3. Exporte le dataset final en CSV pour visualisation dans Excel ou Pandas
💡 A retenir :

● NumPy permet de créer des pipelines complets d’analyse et de simulation

● Vectorisation, masques et [Link] sont les clés pour automatiser les
transformations
● Reshape, concaténation et filtrage préparent les données pour
statistiques et visualisation
● Sauvegarde et chargement assurent réutilisation et reproductibilité

Conclusion
Félicitations ! Aujourd’hui, tu as parcouru tout l’univers NumPy pour un Data Analyst :

● Création de tableaux 1D et 2D
● Reshape, flatten et concaténation
● Masques et filtrage conditionnel
● Génération de données aléatoires et simulations réalistes
● Indexation avancée sur tableaux 2D
● Sauvegarde et chargement des datasets pour réutilisation

Tu es désormais capable de préparer, transformer et filtrer tes données efficacement en

NumPy, ce qui est la base incontournable avant de passer à des datasets plus
complexes avec Pandas.

Tu as même réalisé un pipeline complet NumPy simulant un scénario métier réel, ce qui est
exactement le type de workflow que tu utiliseras en entreprise.

💡 Pourquoi c’est important : Pandas te permettra de passer de tableaux bruts à des

datasets analytiques prêts à l’emploi, en combinant toutes les compétences NumPy
acquises et en automatisant tes analyses de données métier.

Demain, tu vas découvrir comment transformer des données brutes en informations

exploitables, préparer tes datasets pour l’analyse, et mettre en pratique tout ce
que tu as appris jusqu’ici avec NumPy dans un environnement professionnel.