NumPy Core

Guide complet avec exemples

Toutes les fonctions essentielles expliquées et illustrées

Création • Manipulation • Mathématiques • Statistiques • I/O

Table des matières
1. Introduction à NumPy
2. Création de tableaux
3. Manipulation de la forme
4. Indexation et sélection
5. Opérations mathématiques
6. Fonctions trigonométriques
7. Statistiques et agrégations
8. Tri et recherche
9. Opérations sur les tableaux
10. Nombres complexes
11. Logique booléenne
12. Sauvegarde et chargement
1. Introduction à NumPy
NumPy (Numerical Python) est la bibliothèque fondamentale du calcul scientifique en Python. Elle
fournit un objet tableau multidimensionnel puissant appelé ndarray, ainsi que des routines
optimisées pour effectuer des opérations rapides sur ces tableaux.

Installation et importation
# Installation
pip install numpy

# Importation conventionnelle
import numpy as np

# Vérifier la version
print(np.__version__) # ex: 1.26.0

L'objet ndarray
Le ndarray est le coeur de NumPy. C'est un tableau N-dimensionnel homogène (tous les éléments
ont le même type). Ses attributs principaux sont :

Attribut Description Exemple

ndim Nombre de dimensions 2

shape Forme (tuple) (3, 4)

size Nombre total d'éléments 12

dtype Type des données float64

itemsize Taille en octets par élément 8

nbytes Taille totale en octets 96

import numpy as np

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

print([Link]) # 2
print([Link]) # (2, 3)
print([Link]) # 6
print([Link]) # int64
print([Link]) # 8
2. Création de tableaux

[Link]() — Depuis une liste Python

Crée un tableau à partir d'une liste, d'un tuple ou de données imbriquées.
# Tableau 1D
a = [Link]([1, 2, 3, 4, 5])
print(a) # [1 2 3 4 5]

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

# Spécifier le type
c = [Link]([1, 2, 3], dtype=float)
print(c) # [1. 2. 3.]

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

[Link]() / [Link]() / [Link]()

Créent des tableaux remplis de valeurs constantes.
# Tableau de zéros
z = [Link]((3, 4))
# [[0. 0. 0. 0.]
# [0. 0. 0. 0.]
# [0. 0. 0. 0.]]

# Tableau de uns
u = [Link]((2, 3), dtype=int)
# [[1 1 1]
# [1 1 1]]

# Tableau rempli d'une valeur

f = [Link]((3, 3), 7)
# [[7 7 7]
# [7 7 7]
# [7 7 7]]

# Variantes _like (même forme qu'un tableau existant)

a = [Link]([[1, 2], [3, 4]])
print(np.zeros_like(a)) # [[0 0] [0 0]]
print(np.ones_like(a)) # [[1 1] [1 1]]
print(np.full_like(a, 5)) # [[5 5] [5 5]]
[Link]() / [Link]() / [Link]()
Créent des séquences de valeurs numériques.
# arange : comme range() mais pour NumPy
[Link](10) # [0 1 2 3 4 5 6 7 8 9]
[Link](2, 10) # [2 3 4 5 6 7 8 9]
[Link](0, 1, 0.2) # [0. 0.2 0.4 0.6 0.8]

# linspace : N points entre a et b (inclus)

[Link](0, 1, 5) # [0. 0.25 0.5 0.75 1. ]
[Link](0, 10, 3) # [ 0. 5. 10. ]

# logspace : N points espacés logarithmiquement

[Link](0, 3, 4) # [ 1. 10. 100. 1000.]
# (10^0, 10^1, 10^2, 10^3)

Astuce : Utilisez linspace() plutôt que arange() quand vous avez besoin d'un nombre précis de points.

[Link]() / [Link]() / [Link]()

# Matrice identité
[Link](3)
# [[1. 0. 0.]
# [0. 1. 0.]
# [0. 0. 1.]]

# Matrice identité (alias)

[Link](3) # identique à eye(3)

# Diagonale : vecteur -> matrice diagonale

[Link]([1, 2, 3])
# [[1 0 0]
# [0 2 0]
# [0 0 3]]

# Diagonale : matrice -> vecteur diagonal

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

[Link]() / [Link] / [Link]

Créent des grilles de coordonnées utiles pour tracer des fonctions 2D.
# meshgrid : grille de coordonnées
x = [Link]([0, 1, 2])
y = [Link]([0, 1])
X, Y = [Link](x, y)
print(X)
# [[0 1 2]
# [0 1 2]]
print(Y)
# [[0 0 0]
# [1 1 1]]

# mgrid : syntaxe pratique

Y, X = [Link][0:3, 0:4]
# Y varie de 0 à 2, X de 0 à 3

# Utilisation typique : tracer Z = sin(X) + cos(Y)

x = [Link](-3, 3, 100)
y = [Link](-3, 3, 100)
X, Y = [Link](x, y)
Z = [Link](X) + [Link](Y)
3. Manipulation de la forme

reshape() / ravel() / flatten()

a = [Link](12)
# [ 0 1 2 3 4 5 6 7 8 9 10 11]

# reshape : change la forme (les données ne bougent pas)

b = [Link](3, 4)
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]

# -1 : NumPy calcule automatiquement la dimension

c = [Link](2, -1) # (2, 6)
d = [Link](-1, 3) # (4, 3)

# ravel : aplatit en 1D (vue si possible)

e = [Link]() # [ 0 1 2 ... 11]

# flatten : aplatit en 1D (toujours une copie)

f = [Link]()

Info : ravel() retourne une vue (plus rapide), flatten() retourne une copie.

transpose() / swapaxes() / moveaxis()

a = [Link]([[1, 2, 3],
[4, 5, 6]])
# shape : (2, 3)

# Transposer : échange lignes et colonnes

b = a.T # ou [Link](a)
# [[1 4]
# [2 5]
# [3 6]]
# shape : (3, 2)

# swapaxes : échange deux axes

c = [Link](a, 0, 1) # identique à a.T ici

# moveaxis : déplace un axe vers une nouvelle position

a3d = [Link]((2, 3, 4)) # shape (2, 3, 4)
b3d = [Link](a3d, 0, -1) # shape (3, 4, 2)

squeeze() / expand_dims()
# squeeze : supprime les dimensions de taille 1
a = [Link]([[[1], [2], [3]]]) # shape (1, 3, 1)
b = [Link](a) # shape (3,)
 # expand_dims : ajoute une dimension
a = [Link]([1, 2, 3]) # shape (3,)
b = np.expand_dims(a, 0) # shape (1, 3)
c = np.expand_dims(a, 1) # shape (3, 1)

# Utile pour le broadcasting

a = [Link]([1, 2, 3]) # shape (3,)
b = np.expand_dims(a, 0) # shape (1, 3)
c = np.expand_dims(a, 1) # shape (3, 1)
print(b + c)
# [[2 3 4]
# [3 4 5]
# [4 5 6]]

concatenate() / stack() / hstack() / vstack()

a = [Link]([[1, 2], [3, 4]])
b = [Link]([[5, 6], [7, 8]])

# concatenate : fusionne le long d'un axe existant

[Link]([a, b], axis=0)
# [[1 2] <- axe 0 : ajoute des lignes
# [3 4]
# [5 6]
# [7 8]]

[Link]([a, b], axis=1)

# [[1 2 5 6] <- axe 1 : ajoute des colonnes
# [3 4 7 8]]

# vstack : empile verticalement (axe 0)

[Link]([a, b]) # identique à concatenate axis=0

# hstack : empile horizontalement (axe 1)

[Link]([a, b]) # identique à concatenate axis=1

# stack : crée un NOUVEL axe

[Link]([a, b], axis=0) # shape (2, 2, 2)
[Link]([a, b], axis=1) # shape (2, 2, 2)

split() / hsplit() / vsplit()

a = [Link](12).reshape(3, 4)
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]

# split : divise en parties égales (axe 0 par défaut)

parts = [Link](a, 3, axis=0) # 3 tableaux (1, 4)
# vsplit : coupe verticalement (en lignes)
top, bottom = [Link](a, [2]) # 2 premières lignes + reste

# hsplit : coupe horizontalement (en colonnes)

left, right = [Link](a, 2) # 2 colonnes + 2 colonnes
4. Indexation et sélection

Indexation de base et slicing

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

# Indexation simple
a[0] # 10 (premier élément)
a[-1] # 50 (dernier élément)
a[-2] # 40

# Slicing [début:fin:pas]
a[1:4] # [20 30 40]
a[::2] # [10 30 50] (un sur deux)
a[::-1] # [50 40 30 20 10] (inverser)

# Tableaux 2D
m = [Link](9).reshape(3, 3)
# [[0 1 2]
# [3 4 5]
# [6 7 8]]

m[1, 2] # 5 (ligne 1, colonne 2)

m[0, :] # [0 1 2] (toute la ligne 0)
m[:, 1] # [1 4 7] (toute la colonne 1)
m[1:, 1:] # [[4 5] [7 8]] (sous-matrice)

Indexation booléenne (masquage)

Permet de sélectionner des éléments selon une condition — très puissant !
a = [Link]([3, -1, 5, -2, 8, -4, 7])

# Créer un masque booléen

masque = a > 0
# [ True False True False True False True]

# Appliquer le masque
a[masque] # [3 5 8 7]

# Raccourci direct
a[a > 0] # [3 5 8 7]

# Conditions combinées
a[(a > 0) & (a < 6)] # [3 5]
a[(a < 0) | (a > 6)] # [-1 -2 8 -4 7]

# Modifier les éléments filtrés

a[a < 0] = 0
# [3 0 5 0 8 0 7]
where() / nonzero() / argwhere()
a = [Link]([1, -2, 3, -4, 5])

# where : choisir entre deux valeurs selon condition

[Link](a > 0, a, 0)
# [1 0 3 0 5] (remplace négatifs par 0)

[Link](a > 0, a, -a) # valeur absolue !

# [1 2 3 4 5]

# nonzero : indices des éléments non nuls

a = [Link]([0, 1, 0, 3, 0, 5])
[Link](a) # (array([1, 3, 5]),)

# argwhere : indices sous forme de tableau

[Link](a > 0)
# [[1]
# [3]
# [5]]

tile() / repeat() / roll()

# tile : répète le tableau en tuile
a = [Link]([1, 2, 3])
[Link](a, 3) # [1 2 3 1 2 3 1 2 3]
[Link](a, (2, 3)) # [[1 2 3 1 2 3 1 2 3]
# [1 2 3 1 2 3 1 2 3]]

# repeat : répète chaque élément

[Link](a, 3) # [1 1 1 2 2 2 3 3 3]
[Link](a, [1,2,3]) # [1 2 2 3 3 3]

# roll : décale circulairement

[Link](a, 1) # [3 1 2] (décale droite de 1)
[Link](a, -1) # [2 3 1] (décale gauche de 1)
5. Opérations mathématiques

Opérations élément par élément

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

# Opérateurs standards : élément par élément

a + b # [11 22 33 44]
a * b # [10 40 90 160]
a / b # [0.1 0.1 0.1 0.1]
a ** 2 # [ 1 4 9 16]
b % 3 # [1 2 0 1]

# Fonctions ufunc équivalentes

[Link](a, b) # [11 22 33 44]
[Link](a, b) # [10 40 90 160]
[Link](a, 2) # [ 1 4 9 16]
[Link](b, 3) # [1 2 0 1]

Info : Le broadcasting permet les opérations entre tableaux de formes différentes compatibles.

Broadcasting
NumPy peut opérer sur des tableaux de formes différentes si elles sont compatibles. Les règles :
deux dimensions sont compatibles si elles sont égales, ou si l'une d'elles est 1.
# Scalaire et tableau : scalaire broadcasté sur tout le tableau
a = [Link]([1, 2, 3])
a * 3 # [3 6 9]

# Vecteur ligne + vecteur colonne -> matrice

ligne = [Link]([[1, 2, 3]]) # shape (1, 3)
colonne = [Link]([[1], [2], [3]])# shape (3, 1)
ligne + colonne
# [[2 3 4]
# [3 4 5]
# [4 5 6]]

# Ajouter 10 à chaque ligne

m = [Link]((3, 4))
row_add = [Link]([1, 2, 3, 4]) # shape (4,)
m + row_add
# [[2. 3. 4. 5.]
# [2. 3. 4. 5.]
# [2. 3. 4. 5.]]

Fonctions mathématiques universelles (ufunc)

a = [Link]([0.25, 4.0, 9.0, 16.0])
 # Racine carrée, carré, puissance
[Link](a) # [0.5 2. 3. 4. ]
[Link](a) # [ 0.0625 16. 81. 256.]
[Link](a) # racine cubique

# Exponentielle et logarithme
a = [Link]([1, np.e, np.e**2])
[Link](a) # [ 2.718 7.389 54.60] (e^a)
[Link](a) # [0. 1. 2.] (ln)
np.log2(a) # [0. 1.443 2.886] (log2)
np.log10(a) # [0. 0.434 0.868] (log10)

# Valeurs absolues et arrondi

b = [Link]([-2.7, -1.5, 0.3, 1.7])
[Link](b) # [2.7 1.5 0.3 1.7]
[Link](b) # [-2. -1. 1. 2.] (plafond)
[Link](b) # [-3. -2. 0. 1.] (plancher)
[Link](b) # [-3. -2. 0. 2.] (arrondi)
[Link](b) # [-2. -1. 0. 1.] (troncature)
[Link](b) # [-1. -1. 1. 1.] (signe)

Produits matriciels
a = [Link]([[1, 2], [3, 4]])
b = [Link]([[5, 6], [7, 8]])

# dot : produit scalaire ou matriciel

[Link](a, b)
# [[19 22]
# [43 50]]

# matmul (ou @) : multiplication matricielle

a @ b # identique à dot pour les matrices 2D

# inner : produit intérieur

[Link]([1, 2, 3], [4, 5, 6]) # 32 = 1*4+2*5+3*6

# outer : produit extérieur -> matrice

[Link]([1, 2, 3], [4, 5])
# [[ 4 5]
# [ 8 10]
# [12 15]]

# cross : produit vectoriel

[Link]([1, 0, 0], [0, 1, 0]) # [0 0 1]

# einsum : notation d'Einstein (très flexible)

[Link]("ij,jk->ik", a, b) # produit matriciel
[Link]("ii", a) # trace = 1+4 = 5
6. Fonctions trigonométriques

Fonctions de base
angles = [Link]([0, [Link]/6, [Link]/4, [Link]/3, [Link]/2])

# Les fonctions travaillent en radians

[Link](angles)
# [0. 0.5 0.707 0.866 1. ]

[Link](angles)
# [1. 0.866 0.707 0.5 0. ]

[Link]([Link]([0, [Link]/4, [Link]/3]))

# [0. 1. 1.732]

# Fonctions inverses
[Link]([0, 0.5, 1]) # [0. 0.524 1.571]
[Link]([1, 0.5, 0]) # [0. 1.047 1.571]
[Link]([0, 1, 1000]) # [0. 0.785 1.570]

# arctan2 : angle dans le bon quadrant

np.arctan2(1, 1) # 0.785 (= pi/4, Q1)
np.arctan2(1, -1) # 2.356 (= 3pi/4, Q2)
np.arctan2(-1, -1) # -2.356 (Q3)

Conversion degrés / radians

# Degrés -> radians
[Link](180) # 3.14159...
np.deg2rad(90) # 1.5707...
np.deg2rad([0, 90, 180, 270, 360])
# [0. 1.571 3.142 4.712 6.283]

# Radians -> degrés

[Link]([Link]) # 180.0
np.rad2deg([Link] / 4) # 45.0

# Hypoténuse
[Link](3, 4) # 5.0 (sqrt(3^2 + 4^2))
[Link]([Link]([3, 5]), [Link]([4, 12]))
# [ 5. 13.]

Fonctions hyperboliques
x = [Link]([0, 0.5, 1, 2])

[Link](x) # [0. 0.521 1.175 3.627]

[Link](x) # [1. 1.128 1.543 3.762]
[Link](x) # [0. 0.462 0.762 0.964]
# Inverses
[Link]([0, 1, 3.627]) # [0. 0.881 2. ]
[Link]([1, 1.543, 3]) # [0. 1. 1.763]
[Link]([0, 0.5, 0.9]) # [0. 0.549 1.472]
7. Statistiques et agrégations

Fonctions de base
a = [Link]([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])

# Globales (sur tout le tableau)

[Link](a) # 45
[Link](a) # 1
[Link](a) # 9
[Link](a) # 5.0
[Link](a) # 2.581...
[Link](a) # 6.666...

# Avec axis : 0=colonnes (vertical), 1=lignes (horizontal)

[Link](a, axis=0) # [12 15 18] somme par colonne
[Link](a, axis=1) # [ 6 15 24] somme par ligne

[Link](a, axis=0) # [4. 5. 6.]

[Link](a, axis=1) # [3 6 9]

Médianes, percentiles et quantiles

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

# Médiane
[Link](a) # 4.0

# Percentiles
[Link](a, 25) # 2.0 (Q1)
[Link](a, 50) # 4.0 (Q2 = médiane)
[Link](a, 75) # 5.0 (Q3)
[Link](a, [0, 25, 50, 75, 100])
# [1. 2. 4. 5. 9.]

# Quantiles (même chose, échelle 0-1)

[Link](a, 0.25) # 2.0
[Link](a, [0.1, 0.5, 0.9]) # [1. 4. 6.4]

# Moyenne pondérée
valeurs = [Link]([1, 2, 3, 4])
poids = [Link]([0.1, 0.2, 0.3, 0.4])
[Link](valeurs, weights=poids) # 3.0

Sommes et produits cumulés

a = [Link]([1, 2, 3, 4, 5])
 # Somme cumulée
[Link](a) # [ 1 3 6 10 15]

# Produit cumulé
[Link](a) # [ 1 2 6 24 120]

# Sur une matrice par axe

m = [Link]([[1, 2], [3, 4]])
[Link](m, axis=0) # [[1 2] [4 6]] (par colonne)
[Link](m, axis=1) # [[1 3] [3 7]] (par ligne)

Fonctions nan-safe (ignorent les NaN)

a = [Link]([1, 2, [Link], 4, 5])

# Fonctions normales : NaN contamine le résultat

[Link](a) # nan
[Link](a) # nan

# Fonctions nan-safe : ignorent les NaN

[Link](a) # 12.0
[Link](a) # 3.0
[Link](a) # 3.0
[Link](a) # 1.479...
[Link](a) # 1.0
[Link](a) # 5.0

Astuce : Utilisez toujours les versions nan* quand vos données peuvent contenir des valeurs manquantes.
8. Tri et recherche

sort() / argsort() / lexsort()

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

# sort : trie et retourne une copie

[Link](a) # [1 1 2 3 4 5 6 9]

# [Link]() : trie EN PLACE (modifie a)

[Link]()

# argsort : retourne les indices de tri

a = [Link]([30, 10, 20])
idx = [Link](a) # [1 2 0]
a[idx] # [10 20 30]

# Tri décroissant
[Link](a)[::-1] # [30 20 10]
[Link](a)[::-1] # [0 2 1]

# lexsort : tri multi-clés (dernier = clé principale)

noms = [Link](["Alice", "Bob", "Alice", "Bob"])
notes = [Link]([85, 90, 75, 88])
idx = [Link]((notes, noms))
# Tri par nom, puis par note

argmin() / argmax() / searchsorted()

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

# argmin / argmax : indice du min/max

[Link](a) # 1 (valeur 1)
[Link](a) # 5 (valeur 9)

# Sur une matrice, avec axis

m = [Link]([[3, 5], [1, 8], [7, 2]])
[Link](m, axis=0) # [1 2] min de chaque colonne
[Link](m, axis=1) # [1 1 0] max de chaque ligne

# searchsorted : où insérer pour garder le tri

a = [Link]([1, 3, 5, 7, 9])
[Link](a, 4) # 2 (insérer entre 3 et 5)
[Link](a, [2, 6, 8]) # [1 3 4]

unique() / partition()
# unique : valeurs uniques
a = [Link]([3, 1, 2, 1, 3, 3, 2])
[Link](a) # [1 2 3]
# Avec options utiles
vals, idx = [Link](a, return_index=True)
# vals = [1 2 3], idx = indices première apparition

vals, counts = [Link](a, return_counts=True)

# vals = [1 2 3], counts = [2 2 3]

# partition : les k plus petits à gauche

a = [Link]([7, 3, 5, 1, 9, 4])
[Link](a, 3)
# [1 3 4 7 9 5] les 3 plus petits sont à gauche
# (ordre non garanti dans chaque groupe)
9. Opérations sur les tableaux

clip() / ptp() / abs()

a = [Link]([-3, -1, 0, 2, 5, 10])

# clip : écrête entre min et max

[Link](a, 0, 5) # [0 0 0 2 5 5]
[Link](a, -2, 4) # [-2 -1 0 2 4 4]

# ptp : plage = max - min

[Link](a) # 13 (10 - (-3))

# abs : valeur absolue

[Link](a) # [3 1 0 2 5 10]

# Combinaison courante : normalisation

a = [Link]([2.0, 4.0, 6.0, 8.0])
a_norm = (a - [Link]()) / ([Link]() - [Link]())
# [0. 0.333 0.667 1. ]

delete() / insert() / append() / resize()

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

# delete : supprime des éléments

[Link](a, 2) # [10 20 40 50] (supprime index 2)
[Link](a, [1, 3]) # [10 30 50] (supprime plusieurs)

# insert : insère des valeurs

[Link](a, 2, 99) # [10 20 99 30 40 50]
[Link](a, [1, 3], 0) # [10 0 20 30 0 40 50]

# append : ajoute à la fin (retourne une copie)

[Link](a, [60, 70]) # [10 20 30 40 50 60 70]

# resize : redimensionne (peut tronquer ou répéter)

[Link](a, (2, 4))
# [[10 20 30 40]
# [50 10 20 30]] <- répète si trop petit

flip() / fliplr() / flipud() / rot90()

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

# flipud : retourne verticalement (haut-bas)

[Link](m)
# [[4 5 6]
# [1 2 3]]
# fliplr : retourne horizontalement (gauche-droite)
[Link](m)
# [[3 2 1]
# [6 5 4]]

# flip : inverse selon un axe (ou tous)

[Link](m, axis=0) # identique à flipud
[Link](m, axis=1) # identique à fliplr

# rot90 : rotation de 90 degrés

np.rot90(m)
# [[3 6]
# [2 5]
# [1 4]]

np.rot90(m, k=2) # rotation 180 degrés

np.rot90(m, k=3) # rotation 270 degrés
10. Nombres complexes

Création et propriétés
# Créer des nombres complexes
a = [Link]([1+2j, 3-4j, -1+0j])

# Partie réelle et imaginaire

[Link](a) # [ 1. 3. -1.]
[Link](a) # [ 2. -4. 0.]

# Conjugué
[Link](a) # [ 1.-2.j 3.+4.j -1.-0.j]

# Module (valeur absolue)

[Link](a) # [2.236 5. 1. ]

# Angle (argument)
[Link](a)
# [ 1.107 -0.927 3.142] en radians
[Link](a, deg=True)
# [ 63.43 -53.13 180. ] en degrés

11. Logique booléenne

all() / any() / isnan() / isfinite()

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

# all : tous les éléments sont vrais ?

[Link](a > 0) # True
[Link](a > 2) # False

# any : au moins un élément est vrai ?

[Link](a > 4) # True
[Link](a > 10) # False

# Avec axis
m = [Link]([[1, 0], [2, 3]])
[Link](m > 0, axis=0) # [True False]
[Link](m > 0, axis=1) # [True True]

# Détection de NaN et infinis

b = [Link]([1, [Link], [Link], -[Link], 0])
[Link](b) # [F T F F F]
[Link](b) # [F F T T F]
[Link](b) # [T F F F T]
[Link](b) # [F F T F F]
 [Link](b) # [F F F T F]

Comparaisons entre tableaux

a = [Link]([1.0, 2.0, 3.0])
b = [Link]([1.0, 2.001, 3.1])

# array_equal : vérifie égalité exacte

np.array_equal(a, a) # True
np.array_equal(a, b) # False

# allclose : vérifie égalité approchée

[Link](a, b, rtol=1e-2) # True (tolérance 1%)
[Link](a, b, atol=0.01) # True (tolérance abs)

# isclose : comparaison élément par élément

[Link](a, b, atol=0.01)
# [ True True False]
12. Sauvegarde et chargement

Formats binaires NumPy (.npy, .npz)

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

# Sauvegarder un seul tableau (.npy)

[Link]("[Link]", a)

# Charger
b = [Link]("[Link]")

# Sauvegarder plusieurs tableaux (.npz)

x = [Link](0, 10, 100)
y = [Link](x)
[Link]("[Link]", x=x, y=y)

# Charger un .npz
data = [Link]("[Link]")
x2 = data["x"]
y2 = data["y"]

# Version compressée (fichier plus petit)

np.savez_compressed("donnees_comp.npz", x=x, y=y)

Fichiers texte (.txt, .csv)

# Sauvegarder en texte
a = [Link]([[1.1, 2.2], [3.3, 4.4]])
[Link]("[Link]", a)
[Link]("[Link]", a, delimiter=",",
header="col1,col2", fmt="%.2f")

# Charger depuis un fichier texte

b = [Link]("[Link]")
c = [Link]("[Link]", delimiter=",", skiprows=1)

# genfromtxt : plus robuste, gère les valeurs manquantes

d = [Link]("[Link]", delimiter=",",
names=True, dtype=None)
# Valeurs manquantes remplacées par [Link] automatiquement

Attention : [Link]() échoue sur les fichiers avec des données manquantes. Utilisez [Link]() dans
ce cas.

Référence rapide — Constantes utiles

Constante Valeur Description
[Link] 3.14159... Pi

np.e 2.71828... Nombre d'Euler

[Link] inf Infini positif

[Link] nan Not a Number

np.euler_gamma 0.5772... Constante d'Euler-Mascheroni

Guide NumPy Core — Toutes les fonctions avec exemples explicatifs