Memory Layout in NumPy
Views vs Copies

Understanding Memory Layout in NumPy

When working with NumPy arrays, it's easy to assume that any transformation or slice results in a new array. But that's not always true. NumPy is highly optimized for performance, and one of its clever strategies is memory sharing through views.

Knowing whether you're working with a view or a copy can be the difference between blazing speed and sneaky bugs.

What Is a View?

A view in NumPy is simply a different way of looking at the same data. When you slice an array, NumPy doesn't duplicate the data. Instead, it creates a new array object that references the same memory.

import numpy as np

a = np.array([10, 20, 30, 40])
b = a[1:3]  # This is a view of 'a'
b[0] = 99
print(a)  # Output: [10 99 30 40]

Explanation

We sliced array a and assigned it to b. When we updated b[0], the change was reflected in a. That's because b is just a view into the original data.

What Is a Copy?

A copy duplicates the data and creates a new block of memory. Changes to a copy do not affect the original array.

a = np.array([10, 20, 30, 40])
c = a[1:3].copy()  # This is a true copy
c[0] = 99
print(a)  # Output: [10 20 30 40]
print(c)  # Output: [99 30]

Explanation

This time, even though we sliced a, we explicitly used .copy(). So c has its own memory. Changing c has no impact on a.

How to Check If It's a View or a Copy?

You can verify whether two arrays share memory using np.shares_memory().

np.shares_memory(a, b)  # True (view)
np.shares_memory(a, c)  # False (copy)

Why It Matters for Performance

Views are memory-efficient and fast since they avoid copying large data. However, they come with a caveat: unexpected side effects.

Use Case: Avoiding Hidden Mutations

a = np.arange(10)
b = a[::2]  # view every other element
b[:] = -1
print(a)  # Output: [-1  1 -1  3 -1  5 -1  7 -1  9]

This mutation might be unintended. If you didn't know b is a view, this could create subtle, hard-to-find bugs in your logic.

Guidelines to Follow

• When performance matters, use views to avoid data duplication.
• When data integrity matters, create a copy explicitly.
• Always document or comment whether your array is a view or a copy.
• Use np.shares_memory() to debug side-effects between arrays.

Common Pitfall: Chained Indexing

Chaining slices may return unpredictable results because you're layering views. Always assign intermediate steps to variables for clarity and control.

# Bad: confusing and error-prone
np.array([1, 2, 3, 4, 5])[1:4][1] = 99  # Might not do what you expect

# Good: clear and safe
a = np.array([1, 2, 3, 4, 5])
b = a[1:4].copy()
b[1] = 99

Summary

Understanding the difference between views and copies is essential when working with NumPy. It empowers you to write high-performance code, prevent data corruption, and debug your logic effectively. Use views for speed, but reach for copies when clarity and safety are non-negotiable.