You can benchmark NumPy array creation functions and discover the fastest approaches to use in different circumstances.

Generally, the numpy.empty() function is faster when an uninitialized array is needed. If an initialized NumPy array is required, then numpy.zeros() or numpy.full() are the fastest.

An important consideration is the data type of the array. A type should be chosen that fits the data the array intends to hold, and is fast to create on the specific system on which the code will be run. Interestingly, it can be faster to create arrays with a larger data type than is needed in some cases.

In this tutorial, you will discover how to benchmark NumPy array creation functions and discover the fastest approaches you can use in your own programs.

Let’s get started.

Need To Create NumPy Arrays Fast

Creating arrays is the most common activity when using NumPy.

As such, we need to know how to create arrays fast.

There are many ways to create new NumPy arrays, although perhaps the main difference between the approaches are:

• 1. Create an empty uninitialized array:
  • numpy.empty()
• 2. Create an array initialized to a given value.
  • numpy.zeros()
  • numpy.ones()
  • numpy.full()
  • numpy.arange()

In this case, we will ignore creating arrays from or like other arrays and creating arrays as the outcome of an algorithm.

Generally, the division may be between creating empty arrays vs an initialized array.

Given that we need to create new arrays all the time in our NumPy program, which approach or approach is fast?

Specific requirements aside, What function should we use when creating new arrays in our programs?

Benchmark NumPy Array Creation

We can explore the question of how fast the different array creation methods are using benchmarking.

In this case, we will use an approach to create an array of a modest fixed size, then repeat this process many times to give an estimated time. We can then compare the times to see the relative performance of the methods tested.

You can use this approach to test your own favorite NumPy array creation methods.

If you use or extend the NumPy benchmarking approach used in this tutorial, let me know in the comments below. I’d love to see what you come up with.

We could use the time.perf_counter() function directly and develop a helper function to perform the benchmarking and report results.

You can learn more about benchmarking with the time.perf_counter() function in the tutorial:

• Benchmark Python with time.perf_counter()

Instead, in this case, we will use the timeit API, specifically the timeit.timeit() function and specify the string of array creation code to run and a fixed number of times to run it.

We will also provide the globals argument for any constants defined in our benchmark code, such as array size or shape.

For example:

You can learn more about benchmarking with the timeit.timeit() function in the tutorial:

• Benchmark Python with timeit.timeit()

The number of runs in each benchmark was tuned to ensure that each snippet was executed in more than one second and less than about 10 seconds.

Let’s get started.

Fastest Way To Create NumPy 1D Array (uninitialized)

We can explore the fastest way to create a modestly sized uninitialized one-dimensional NumPy array.

In this case, we will define a fixed-size 1d array with one million elements (1,000,000). Each approach will be used to create an array 10,000 times.

The approaches we will compare include the most common NumPy functions for creating a new 1d array of a given size:

1. numpy.empty()
2. numpy.zeros()
3. numpy.ones()
4. numpy.arange()

The complete example is listed below.

Running the example benchmarks each approach and reports the sum execution time.

We can restructure the output into a table for comparison.

We can see that creating an empty array via numpy.empty() was the fastest approach by a massive margin. It was about 44x faster than the next fastest method which was numpy.zeros().

This highlights that if we need an uninitialized 1d array, we should strongly consider using the numpy.empty() function.

Interestingly, we can see that numpy.ones() may have been the slowest method. Surprisingly, there was a one-second difference between numpy.zeros() and numpy.ones() as internally I would have guessed they perform nearly identical tasks (e.g., create an empty array and assign a value to each element in bulk).

Fastest Way To Create NumPy 2D Array (uninitialized)

We can explore the fastest way to create a modestly sized uninitialized two-dimensional NumPy array.

In this case, we will only compare the two fastest approaches for creating a one-dimensional array in the last section:

1. numpy.empty()
2. numpy.zeros()

Each array will have a size (100000,100000) and we will run each method 100,000 times.

The complete example is listed below.

Running the example executes each approach many times and reports the sum time in seconds.

We can restructure the results into a table for comparison.

Interestingly, the results suggest that it may be slightly faster to use numpy.zeros() to create a 2d array than numpy.empty().

The difference is small, less than 300 ms in this case. Nevertheless, if real, it is surprising as we might expect that creating an empty array would be as fast or as fast as creating an array and initializing it.

Repeating the same benchmark a few times, I see a similar pattern, although with different specific benchmark results.

For example:

It may be a real effect and the reason may require further investigation.

Fastest Way To Create and Initialize NumPy Array

We can explore the fastest way to create an initialized one-dimensional NumPy array.

This may be a more common situation.

We have seen that numpy.empty() is fast and numpy.zeros() is faster than numpy.ones(). Therefore, we will focus our attention on these approaches, as well as the numpy.full() function.

Specifically, we will directly compare the approaches:

1. numpy.zeros()
2. numpy.full()
3. numpy.empty() + slice assign
4. numpy.empty() + fill()
5. numpy.empty() + numpy.zeros_like()

We may need to initialize with an arbitrary value, so this is the focus of the methods explored with numpy.zeros() provided as a baseline.

Each approach is tested with an array with one million elements (1,000,000) and each test is run 10,000 times.

The complete example is listed below.

Running the example executes each approach many times and reports the total time in seconds.

We can restructure each approach into a table for direct comparison.

The results show that numpy.zeros() is the fastest overall, as we might have expected. It is probably using a special trick down in the C implementation.

The next fastest was numpy.full(), which was 2 or more seconds faster than all of the approaches that involved creating an empty array and populating it.

This highlights that we should use the built-in NumPy functions where possible as they are likely faster than our attempts to re-implement them with multiple NumPy statements.

Array DataType Matters

We can explore the data type used when creating a NumPy array.

The data type matters as it defines the amount of main memory to allocate to the array, the space required.

Allocating more memory is slower, therefore it is faster if we can choose the smallest data type size that will best hold the data we intend to hold.

For example, if we only need True and False values, such as for an array mask, we should use numy.bool_. If we only need positive integers less than 256, we should use numpy.ushort, and so on.

You can see a list of all NumPy data types and the bounds of data they hold here:

• Array types and conversions between types

I will use the aliases for the data types that give an idea of the number of bits used in the type, it helps in analysis.

We can highlight the impact of the data type on array creation, by creating an empty array with each NumPy data type and comparing the execution time.

We will focus on the numerical data types and exclude strings and objects as they are orders of magnitude slower than the numerical types.

The complete example is listed below.

Running the example creates an empty NumPy array with each NumPy data type and reports the overall execution time.

We can restructure the output as a table for direct comparison.

The pattern of speed difference will be different on your platform, depending on how different-sized data types are handled by the operating system and/or how NumPy was compiled on your system.

Generally, we might expect that as the number of bits per data type is increased, we see a linear increase in execution time.

This is not the case. Looking at signed integers, the int8 type is the fastest followed by int64 and int32 is the slowest. A similar pattern is seen with the unsigned integers.

This is surprising and highlights the need to benchmark on a platform.

It suggests we may get better performance using a larger data type than needed when creating many empty arrays, e.g. int64 when we only need int32 or int16.

We see a similar artifact in floating point arrays, where a float32 array is nearly twice as slow to create than a float64 or float16 array. Again, we may want to use an array with more precision than is required in some situations.

Recommendations

The best recommendation is to identify the array creation tasks you need in your program, then benchmark them in isolation to discover what has the lowest execution speed on your system with your hardware and library versions.

I cannot stress this enough. The numbers above are highly specific and the patterns in performance observed may or may not hold on your specific platform.

That being said, you probably want to:

• Use numpy.empty() to create uninitialized arrays.
• Use numpy.zeros() to create arrays initialized to 0.
• Use numpy.full() to create arrays initialized to a given value.
• Use a data type that fits the data you require and is fastest to create.

Don’t rely on assumptions about performance, such as with data types of functions to call.

Always benchmark.

Further Reading

This section provides additional resources that you may find helpful.

Books

• Python Benchmarking, Jason Brownlee (my book!)

Also, the following Python books have chapters on benchmarking that may be helpful:

• Python Cookbook, 2013. (sections 9.1, 9.10, 9.22, 13.13, and 14.13)
• High Performance Python, 2020. (chapter 2)

Guides

• 4 Ways to Benchmark Python Code
• 5 Ways to Measure Execution Time in Python
• Python Benchmark Comparison Metrics

Benchmarking APIs

• time — Time access and conversions
• timeit — Measure execution time of small code snippets
• The Python Profilers

References

• Benchmark (computing), Wikipedia.
• Profiling (computer programming), Wikipedia.

Takeaways

You now know how to benchmark NumPy array creation functions and discover the fastest approaches you can use in your own programs.

Did I make a mistake? See a typo?
I’m a simple humble human. Correct me, please!

Do you have any additional tips?
I’d love to hear about them!

Do you have any questions?
Ask your questions in the comments below and I will do my best to answer.

Photo by Emeric Deroubaix on Unsplash