Improving numpy Save Performance After Indexing Using ascontiguousarray()

Описание: Learn how to speed up saving numpy arrays after advanced indexing by using numpy's ascontiguousarray() for optimized memory layout.
---
This video is based on the question https://stackoverflow.com/q/79141089/ asked by the user 'cozeybozey' ( https://stackoverflow.com/u/28055648/ ) and on the answer https://stackoverflow.com/a/79141407/ provided by the user 'Ahmed' ( https://stackoverflow.com/u/4742618/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Saving numpy array after indexing is much slower

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to drop me a comment under this video.
---
Why Saving Indexed NumPy Arrays Can Be Slow

When you save a NumPy array after slicing or advanced indexing, you might notice a significant slowdown compared to saving the original array. This happens because the indexed array might not be stored in a contiguous block of memory, which negatively affects I/O operations.

For example, slicing an array like array2 = array[:, :, [0,1,2,3,4,5]] returns a view with an advanced indexing pattern. Even if np.array_equal(array, array2) returns True, their memory layouts differ.

Understanding Contiguous Memory Layout

NumPy arrays can be stored in memory either:

Contiguously: Data elements are stored one after another in memory.

Non-contiguously: Data elements are scattered or accessed via strides.

Contiguous arrays enable faster reading/writing because the data block is continuous, which I/O operations favor.

How to Fix Slow Saving: Use np.ascontiguousarray()

You can convert your indexed array into a contiguous array using:

[[See Video to Reveal this Text or Code Snippet]]

This creates a copy (if necessary) with a contiguous memory layout, improving save performance.

Demonstration

[[See Video to Reveal this Text or Code Snippet]]

Typical results show the contiguous version saving significantly faster than the non-contiguous slice:

No indexing: ~3s

With indexing (non-contiguous): ~10s

With indexing (contiguous copy): ~6.5s

Summary

Indexed arrays using advanced slicing may have a non-contiguous memory layout.

Non-contiguous arrays slow down saving operations.

Use np.ascontiguousarray() to ensure a contiguous memory layout and improve save performance.

This small step can greatly optimize saving large indexed numpy arrays without changing their content.