This tutorial will teach you how to use **NumPy linspace()** to create an array of evenly spaced numbers in Python.

You’ll learn the syntax of NumPy `linspace()`

, followed by examples that’ll help you understand how to use it.

Note:To follow along with this tutorial, you need to have Python and NumPy installed.

Don’t have NumPy yet? We’ve put together a quick installation guide for you.

Let’s start!

## Install and Import NumPy

Before starting the tutorial, let’s quickly run through the steps to install the NumPy library.

⏩ If you already have NumPy installed, feel free to skip to the next section.

- If you’re using Google Colab—a cloud-based Jupyter notebook environment, you can import NumPy and start coding right away. (recommended for this tutorial ✅)
- If you’d like to set up a local working environment, I recommend installing the Anaconda distribution of Python. Anaconda comes with several useful packages pre-installed. You may download the installer for your Operating System. The setup process takes only a few minutes.⌛
- If you already have Python installed on your computer, you can still install the Anaconda distribution. You may use conda or pip to install and manage packages. You may run one of the following commands from the Anaconda Command Prompt to install NumPy.

```
# Install NumPy using conda
conda install numpy
# Install NumPy using pip
pip install numpy
```

As a next step, import `numpy`

under the alias `np`

by running the following command. Doing this will help you reference NumPy as `np`

—without having to type down `numpy`

every time you access an item in the module.

`import numpy as np`

Going forward, we’ll use the dot notation to access all functions in the NumPy library like this: `np.<func-name>`

.

## The Case for Evenly Spaced Numbers

When you’re working with NumPy arrays, there are times when you’ll need to create an array of evenly spaced numbers in an interval.

Before we go any further, let’s quickly go over another similar function `np.arange()`

.

### NumPy linspace() vs. NumPy arange()

If you’ve used NumPy before, you’d have likely used `np.arange()`

to create an array of numbers within a specified range.

You know that

`np.arange(start, stop, step)`

returns an array of numbers from`start`

up to but not including`stop`

, in steps of`step`

; the default step size being 1.

However, the value of **step** may not always be obvious. Let’s see why this is the case.

For example, if you need 4 evenly spaced numbers between 0 and 1, you know that the step size must be 0.25. But if you’re using `np.arange()`

, it does not include the stop value of 1. So you will have to pick an interval that goes beyond the stop value.

The following image illustrates a few more examples where you need a specific number of evenly spaced points in the interval [a, b].

Our first example of 4 evenly spaced points in [0,1] was easy enough. You know that the step size between the points should be 0.25.

Suppose you have a slightly more involved example—where you had to list 7 evenly spaced points between 1 and 33. Here, the step size may not be very clear immediately. You can, however, manually work out the value of `step`

in this case.

However, `np.linspace()`

is here to make it even simpler for you! 😄

When using `np.linspace()`

, you only need to specify the number of points in the interval—without worrying about the step size. And you’ll get back the array as desired.

With this motivation, let’s proceed to learn the syntax of NumPy `linspace()`

in the next section.

## Syntax of NumPy linspace()

The syntax for using NumPy `linspace()`

is shown below:

`np.linspace(start, stop, num, endpoint, retstep, dtype, axis)`

At the outset, the above syntax may seem very complicated with many parameters.

However, most of them are *optional* parameters, and we’ll arrive at a much simpler syntax in just a couple of minutes.

Now let’s start by parsing the above syntax:

`start`

and`stop`

are the starting and end points of the interval, respectively. Both start and stop can be scalars or arrays. We’ll limit ourselves to scalar start and end values in this tutorial.`num`

is the number of evenly spaced points. And it is an optional parameter with a default value of 50.`endpoint`

is also an optional parameter that can be either True or False.- The default value is True, which means the end point will be included in the interval by default. However, you may set it to False to exclude the end point.
`retstep`

is yet another optional parameter that takes the Booleans True or False. When set to True, the step value is returned.`dtype`

is the data type of the numbers in the array. The type is usually inferred as float and need not be provided explicitly.`axis`

is another optional parameter denoting the axis along which the numbers should be stored. And this is relevant only when the`start`

and the`stop`

values are arrays themselves.

▶️ So what does `np.linspace()`

return?

It returns an N-dimensional array of evenly spaced numbers. And if the parameter `retstep`

is set to `True`

, it also returns the step size.

Based on the discussion so far, here is a simplified syntax to use `np.linspace()`

:

`np.linspace(start, stop, num)`

The above line of code will return an array of

`num`

evenly spaced numbers in the interval`[start, stop]`

.

Now that you know the syntax, let’s start coding examples.

## How to Create Evenly Spaced Arrays with NumPy linspace()

**#1.** As our first example, let’s create an array of 20 evenly spaced numbers in the interval [1, 5].

You can specify the values of `start`

, `stop`

, and `num`

as keyword arguments. This is shown in the code cell below:

```
import numpy as np
arr1 = np.linspace(start = 1,stop = 5,num = 20)
print(arr1)
# Output:
[1. 1.21052632 1.42105263 1.63157895 1.84210526 2.05263158
2.26315789 2.47368421 2.68421053 2.89473684 3.10526316 3.31578947
3.52631579 3.73684211 3.94736842 4.15789474 4.36842105 4.57894737
4.78947368 5. ]
```

Notice how the numbers in the array start at 1 and end at 5—including both the end points. Also, observe how the numbers, including the points 1 and 5 are represented as `float`

in the returned array.

**#2.** In the previous example, you had passed in the values for `start`

, `stop`

, and `num`

as *keyword arguments*. If you pass in the arguments in the correct order, you might as well use them as *positional arguments* with only the values, as shown below.

```
import numpy as np
arr2 = np.linspace(1,5,20)
print(arr2)
# Output:
[1. 1.21052632 1.42105263 1.63157895 1.84210526 2.05263158
2.26315789 2.47368421 2.68421053 2.89473684 3.10526316 3.31578947
3.52631579 3.73684211 3.94736842 4.15789474 4.36842105 4.57894737
4.78947368 5. ]
```

**#3.** Now let’s create another array where we set `retstep`

to `True`

.

This means that the function will now return both the array and the step. And we can unpack them into two variables `arr3`

: the array, and `step_size`

: the returned step size.

The following code cell explains how you can do it.

```
import numpy as np
arr3, step_size = np.linspace(1,5,20,retstep = True)
print(arr3)
# Output:
[1. 1.21052632 1.42105263 1.63157895 1.84210526 2.05263158
2.26315789 2.47368421 2.68421053 2.89473684 3.10526316 3.31578947
3.52631579 3.73684211 3.94736842 4.15789474 4.36842105 4.57894737
4.78947368 5. ]
# Output:
print(step_size)
0.21052631578947367
```

**#4.** As a final example, let us set `endpoint`

to `False`

, and check what happens.

```
import numpy as np
arr4 = np.linspace(1,5,20,endpoint = False)
print(arr4)
# Output:
[1. 1.2 1.4 1.6 1.8 2. 2.2 2.4 2.6 2.8 3. 3.2 3.4 3.6 3.8
4. 4.2 4.4 4.6 4.8]
```

In the returned array, you can see that 1 is included, whereas 5 is not included. And the last value in the array happens to be 4.8, but we still have 20 numbers.

So far, we’ve only generated arrays of evenly spaced numbers. In the next section, let’s visualize by plotting these numbers.

## How to Plot Evenly Spaced Numbers in an Interval

In this section, let us choose [10,15] as the interval of interest. And then, use `np.linspace()`

to generate two arrays, each with 8 and 12 points, respectively.

After this is complete, we can use the plotting function from the `matplotlib`

library to plot them.

For clarity, we’ll clamp the two arrays of **N1 = 8** and **N2 = 12** evenly spaced points at different positions along the y-axis.

The following code snippet demonstrates this.

```
import numpy as np
import matplotlib.pyplot as plt
N1 = 8
N2 = 12
a = 10
b = 15
y1 = np.zeros(N1)
y2 = np.zeros(N2)
x1 = np.linspace(a, b, N1)
x2 = np.linspace(a, b, N2)
plt.plot(x1, y1-0.5, 'o')
plt.plot(x2, y2 + 0.5, 'o')
plt.ylim([-1, 1])
plt.title(f'Evenly Spaced Numbers in the Interval [{a},{b}]')
plt.xlabel('Interval')
plt.show()
```

Generating evenly spaced points can be helpful when working with mathematical functions. We’ll learn about that in the next section.

## How to Use NumPy linspace() with Math Functions

After you’ve generated an array of evenly spaced numbers using `np.linspace()`

, you can compute the values of mathematical functions in the interval.

In the code cell below, you first generate 50 evenly spaced points in the interval 0 to 2π. And then create the array `y`

using `np.sin()`

on the array `x`

. Note that you may skip the `num`

parameter, as the default value is 50. We’ll still use it explicitly.

As a next step, you can plot the sine function in the interval [0, 2π]. To do this, you can use matplotlib, as in the previous example. Specifically, the `plot()`

function in `matplotlib.pytplot`

is used to create a line plot.

```
import numpy as np
import matplotlib.pyplot as plt
N = 50
a = 0.0
b = 2*np.pi
x = np.linspace(a, b, N)
y = np.sin(x)
plt.plot(x, y, marker = "o")
plt.ylim([-1, 1])
plt.title(f'y = sin(x)')
plt.xlabel('x ---->')
plt.show()
```

Now, run the above code by setting `N`

equal to 10. You’ll get the plot as shown in the figure below.

And you can see that the plot is not very smooth—as you’ve only picked 10 points in the interval.

In general, the larger the number of points you consider, the smoother the plot of the function will be.

### Conclusion

Here’s a summary of what we’ve learned.

**np.linspace(start, stop, num)**returns an array of**num**evenly spaced numbers in the interval**[start, stop]**.- Set the optional parameter
**endpoint**to**False**to exclude**stop**, and set the interval to**[start, stop)**. - Set
**retstep**to**True**optionally to get the step size. - Generate evenly spaced arrays using
**np.linspace()**, and then use the array with mathematical functions.

I hope you now understand how **np.linspace()** works. You may choose to run the above examples in the Jupyter notebook. Check out our guide on Jupyter notebook, or other Jupyter alternatives you can consider.

See you all soon in another Python tutorial. Until then, keep coding!😀