How to Use the NumPy linspace() Function

NumPy is an essential package in the Python data science ecosystem, offering a wide array of functions to manipulate numerical data efficiently. Among these, the linspace() function is often used to generate evenly spaced values over a specified interval, making it a useful tool for tasks that require precise numerical ranges, such as data visualization and mathematical modeling. In this tutorial, I’ll show you the ins and outs of the linspace() function.

The Short Answer: How to Use np.linspace()

If you’re in a hurry, here’s the quickest explanation of the linspace() function. NumPy's linspace() function generates an array of evenly spaced numbers over a defined interval. Here, for example, we create an array that starts at 0 and ends at 100, throughout an interval of 5 numbers. As you can expect, it returns an array with [0, 25, 75, 100].

import numpy as np

# Basic usage of linspace to create an array from 0 to 100 with 5 elements
linspace_example = np.linspace(0, 100.0, 5)
linspace_example # Return example

# Output: array([  0.,  25.,  50.,  75., 100.])

Why use NumPy’s linspace() function?

The linspace() function is a simple and efficient method for generating linearly spaced values, offering a useful solution for a variety of scenarios where specific numerical ranges are needed, such as in data visualization, simulations, and even in the fine-tuning of algorithms. Here are a few examples of where linspace() can be used:

• Data visualization tasks: For example, when creating a line graph to represent the trajectory of a satellite over time, linspace() can be used to generate the time intervals at which the position data is sampled, ensuring a smooth and continuous line on the graph.
• Simulations: In financial modeling, to assess the impact of varying interest rates on bond pricing, linspace() can produce a range of interest rates from the lowest possible to the highest anticipated, allowing for a comprehensive analysis across the entire spectrum.
• Scientific research: While studying the effects of global warming on polar ice caps, researchers might use linspace() to create a series of evenly spaced time intervals over several decades. At each interval, they could simulate the average global temperature increase and its impact on ice melt rates.

NumPy linspace() Syntax and Usage with Examples

As mentioned before, the linspace() function creates linearly spaced values which is useful for various numerical computations. Before diving into examples, let’s look at the different arguments you can work with when using linspace().

NumPy linspace() Arguments

• start: The starting value of the sequence.
• stop: The end value of the sequence.
• num (optional): The specified interval. The default is 50, and it must be non-negative.
• endpoint (optional): If True (default), stop is the last sample. If False, the stop value is not included in the sequence generated by linspace(). This means that the function will create evenly spaced samples within the range from start to just before stop, effectively excluding the stop value itself from the sequence. This can be useful when you need a range that approaches but does not reach the endpoint, allowing for more flexible control over the range of values generated.
• retstep (optional): If True, returns (samples, step), where step is the spacing between samples.
• dtype (optional): The type of the output array. If not given, the dtype will be determined by the start and stop arguments.
• axis (optional): The axis in the result to store the samples, only when working with multi-dimensional arrays.

Creating 1-dimensional arrays with linspace()

Now that we’ve deeply understood the arguments available in linspace(), let’s look at a few examples in action!

Creating an evenly spaced 1-dimensional array using linspace()

This example creates an array of 7 evenly spaced numbers between 0 and 10.

import numpy as np

# Create an array of 7 evenly spaced elements from 0 to 10
uniform_array = np.linspace(0, 10, num=7)
print("Uniform Array")
uniform_array

Uniform Array
array([ 0., 1.66666667, 3.33333333, 5., 6.66666667,8.33333333, 10.])

Excluding the endpoint in an evenly spaced 1-dimensional array using linspace()

In this instance, we generate an array of 8 numbers between 10 and 20, but exclude the final value (20) from the array, showcasing the endpoint argument in action.

import numpy as np


# Create an array of 8 elements from 10 to 20, excluding 20
exclude_final_array = np.linspace(10, 20, num=8, endpoint=False)
print("Array Excluding Final Value")
exclude_final_array

Array Excluding Final Value
array([10. , 11.25, 12.5 , 13.75, 15. , 16.25, 17.5 , 18.75])

Including the step size in an evenly spaced 1-dimensional array using linspace()

Here, we create an array of 4 elements between -5 and 5. We also capture and display the step size.

import numpy as np


# Create an array of 4 elements from -5 to 5 and capture the step size
step_array, step = np.linspace(-5, 5, num=4, retstep=True)
print("Array with Defined Step Size", step_array)
print("Step Size", step)

Array with Defined Step Size [-5.         -1.66666667  1.66666667  5.        ]
Step Size 3.3333333333333335

Creating N-dimensional arrays with linspace()

linspace() is also useful for generating multi-dimensional arrays. Here, we show a few examples of that in action.

Generating a 2-dimensional array using linspace()

This example illustrates how to generate a 2D array where each row transitions smoothly from the vector [0, 10] to [5, 15], creating a gradient effect over 4 steps.

import numpy as np


# Perform column-wise linear interpolation from [10, 20] to [15, 25] over 3 steps
column_interpolation_array = np.linspace([10, 20], [15, 25], num=3, axis=1)
print("Column-wise Interpolation Array:")
print(column_interpolation_array)

Column-wise Interpolation Array:
[[10.  12.5 15. ]
 [20.  22.5 25. ]]

Alternatives to NumPy linspace()

While linspace() is highly useful, there are alternatives worth considering, like NumPy's arange() function and list comprehensions.

Using the NumPy arange() function

The arange() function generates values within a given interval. Unlike linspace(), the spacing between values is specified rather than the number of values.

# Using arange to generate values from 0 to 10, spaced by 2
arange_example = np.arange(0, 10, 2)
arange_example

# Returns array([0, 2, 4, 6, 8])

# Using linspace() to generate values from 0 to 10, with interval set to 2
linspace_example = np.linspace(0, 10, 2)
linspace_example

# Returns array([0.,10.0])

Using list comprehensions

List comprehensions provide a more Pythonic way of generating lists, though they lack the vectorization benefits and flexibility of NumPy linspace().

list_comp = [x for x in range(10)]
print(list_comp)

# Outputs [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Final Thoughts

NumPy's linspace() function is a fundamental tool in the data science toolkit, offering precision and flexibility in generating numerical sequences. If you want to strengthen your NumPy chops, check out this tutorial on NumPy Arrays, this NumPy Cheat Sheet, or consider enrolling in our Introduction to NumPy course.