Being a sequence generator, the numpy.linspace() function is used to generate a sequence of numbers in linear space with a uniform step size.
Numpy generally can generate sequences using numpy.arange(), but when we use floating-point arguments, it can result in a loss of precision, which may cause an unpredictable output.
To avoid any potential loss of precision due to the floating-point precision, numpy provides us with a separate sequence generator in numpy.linspace(), which is the preferred option if you already know the number of elements you need. But you generally get the same output using both linspace() and arange() with appropriate parameters, so both can be chosen for the same task.
For example, the following code plots 2 linear sequences between 0 and 10 using numpy.linspace() to show that there is uniformity generated by the sequence.
|
1 2 3 4 5 6 7 8 9 |
import numpy as np import matplotlib.pyplot as plt y = np.zeros(5) x1 = np.linspace(0, 10, 5) x2 = np.linspace(0, 10, 5) plt.plot(x1, y, 'o') plt.plot(x2, y + 0.5, 'o') plt.ylim([-0.5, 1]) plt.show() |
Output:
Syntax
Format: array = numpy.linspace(start, end, num=num_points) will generate a uniform sequence between start and end, with num_points of total elements.
Here,
start-> Starting point (included) of the rangeend-> Endpoint (included) of the rangenum-> Total number of points in the sequence
Let’s understand this using a couple of examples:
|
1 2 3 4 |
import numpy as np a = np.linspace(0.02, 2, 10) print('Linear Sequence from 0.02 to 2:', a) print('Length:', len(a)) |
Output
|
1 2 3 |
<span style="color: #008000;"><strong>Linear Sequence from 0.02 to 2: [0.02 0.24 0.46 0.68 0.9 1.12 1.34 1.56 1.78 2. ] Length: 10 </strong></span> |
The above snippet generates a uniform sequence between 0.02 to 2, having 10 elements in it.
The endpoint keyword argument
If you don’t want to include the last point in the sequence calculations, there is another keyword argument endpoint, which can be set to False. ( It is True by default )
|
1 2 3 4 |
import numpy as np a = np.linspace(0.02, 2, 10, endpoint=False) print('Linear Sequence from 0.02 to 2:', a) print('Length:', len(a)) |
Output
|
1 2 3 |
<span style="color: #008000;"><strong>Linear Sequence from 0.02 to 2: [0.02 0.218 0.416 0.614 0.812 1.01 1.208 1.406 1.604 1.802] Length: 10 </strong></span> |
As you can observe, the last point (2) has not been included in the sequence, so the step size is also different, which will generate a totally different sequence now.
The retstep keyword argument
This is a boolean optional argument, if specified, also returns the step size along with the sequence array, resulting in a tuple as the output
|
1 2 3 4 |
import numpy as np a = np.linspace(0.02, 2, 10, retstep=True) print('Linear Sequence from 0.02 to 2:', a) print('Length:', len(a)) |
Output
|
1 2 3 |
<span style="color: #008000;"><strong>Linear Sequence from 0.02 to 2: (array([0.02, 0.24, 0.46, 0.68, 0.9 , 1.12, 1.34, 1.56, 1.78, 2. ]), 0.22) Length: 2 </strong></span> |
Since the output is a tuple, it’s length is 2, and not 10!
The axis keyword argument
This sets the axis in the result to store the samples. It is used only if the start and endpoints are of the array datatype.
By default (axis=0), the samples will be along a new axis inserted at the beginning. We can use axis=-1 to get an axis at the end.
|
1 2 3 4 5 6 7 |
import numpy as np p = np.array([[1, 2], [3, 4]]) q = np.array([[5, 6], [7, 8]]) r = np.linspace(p, q, 3, axis=0) print(r) s = np.linspace(p, q, 3, axis=1) print(s) |
Output
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
<span style="color: #008000;"><strong>array([[[1., 2.], [3., 4.]], [[3., 4.], [5., 6.]], [[5., 6.], [7., 8.]]]) array([[[1., 2.], [3., 4.], [5., 6.]], [[3., 4.], [5., 6.], [7., 8.]]]) </strong></span> |
In the first case, since axis = 0, we take sequence limits from the first axis.
Here, the limits are the subarray pairs [1, 2] and [5,6], as well as [3, 4] and [7,8], taking elements from the first axis of p and q. Now we compare corresponding elements from the resulting pair to generate the sequences.
So the sequences are [[1 to 5], [2 to 6]] for the first row and [[3 to 7], [4 to 8]], for the second pair(row) which is evaluated and combined to form [ [[1, 2], [3, 4]], [[3, 4], [5, 6]], [[5, 6], [7,8]] ],
The second case will insert new elements in axis=1, or the columns. So the new axis will have been generated via the column sequences. instead of the row sequences.
The sequences [1, 2] to [5, 7] and [3, 4] to [7, 8] are considered and inserted into the columns of the result, resulting in [[[1, 2], [3, 4], [5, 6]], [[3, 4], [5, 6], [7, 8]]].