Skip to content

Effortlessly Use Python linspace


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

by [Your Name]

When working with numerical applications in Python, it is often necessary to create arrays of numbers. In many cases, these numbers need to be evenly spaced, but there are also situations where non-evenly spaced numbers are required. To accomplish both tasks, the np.linspace() function from the NumPy library can be used.

In this tutorial, we will explore how to effectively use np.linspace() to create arrays of evenly or non-evenly spaced numbers. By the end of this tutorial, you will have a clear understanding of the different use cases for this function and how to customize its output.

Creating Ranges of Numbers With Even Spacing

There are multiple methods available in Python to create ranges of evenly spaced numbers. The np.linspace() function is incredibly versatile and can be used in a variety of scenarios, making it a powerful tool in numerical programming.

Using np.linspace()

To use np.linspace(), you simply provide the starting and ending values of the desired range. Here is an example:

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

This code will generate an array of numbers evenly spaced between 1 and 10. The output will be:

array([ 1. , 1.18367347, 1.36734694, 1.55102041, 1.73469388,
1.91836735, 2.10204082, 2.28571429, 2.46938776, 2.65306122,
2.83673469, 3.02040816, 3.20408163, 3.3877551 , 3.57142857,
3.75510204, 3.93877551, 4.12244898, 4.30612245, 4.48979592,
4.67346939, 4.85714286, 5.04081633, 5.2244898 , 5.40816327,
5.59183673, 5.7755102 , 5.95918367, 6.14285714, 6.32653061,
6.51020408, 6.69387755, 6.87755102, 7.06122449, 7.24489796,
7.42857143, 7.6122449 , 7.79591837, 7.97959184, 8.16326531,
8.34693878, 8.53061224, 8.71428571, 8.89795918, 9.08163265,
9.26530612, 9.44897959, 9.63265306, 9.81632653, 10. ])

This array contains 50 evenly spaced numbers between 1 and 10. The spacing between the numbers is determined automatically by the np.linspace() function.

Using other methods

While np.linspace() is a powerful tool, there are also alternative methods to create ranges of evenly spaced numbers in Python. Some of these methods include using the range() function and list comprehensions, as well as the np.arange() function from the NumPy library. Each of these methods has its own advantages and use cases, so it’s important to choose the most appropriate method for your specific needs.

Customizing the Output From np.linspace()

One of the strengths of the np.linspace() function is its ability to be customized to fit your specific requirements. By adjusting the input parameters, you can fine-tune the output of the function.

The start, stop, and num Parameters

The start and stop parameters of np.linspace() allow you to define the desired range of numbers. The num parameter specifies the number of evenly spaced numbers you want to generate within that range. By adjusting these parameters, you can create arrays with different lengths and spacing.

The dtype Parameter for Changing Output Type

By default, np.linspace() returns an array of floating-point numbers. However, you can change the output type by specifying the desired data type with the dtype parameter. This allows you to generate arrays of integers, complex numbers, or any other supported type.

The endpoint and retstep Parameters

The endpoint parameter controls whether the ending value is included in the generated array. By default, this parameter is set to True, meaning the ending value is included. If you set it to False, the ending value is excluded from the array.

The retstep parameter allows you to retrieve the spacing between the numbers as well. When retstep is set to True, the output of np.linspace() will be a tuple containing both the array and the spacing value.

Nonscalar Values for Higher-Dimensional Arrays

While np.linspace() is commonly used to generate one-dimensional arrays, it can also be used to create higher-dimensional arrays. By providing nonscalar values for the start, stop, and num parameters, you can generate arrays with multiple dimensions.

Summary of Input Parameters and Return Values

To summarize, here is a table outlining the available input parameters and their effects:

startStarting value of the range
stopEnding value of the range
numNumber of evenly spaced values within the range
dtypeDesired data type of the output
endpointWhether to include the ending value in the output
retstepWhether to return the spacing between the numbers in addition to the array

Example: A Food Production Conveyor Belt

To illustrate the versatility of np.linspace(), let’s consider a practical example. Imagine you are designing a conveyor belt for a food production line. The belt needs to start at a speed of 1 meter per second and increase in speed gradually to 10 meters per second over a duration of 10 seconds.

You can use np.linspace() to create a time series array that represents the speed of the conveyor belt at each moment. Here is the code to achieve this:

import numpy as np
time = np.linspace(0, 10, 100)
speed = np.linspace(1, 10, 100)

This code will create two arrays: time and speed. The time array will contain 100 evenly spaced values from 0 to 10, representing the duration of the conveyor belt. The speed array will contain 100 corresponding values, starting at 1 and gradually increasing to 10.

By utilizing np.linspace(), you can easily generate the necessary arrays for your food production conveyor belt simulation.

Representing Mathematical Functions

Another important use case for np.linspace() is representing mathematical functions in discrete form. By generating evenly spaced arrays for the input variable, you can easily evaluate the function at specific points.

Mathematical Functions With np.linspace()

To represent a mathematical function, you need to create an array of input values and an array of corresponding output values. By using np.linspace() to generate the input array, you can evaluate the function at each value to obtain the output array.

Example: Superimposing Traveling Waves

As an example, consider two traveling waves described by the following equations:

y1 = A * sin(2πf1x + φ1)
y2 = A * sin(2πf2x + φ2)

To create an animation that demonstrates the superposition of these waves, you need to evaluate these equations at different positions along the x-axis. You can achieve this by using np.linspace() to generate the x-values array.

Here is an example code snippet that demonstrates this process:

import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(0, 10, 1000)
y1 = np.sin(2 * np.pi * 2 * x)
y2 = np.sin(2 * np.pi * 3 * x)
y = y1 + y2
plt.plot(x, y1, label="Wave 1")
plt.plot(x, y2, label="Wave 2")
plt.plot(x, y, label="Superposition")

This code will generate an animation that shows the individual waves as well as their superposition. By using np.linspace() to create the x-values array, you can easily evaluate the equations at each position and visualize the results.

Two-Dimensional Mathematical Functions

While np.linspace() is commonly used to generate one-dimensional arrays, it can also be used to create two-dimensional arrays. By utilizing nonscalar values for the input parameters, you can generate arrays that represent mathematical functions in multiple dimensions.

Creating Ranges of Numbers With Uneven Spacing

In addition to evenly spaced numbers, there are situations where you may require arrays with non-evenly spaced numbers. np.linspace() can still be used for this purpose, but there are also alternative functions available in NumPy.

Logarithmic Spaces

One common use case for non-evenly spaced numbers is creating logarithmic spaces. The np.logspace() function provides a convenient way to generate arrays that are evenly spaced on a logarithmic scale.

Other Nonlinear Ranges

If you need to generate arrays with other types of non-evenly spaced numbers, NumPy offers several functions. Some of these functions include np.geomspace() for generating geometric sequences and np.mgrid[] for generating multidimensional coordinate grids.

Example: Simulation of an Orbiting Planet

As an example, let’s consider simulating the motion of a planet in orbit around the sun. The distance between the planet and the sun follows a Keplerian orbit, which can be represented by the equation:

r = a(1 - e^2) / (1 + e * cos(theta))

To simulate the orbit, you need to evaluate this equation at different values of the polar angle theta. By using np.linspace() with trigonometric functions, you can easily generate the necessary arrays for the simulation.

import numpy as np
import matplotlib.pyplot as plt
theta = np.linspace(0, 2 * np.pi, 100)
r = a * (1 - e**2) / (1 + e * np.cos(theta))
x = r * np.cos(theta)
y = r * np.sin(theta)
plt.plot(x, y)

This code will generate a plot that represents the simulated orbit of the planet. By using np.linspace() to create the theta-values array, you can easily evaluate the equation at each angle and obtain the corresponding values for the x and y coordinates.


In this tutorial, you learned how to effectively use np.linspace() to create arrays of evenly or non-evenly spaced numbers in Python. You explored the various ways of customizing the output of this function and saw examples of its application in different scenarios.

By using np.linspace() alongside other tools in the NumPy library, you can handle a wide range of numerical programming tasks and create arrays that meet your specific requirements. With this knowledge, you are now equipped to apply np.linspace() to your own projects and harness its power as a numerical programming tool.