Eric Campbell 6 min read Python

How to Pad Arrays in NumPy

Array padding adds extra values around the edges of your data. You'll encounter it constantly in numerical computing: convolution operations need padded inputs to handle boundaries, neural networks...

Key Insights

  • NumPy’s np.pad() function offers seven padding modes, but constant, edge, and reflect cover 90% of real-world use cases
  • The pad_width parameter syntax is confusing at first—think of it as ((before_axis0, after_axis0), (before_axis1, after_axis1)) for 2D arrays
  • For performance-critical code with simple constant padding, manual array allocation and slicing can be 2-3x faster than np.pad()

Introduction to Array Padding

Array padding adds extra values around the edges of your data. You’ll encounter it constantly in numerical computing: convolution operations need padded inputs to handle boundaries, neural networks require fixed-size inputs, and signal processing algorithms often assume periodic or reflected boundaries.

NumPy provides np.pad() as the standard tool for this job. It’s flexible enough to handle everything from simple zero-padding to complex reflection modes, but that flexibility comes with a learning curve. The function signature looks intimidating at first:

np.pad(array, pad_width, mode='constant', **kwargs)

Let’s break it down piece by piece.

Basic Padding with Constant Values

The most common padding operation fills edges with a constant value—usually zero. Here’s how it works with 1D arrays:

import numpy as np

# Original 1D array
arr = np.array([1, 2, 3, 4, 5])

# Pad with 2 zeros on each side
padded = np.pad(arr, pad_width=2, mode='constant', constant_values=0)
print(padded)
# Output: [0 0 1 2 3 4 5 0 0]

For 2D arrays, the same principle applies. The padding extends in all directions:

# Original 2D array
matrix = np.array([[1, 2], 
                   [3, 4]])

# Pad with 1 element on all sides, using -1 as the fill value
padded = np.pad(matrix, pad_width=1, mode='constant', constant_values=-1)
print(padded)
# Output:
# [[-1 -1 -1 -1]
#  [-1  1  2 -1]
#  [-1  3  4 -1]
#  [-1 -1 -1 -1]]

When you omit constant_values, NumPy defaults to zero. This is what you want most of the time for image processing and convolution operations.

Understanding Pad Width Syntax

The pad_width parameter accepts three formats, and choosing the right one saves you from writing verbose code.

Single integer: Pads all axes equally on both sides.

arr = np.array([1, 2, 3])

# pad_width=2 means: 2 elements before AND 2 elements after
result = np.pad(arr, pad_width=2, mode='constant')
print(result)
# Output: [0 0 1 2 3 0 0]

Tuple of two integers: Different padding before and after, applied to all axes.

arr = np.array([1, 2, 3])

# (1, 3) means: 1 element before, 3 elements after
result = np.pad(arr, pad_width=(1, 3), mode='constant')
print(result)
# Output: [0 1 2 3 0 0 0]

Nested tuples: Full control over each axis independently. This is where things get powerful.

matrix = np.array([[1, 2],
                   [3, 4]])

# ((1, 2), (3, 4)) means:
# - Axis 0 (rows): 1 row before, 2 rows after
# - Axis 1 (cols): 3 cols before, 4 cols after
result = np.pad(matrix, pad_width=((1, 2), (3, 4)), mode='constant')
print(result)
print(f"Shape: {result.shape}")
# Output:
# [[0 0 0 1 2 0 0 0 0]
#  [0 0 0 3 4 0 0 0 0]
#  [0 0 0 0 0 0 0 0 0]
#  [0 0 0 0 0 0 0 0 0]]
# Shape: (4, 9)

The nested tuple format follows the pattern ((before_axis0, after_axis0), (before_axis1, after_axis1), ...). For images stored as (height, width, channels), you’d use three inner tuples.

Edge and Wrap Padding Modes

Constant padding works for many cases, but sometimes you need the padded values to relate to your actual data.

Edge mode repeats the boundary values outward:

arr = np.array([1, 2, 3, 4, 5])

edge_padded = np.pad(arr, pad_width=3, mode='edge')
print(f"Edge:  {edge_padded}")
# Output: Edge:  [1 1 1 1 2 3 4 5 5 5 5]

Wrap mode treats the array as circular, connecting the end back to the beginning:

arr = np.array([1, 2, 3, 4, 5])

wrap_padded = np.pad(arr, pad_width=3, mode='wrap')
print(f"Wrap:  {wrap_padded}")
# Output: Wrap:  [3 4 5 1 2 3 4 5 1 2 3]

Here’s a 2D comparison that makes the difference clearer:

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

print("Original:")
print(matrix)

print("\nEdge padded:")
print(np.pad(matrix, pad_width=1, mode='edge'))
# Corners repeat the corner values

print("\nWrap padded:")
print(np.pad(matrix, pad_width=1, mode='wrap'))
# Wraps around like a torus

Output:

Original:
[[1 2 3]
 [4 5 6]
 [7 8 9]]

Edge padded:
[[1 1 2 3 3]
 [1 1 2 3 3]
 [4 4 5 6 6]
 [7 7 8 9 9]
 [7 7 8 9 9]]

Wrap padded:
[[9 7 8 9 7]
 [3 1 2 3 1]
 [6 4 5 6 4]
 [9 7 8 9 7]
 [3 1 2 3 1]]

Use edge mode when you want smooth transitions at boundaries. Use wrap mode for periodic data like angles or cyclic time series.

Reflective Padding

NumPy offers two reflection modes that look similar but behave differently at the boundary.

reflect mode mirrors the array without repeating the edge value:

arr = np.array([1, 2, 3, 4, 5])

reflect_padded = np.pad(arr, pad_width=4, mode='reflect')
print(f"Reflect:   {reflect_padded}")
# Output: Reflect:   [5 4 3 2 1 2 3 4 5 4 3 2 1]

symmetric mode mirrors the array and includes the edge value:

arr = np.array([1, 2, 3, 4, 5])

symmetric_padded = np.pad(arr, pad_width=4, mode='symmetric')
print(f"Symmetric: {symmetric_padded}")
# Output: Symmetric: [4 3 2 1 1 2 3 4 5 5 4 3 2]

Notice how reflect skips the boundary value (no repeated 1 or 5), while symmetric includes it (the 1 and 5 appear twice at the boundaries).

For image processing, reflect is usually preferred because it avoids the visual artifacts that repeated edge pixels can create. Here’s a 2D example:

img = np.array([[10, 20, 30],
                [40, 50, 60],
                [70, 80, 90]])

print("Reflect mode:")
print(np.pad(img, pad_width=1, mode='reflect'))

print("\nSymmetric mode:")
print(np.pad(img, pad_width=1, mode='symmetric'))

Output:

Reflect mode:
[[50 40 50 60 50]
 [20 10 20 30 20]
 [50 40 50 60 50]
 [80 70 80 90 80]
 [50 40 50 60 50]]

Symmetric mode:
[[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]]

Practical Applications

Preparing Images for Convolution

When applying a convolution kernel to an image, you need to handle the edges. Without padding, your output shrinks. Here’s how to pad for a 3x3 kernel:

def convolve_2d_with_padding(image, kernel):
    """Apply 2D convolution with reflect padding to preserve size."""
    kh, kw = kernel.shape
    pad_h, pad_w = kh // 2, kw // 2
    
    # Pad the image
    padded = np.pad(image, pad_width=((pad_h, pad_h), (pad_w, pad_w)), 
                    mode='reflect')
    
    # Simple convolution (not optimized)
    output = np.zeros_like(image, dtype=np.float64)
    for i in range(image.shape[0]):
        for j in range(image.shape[1]):
            output[i, j] = np.sum(padded[i:i+kh, j:j+kw] * kernel)
    
    return output

# Example: edge detection kernel
image = np.random.rand(5, 5)
sobel_x = np.array([[-1, 0, 1],
                    [-2, 0, 2],
                    [-1, 0, 1]])

result = convolve_2d_with_padding(image, sobel_x)
print(f"Input shape: {image.shape}, Output shape: {result.shape}")
# Output: Input shape: (5, 5), Output shape: (5, 5)

Aligning Arrays of Different Sizes

When you need to stack or compare arrays of different sizes, padding brings them to a common shape:

def pad_to_match(arrays):
    """Pad all arrays to match the largest dimensions."""
    max_shape = np.max([arr.shape for arr in arrays], axis=0)
    
    padded = []
    for arr in arrays:
        pad_width = [(0, max_dim - curr_dim) 
                     for curr_dim, max_dim in zip(arr.shape, max_shape)]
        padded.append(np.pad(arr, pad_width, mode='constant'))
    
    return np.stack(padded)

# Arrays of different sizes
a = np.ones((2, 3))
b = np.ones((4, 2))
c = np.ones((3, 5))

stacked = pad_to_match([a, b, c])
print(f"Stacked shape: {stacked.shape}")
# Output: Stacked shape: (3, 4, 5)

Performance Tips and Alternatives

np.pad() is convenient but not always the fastest option. For simple constant padding, manual allocation can be significantly faster:

import time

def manual_pad_constant(arr, pad_width, value=0):
    """Manually pad with constant value (2D only)."""
    py, px = pad_width, pad_width
    new_shape = (arr.shape[0] + 2*py, arr.shape[1] + 2*px)
    result = np.full(new_shape, value, dtype=arr.dtype)
    result[py:-py, px:-px] = arr
    return result

# Benchmark
large_array = np.random.rand(1000, 1000)

start = time.perf_counter()
for _ in range(100):
    _ = np.pad(large_array, pad_width=10, mode='constant')
numpy_time = time.perf_counter() - start

start = time.perf_counter()
for _ in range(100):
    _ = manual_pad_constant(large_array, pad_width=10)
manual_time = time.perf_counter() - start

print(f"np.pad():     {numpy_time:.3f}s")
print(f"Manual:       {manual_time:.3f}s")
print(f"Speedup:      {numpy_time/manual_time:.1f}x")

Typical output:

np.pad():     0.847s
Manual:       0.312s
Speedup:      2.7x

The performance gap narrows for complex padding modes like reflect, where np.pad() is well-optimized. Use manual padding only when you’re doing constant padding in a tight loop and profiling shows it matters.

For memory-constrained situations, remember that np.pad() always creates a copy. If you’re working with very large arrays and only need padded access occasionally, consider using index manipulation instead of actually padding the data.

Liked this? There's more.

Every week: one practical technique, explained simply, with code you can use immediately.

Similar Articles