np.pad, aussi appelé numpy.pad, sert à ajouter une bordure autour d’un tableau NumPy. Cette bordure peut contenir des zéros, une valeur constante, une copie des bords, un reflet du tableau, une répétition circulaire ou encore des valeurs calculées à partir des données.
C’est une fonction très utile dès que l’on manipule des tableaux, des images, des signaux, des matrices ou des données préparées pour un modèle de machine learning.
import numpy as np
tableau = np.array([1, 2, 3])
resultat = np.pad(tableau, pad_width=2)
print(resultat)
Résultat :
[0 0 1 2 3 0 0]
Par défaut, np.pad ajoute des zéros autour du tableau. Le paramètre le plus important est pad_width, car il indique combien de valeurs ajouter avant et après chaque dimension.
La réponse courte
Pour ajouter du padding à un tableau NumPy, utilisez :
np.pad(array, pad_width, mode="constant")
Exemple simple :
import numpy as np
a = np.array([1, 2, 3])
print(np.pad(a, 1))
Résultat :
[0 1 2 3 0]
Avec une valeur personnalisée :
print(np.pad(a, 1, mode="constant", constant_values=9))
Résultat :
[9 1 2 3 9]
Pour un tableau 2D :
matrice = np.array([
[1, 2],
[3, 4],
])
print(np.pad(matrice, pad_width=1))
Résultat :
[[0 0 0 0]
[0 1 2 0]
[0 3 4 0]
[0 0 0 0]]
À quoi sert np.pad ?
Le padding consiste à agrandir un tableau en ajoutant des valeurs autour de ses bords.
Dans un tableau 1D, cela revient à ajouter des valeurs avant et après :
[1, 2, 3]
devient par exemple :
[0, 0, 1, 2, 3, 0, 0]
Dans un tableau 2D, cela revient à ajouter une bordure autour d’une matrice :
[[1, 2],
[3, 4]]
devient :
[[0, 0, 0, 0],
[0, 1, 2, 0],
[0, 3, 4, 0],
[0, 0, 0, 0]]
Ce mécanisme est fréquent pour :
- préparer une image avant une convolution ;
- garder la même taille après un filtre ;
- aligner des séquences ;
- ajouter une marge autour d’une matrice ;
- compléter des données jusqu’à une taille attendue ;
- éviter certains problèmes aux bords d’un tableau.
Comprendre pad_width
pad_width indique combien d’éléments ajouter autour du tableau.
Avec un entier, NumPy ajoute le même nombre de valeurs de chaque côté.
a = np.array([1, 2, 3])
print(np.pad(a, 2))
Résultat :
[0 0 1 2 3 0 0]
Avec un tuple, on peut préciser séparément le padding avant et après.
print(np.pad(a, (1, 3)))
Résultat :
[0 1 2 3 0 0 0]
Ici, NumPy ajoute :
1valeur avant le tableau ;3valeurs après le tableau.
pad_width avec un tableau 2D
Sur un tableau 2D, il faut raisonner par axe :
- axe
0: lignes ; - axe
1: colonnes.
matrice = np.array([
[1, 2],
[3, 4],
])
Pour ajouter :
1ligne en haut ;2lignes en bas ;3colonnes à gauche ;1colonne à droite ;
on écrit :
resultat = np.pad(
matrice,
pad_width=((1, 2), (3, 1)),
)
print(resultat)
Résultat :
[[0 0 0 0 0 0]
[0 0 0 1 2 0]
[0 0 0 3 4 0]
[0 0 0 0 0 0]
[0 0 0 0 0 0]]
La structure ((1, 2), (3, 1)) se lit ainsi :
((avant_axe_0, apres_axe_0), (avant_axe_1, apres_axe_1))
C’est souvent le point qui bloque les débutants. Pour un tableau 2D, chaque axe reçoit son propre couple.
Mode constant : ajouter une valeur fixe
Le mode par défaut est constant. Sans précision, NumPy ajoute des zéros.
a = np.array([1, 2, 3])
print(np.pad(a, 2, mode="constant"))
Résultat :
[0 0 1 2 3 0 0]
Pour changer la valeur ajoutée, utilisez constant_values.
print(np.pad(a, 2, mode="constant", constant_values=5))
Résultat :
[5 5 1 2 3 5 5]
On peut aussi utiliser deux valeurs différentes : une avant, une après.
print(np.pad(a, (2, 3), mode="constant", constant_values=(8, 9)))
Résultat :
[8 8 1 2 3 9 9 9]
Ce mode est le plus simple et le plus courant. Il convient lorsque vous voulez ajouter une bordure neutre, une valeur de remplissage ou une marge explicite.
Mode edge : répéter les bords
Le mode edge répète la première et la dernière valeur du tableau.
a = np.array([1, 2, 3])
print(np.pad(a, 2, mode="edge"))
Résultat :
[1 1 1 2 3 3 3]
Ce mode est utile quand vous ne voulez pas introduire de zéro artificiel aux bords. Dans certains traitements d’image ou de signal, répéter la valeur du bord donne un résultat plus naturel qu’une bordure remplie de zéros.
Sur une matrice :
matrice = np.array([
[1, 2],
[3, 4],
])
print(np.pad(matrice, 1, mode="edge"))
Résultat :
[[1 1 2 2]
[1 1 2 2]
[3 3 4 4]
[3 3 4 4]]
Mode reflect : refléter sans répéter le bord
Le mode reflect reflète les valeurs autour du bord, sans répéter la valeur située exactement sur le bord.
a = np.array([1, 2, 3, 4])
print(np.pad(a, 2, mode="reflect"))
Résultat :
[3 2 1 2 3 4 3 2]
Ici, les valeurs proches du bord sont utilisées comme miroir.
Ce mode est fréquent dans des traitements où l’on veut prolonger un signal ou une image sans créer une rupture brutale.
Mode symmetric : refléter en répétant le bord
Le mode symmetric ressemble à reflect, mais il inclut la valeur du bord dans le reflet.
a = np.array([1, 2, 3, 4])
print(np.pad(a, 2, mode="symmetric"))
Résultat :
[2 1 1 2 3 4 4 3]
La différence entre reflect et symmetric est subtile mais importante :
| Mode | Le bord est répété ? |
|---|---|
reflect |
Non |
symmetric |
Oui |
Si votre résultat semble décalé d’une valeur, vérifiez souvent ce choix.
Mode wrap : boucler autour du tableau
Le mode wrap complète le début avec la fin du tableau, et la fin avec le début.
a = np.array([1, 2, 3, 4])
print(np.pad(a, 2, mode="wrap"))
Résultat :
[3 4 1 2 3 4 1 2]
Ce mode est utile quand les données sont cycliques : angles, signaux périodiques, jours de la semaine ou tout autre cas où la fin rejoint le début.
Modes statistiques : maximum, minimum, mean, median
NumPy propose aussi des modes qui remplissent le padding avec une statistique calculée sur le tableau :
maximum;minimum;mean;median.
a = np.array([1, 2, 10])
print(np.pad(a, 2, mode="maximum"))
print(np.pad(a, 2, mode="minimum"))
print(np.pad(a, 2, mode="mean"))
print(np.pad(a, 2, mode="median"))
Ces modes sont moins fréquents que constant, edge, reflect ou wrap, mais ils peuvent être utiles pour certaines préparations de données.
Tableau récapitulatif des modes courants
| Mode | Effet principal | Exemple d’usage |
|---|---|---|
constant |
ajoute une valeur fixe | bordure de zéros, valeur neutre |
edge |
répète les valeurs du bord | image, signal sans rupture forte |
reflect |
reflète sans répéter le bord | traitement d’image, signal |
symmetric |
reflète en répétant le bord | prolongement miroir plus doux |
wrap |
reprend les valeurs de l’autre côté | données cycliques |
maximum |
remplit avec le maximum | padding statistique |
minimum |
remplit avec le minimum | padding statistique |
mean |
remplit avec la moyenne | préparation de données |
median |
remplit avec la médiane | données bruitées |
Dans la plupart des cas, commencez par constant ou edge. Passez à reflect, symmetric ou wrap quand le comportement au bord a une signification particulière.
Exemple pratique : ajouter une bordure à une image
Une image en niveaux de gris peut être représentée par un tableau 2D.
image = np.array([
[10, 20, 30],
[40, 50, 60],
[70, 80, 90],
])
Pour ajouter une bordure de zéros :
bordure_zero = np.pad(image, 1, mode="constant")
print(bordure_zero)
Résultat :
[[ 0 0 0 0 0]
[ 0 10 20 30 0]
[ 0 40 50 60 0]
[ 0 70 80 90 0]
[ 0 0 0 0 0]]
Pour éviter une bordure artificiellement noire, on peut répéter les bords :
bordure_edge = np.pad(image, 1, mode="edge")
print(bordure_edge)
Résultat :
[[10 10 20 30 30]
[10 10 20 30 30]
[40 40 50 60 60]
[70 70 80 90 90]
[70 70 80 90 90]]
Dans un pipeline d’image, ce choix peut changer le résultat d’un filtre ou d’une convolution.
Exemple pratique : compléter une séquence
Supposons que vous ayez une séquence plus courte que la taille attendue.
sequence = np.array([4, 8, 15])
taille_cible = 6
manquant = taille_cible - len(sequence)
completee = np.pad(
sequence,
pad_width=(0, manquant),
mode="constant",
constant_values=0,
)
print(completee)
Résultat :
[ 4 8 15 0 0 0]
Cette logique apparaît souvent quand on aligne des séquences ou quand on prépare des entrées de longueur fixe.
Vérifier la forme avec .shape
Après un padding, vérifiez toujours la forme du tableau.
matrice = np.array([
[1, 2, 3],
[4, 5, 6],
])
resultat = np.pad(matrice, ((1, 1), (2, 2)))
print(matrice.shape)
print(resultat.shape)
Résultat :
(2, 3)
(4, 7)
Pourquoi (4, 7) ?
- lignes :
2 + 1 + 1 = 4; - colonnes :
3 + 2 + 2 = 7.
Cette vérification évite beaucoup d’erreurs dans les pipelines NumPy, image ou machine learning.
Erreurs fréquentes avec np.pad
Confondre les axes
Sur une matrice, pad_width=((1, 2), (3, 4)) ne signifie pas “1 à gauche, 2 à droite, 3 en haut, 4 en bas”.
Cela signifie :
((haut, bas), (gauche, droite))
Autrement dit :
- axe 0 : lignes ;
- axe 1 : colonnes.
Oublier constant_values
Si vous écrivez :
np.pad(a, 2, mode="constant")
NumPy ajoute des zéros. Si vous voulez une autre valeur, il faut préciser :
np.pad(a, 2, mode="constant", constant_values=9)
Utiliser reflect sur un tableau trop petit
Certains modes comme reflect ont besoin d’assez de valeurs pour construire le reflet.
a = np.array([1])
Avec un tableau trop court et un padding trop grand, le comportement peut surprendre ou déclencher une erreur selon le mode et les paramètres. Si votre tableau est très petit, commencez par constant ou edge, puis testez explicitement le résultat.
Croire que le padding modifie le tableau d’origine
np.pad renvoie un nouveau tableau. Il ne modifie pas le tableau original en place.
a = np.array([1, 2, 3])
b = np.pad(a, 1)
print(a) # [1 2 3]
print(b) # [0 1 2 3 0]
Si vous voulez utiliser le tableau paddé, stockez bien le résultat dans une variable.
Quel mode choisir ?
Le bon mode dépend de ce que représente le bord.
| Situation | Mode conseillé |
|---|---|
| Ajouter une bordure neutre | constant |
| Garder la valeur du bord | edge |
| Prolonger un signal sans rupture brutale | reflect ou symmetric |
| Données cycliques | wrap |
| Remplir avec une statistique | mean, median, maximum, minimum |
Si vous ne savez pas quoi choisir, commencez par constant pour comprendre la forme obtenue, puis adaptez le mode selon le sens de vos données.
Mini-exercices
Exercice 1
Prédisez le résultat :
a = np.array([5, 6, 7])
print(np.pad(a, (2, 1), mode="constant", constant_values=0))
Réponse :
[0 0 5 6 7 0]
Exercice 2
Quelle sera la forme du tableau ?
m = np.ones((3, 4))
r = np.pad(m, ((1, 2), (3, 1)))
print(r.shape)
Réponse :
(6, 8)
Explication :
- lignes :
3 + 1 + 2 = 6; - colonnes :
4 + 3 + 1 = 8.
Exercice 3
Comparez edge, reflect et wrap :
a = np.array([1, 2, 3, 4])
print(np.pad(a, 2, mode="edge"))
print(np.pad(a, 2, mode="reflect"))
print(np.pad(a, 2, mode="wrap"))
Le meilleur moyen de comprendre ces modes est souvent de les afficher côte à côte.
Pour aller plus loin
np.pad devient beaucoup plus clair quand vous maîtrisez les formes de tableaux, les axes et le coût des opérations. Vous pouvez compléter ce guide avec :
- la complexité algorithmique en Python, pour mieux comprendre le coût des opérations sur les données ;
- la méthode de Monte Carlo en Python, qui utilise souvent des tableaux NumPy ;
- l’intégration en Python avec la formule de Simpson, où les tableaux et les séquences numériques sont très utiles.
Le réflexe à garder : vérifiez toujours pad_width, le mode choisi et la forme finale avec .shape. Dans la majorité des erreurs avec numpy.pad, le problème vient d’un axe mal interprété ou d’un mode qui ne correspond pas au sens des données.
Références
- Documentation NumPy –
numpy.pad - Documentation NumPy –
ndarray.shape - Documentation NumPy – Création de tableaux
