Skip to content

Effortlessly Interpolate Values with linspace in Python


np.linspace(): Create Evenly or Non-Evenly Spaced Arrays

When working with numerical applications in Python, particularly using NumPy, it is often necessary to create an array of numbers. In many cases, you may want to have the numbers evenly spaced, but there are also instances where non-evenly spaced numbers are needed. One of the key tools for accomplishing this is the np.linspace() function.

np.linspace() is a versatile and powerful function that is essential in the numerical programming toolkit. In this tutorial, we will explore how to effectively use this function.

Creating Ranges of Numbers With Even Spacing

There are multiple ways to create a range of evenly spaced numbers in Python. The np.linspace() function allows you to achieve this, while also providing customization options to suit your specific requirements. In the following sections, we will learn how to use np.linspace() and compare it with other methods of creating evenly spaced number ranges.

Using np.linspace()

np.linspace() requires two parameters: start and stop. These parameters allow you to define the beginning and end of the range. Here is an example:

import numpy as np
np.linspace(1, 10)

The output will be an array of numbers evenly spaced between 1 and 10.

It is worth noting that np.linspace() provides additional optional parameters that allow for further customization of the output. Some of these parameters include:

  • num: Specifies the number of equally spaced points within the range.
  • dtype: Allows for the specification of the data type of the output.
  • endpoint: Determines whether the stop value is included in the output.
  • retstep: Returns the step size used to create the range.


import numpy as np
np.linspace(1, 10, num=5, endpoint=False)

In this example, the num parameter is set to 5 and the endpoint parameter is set to False, which excludes the stop value from the output.

Using range() and List Comprehensions

Another method of creating an evenly spaced range of numbers is by using the built-in range() function combined with list comprehensions. However, unlike np.linspace(), this method requires more code and is less versatile.

Here is an example of creating an evenly spaced range using range() and list comprehensions:

numbers = [i * 0.1 for i in range(1, 101)]

This code creates a list of numbers ranging from 0.1 to 10, with each number incremented by 0.1. However, note that this method is limited to generating integer or floating-point values, and the range must be known in advance.

Using np.arange()

Lastly, the np.arange() function can also be used to create an evenly spaced range of numbers. This function accepts three parameters: start, stop, and step. By specifying a step value, you can control the spacing between the numbers in the range.

Here is an example of using np.arange() to create an evenly spaced range:

import numpy as np
np.arange(1, 10.5, 0.5)

The output will be an array of numbers ranging from 1 to 10, with a step size of 0.5.

Customizing the Output From np.linspace()

In addition to the required start and stop parameters, np.linspace() provides optional parameters that allow you to further customize the output.

The start, stop, and num Parameters

The start and stop parameters define the range of numbers. The num parameter specifies the number of equally spaced points within the range. By adjusting these parameters, you can control the size and spacing of the output array.

For example:

import numpy as np
np.linspace(1, 10, num=10)

With num set to 10, the output will contain 10 equally spaced numbers between 1 and 10.

The dtype Parameter for Changing Output Type

The dtype parameter allows you to specify the data type of the output array. By default, np.linspace() returns an array of floating-point numbers. However, if you want integers instead, you can specify the dtype parameter as int.

For example:

import numpy as np
np.linspace(1, 10, num=10, dtype=int)

In this example, the output will be an array of integers ranging from 1 to 10.

The endpoint and retstep Parameters

The endpoint parameter determines whether the stop value should be included in the output array. By default, endpoint is set to True, meaning that the stop value is included. If you set endpoint to False, the stop value will be excluded.

The retstep parameter, when set to True, returns the step size used to create the range as a second output. This can be useful when you need to know the exact spacing between the numbers.

Nonscalar Values for Higher-Dimensional Arrays

np.linspace() can also be used to create higher-dimensional arrays by specifying nonscalar values for the start and stop parameters. The output will be an array with the specified dimensions, where each element is an equally spaced range of numbers.

Summary of Input Parameters and Return Values

To summarize, here are the input parameters and return values of np.linspace():

  • Input parameters:
    • start: The starting value of the range.
    • stop: The ending value of the range.
    • num: The number of equally spaced points within the range.
    • dtype: The data type of the output.
  • Return values:
    • An array of evenly spaced numbers within the specified range.

Example: A Food Production Conveyor Belt

To illustrate the usage of np.linspace(), let’s consider the scenario of a food production conveyor belt. The belt has a length of 10 meters, and food items need to be placed on the belt at equally spaced intervals of 1 meter.

import numpy as np
belt_length = 10
item_count = 11
item_positions = np.linspace(0, belt_length, num=item_count)

In this example, np.linspace() is used to calculate the positions of the items on the conveyor belt. The output will be an array with 11 equally spaced values ranging from 0 to 10, representing the positions of the items.

Representing Mathematical Functions

np.linspace() can also be used to represent mathematical functions in a discrete form. By creating an array of x-values and then evaluating the function at those points, you can visualize and analyze mathematical functions.

Mathematical Functions With np.linspace()

To represent a mathematical function, you need to define the ideal x-values within a given range. np.linspace() can generate these x-values by specifying the starting and ending points of the range and the desired number of points.

Here is an example:

import numpy as np
import matplotlib.pyplot as plt
x_values = np.linspace(0, 2 * np.pi, num=100)
y_values = np.sin(x_values)
plt.plot(x_values, y_values)

In this example, np.linspace() generates 100 evenly spaced x-values between 0 and 2π. The sin() function is then applied to these x-values, creating corresponding y-values. Finally, the x and y values are plotted to visualize the sine function.

Example: Superimposing Traveling Waves

Another example is simulating the superposition of two traveling waves. np.linspace() can generate the x-values, and mathematical expressions can be applied to create the y-values for each wave. The result is a visualization of the interference pattern created by the waves.

Creating Ranges of Numbers With Uneven Spacing

While np.linspace() is commonly used for creating evenly spaced number ranges, it can also handle unevenly spaced numbers. In some cases, you might need numbers that follow a logarithmic or other nonlinear spacing.

Logarithmic Spaces

To create a range of numbers with logarithmic spacing, you can use the logspace() function from NumPy. This function is similar to np.linspace(), but it generates numbers spaced evenly on a logarithmic scale.

Here is an example:

import numpy as np
np.logspace(1, 3, num=4)

In this example, the logspace() function generates four numbers spaced evenly on a logarithmic scale between 10 and 1000.

Other Nonlinear Ranges

For creating ranges of numbers with other nonlinear spacing, you can use mathematical functions in combination with np.linspace() or np.arange(). By applying mathematical expressions to the generated x-values, you can achieve the desired nonlinear spacing.

Example: Simulation of an Orbiting Planet

Suppose you want to simulate the position of an orbiting planet over a certain time period. The planet follows an elliptical orbit, so the distances covered at different time intervals are not equally spaced.

By using np.linspace() and applying mathematical expressions for the positions, you can create an array representing the planet’s positions at various time points.


In this tutorial, we explored the np.linspace() function in NumPy, which allows us to create evenly or non-evenly spaced arrays of numbers. We discussed various methods of creating evenly spaced ranges and compared the usage of np.linspace() with alternative tools such as range() and list comprehensions.

We also looked at the customization options provided by np.linspace() and how they can be used to fine-tune the output. Additionally, we discussed how np.linspace() can be used to represent mathematical functions and create ranges of numbers with nonlinear spacing.

By understanding the versatility and power of np.linspace(), you now have a valuable tool for creating arrays of numbers in Python, making it easier to work with numerical applications and data analysis.