ndarray<\/code> object).<\/p>\nThat might sound a little complicated, so let’s look at a quick example.<\/p>\n
We can call the arange()<\/code> function like this:<\/p>\n\r\nnumpy.arange(5)\r\n<\/pre>\nWhich will produce a NumPy array like this:<\/p>\n
![\"A](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2018\/10\/numpy-array-made-with-numpy-arange.png\")
<\/p>\n
What happened here?<\/p>\n
The np.arange function produced a sequence of 5 evenly spaced values from 0 to 4, stored as an ndarray<\/code> object (i.e., a NumPy array).<\/p>\nHaving said that, what’s actually going on here is a little more complicated, so to fully understand the np.arange function, we need to examine the syntax. Once we look at the syntax, I’ll show you more complicated examples which will make everything more clear.<\/p>\n
The syntax of numpy arange<\/h2>\n
The syntax for NumPy arange is pretty straightforward.<\/p>\n
Like essentially all of the NumPy functions, you call the function name and then there are a set of parameters that enable you to specify the exact behavior of the function.<\/p>\n
![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2018\/10\/numpy-arange-syntax-explanation.png\")
<\/p>\n
Assuming that you’ve imported NumPy into your environment as np<\/code>, you call the function with np.arange()<\/code>.<\/p>\nThen inside of the arange()<\/code> function, there are 4 parameters that you can modify:<\/p>\n\nstart<\/code><\/li>\nstop<\/code><\/li>\nstep<\/code><\/li>\ndtype<\/code><\/li>\n<\/ul>\nLet’s take a look at each of those parameters, so you know what each one does.<\/p>\n
start<\/strong><\/code> (optional)
\nThe start<\/code> parameter indicates the beginning value of the range.<\/p>\nThis parameter is optional<\/em>, so if you omit it, it will automatically default to 0.<\/p>\nstop<\/strong><\/code> (required)
\nThe stop<\/code> parameter indicates the end of the range. Keep in mind that like all Python indexing, this value will not<\/em> be included in the resulting range. (The examples below will explain and clarify this point.) So essentially, the sequence of values will extend up to but excluding the stop<\/code> value.<\/p>\nAdditionally, this parameter is required<\/em>, so you need to provide a stop<\/code> value.<\/p>\nstep<\/strong><\/code> (optional)
\nThe step<\/code> parameter specifies the spacing between values in the sequence. <\/p>\nThis parameter is optional. If you don’t specify a step<\/code> value, by default the step<\/code> value will be 1.<\/p>\ndtype<\/strong><\/code> (optional)
\nThe dtype<\/code> parameter specifies the data type.<\/p>\nPython and NumPy have a variety of data types<\/a> that can be used here. <\/p>\nHaving said that, if you don’t specify a data type, it will be infered based on the other arguments to the function. <\/p>\n
Examples: how to use numpy arange<\/h2>\n
Now, let’s work through some examples of how to use the NumPy arange function.<\/p>\n
Before you start working through these examples though, make sure that you’ve imported NumPy into your environment:<\/p>\n
\r\n# IMPORT NUMPY\r\nimport numpy as np\r\n<\/pre>\nOk, let’s get started.<\/p>\n
Create a simple NumPy arange sequence<\/h4>\n
First, let’s use a simple case. <\/p>\n
Here, we’re going to create a simple NumPy array with 5 values.<\/p>\n
\r\nnp.arange(stop = 5)\r\n<\/pre>\nWhich produces something like the following array:<\/p>\n
<\/p>\n
Notice a few things. <\/p>\n
First, we didn’t specify a start<\/code> value. Because of this, the sequence starts at “0.”<\/p>\nSecond, when we used the code stop = 5<\/code>, the “5” serves as the stop<\/code> position. This causes NumPy to create a sequence of values starting from 0 (the start<\/code> value) up to but excluding<\/em> this stop value. <\/p>\nNext, notice the spacing between values. The values are increasing in “steps” of 1. This is because we did not<\/em> specify a value for the step<\/code> parameter. If we don’t specify a value for the step<\/code> parameter, it defaults to 1.<\/p>\nFinally, the data type is integer. We didn’t specify a data type with the dtype<\/code> parameter, so Python has inferred the data type from the other arguments to the function.<\/p>\nOne last note about this example. In this example, we’ve explicitly used stop =<\/code> parameter. It’s possible to remove the parameter itself, and just leave the argument, like this: <\/p>\n\r\nnp.arange(5)\r\n<\/pre>\nHere, the value “5” is treated a positional argument to the stop<\/code> parameter. Python “knows” that the value “5” serves as the stop<\/code> point of the range. Having said that, I think it’s much clearer to explicitly use the parameter names. It’s clearer if you just type np.arange(stop = 5)<\/code>.<\/p>\nCreate a sequence in increments of 2<\/h4>\n
Now that you’ve seen a basic example, let’s look at something a little more complicated.<\/p>\n
Here, we’re going to create a range of values from 0 to 8, in increments of 2. <\/p>\n
To do this, we will use the start<\/code> position of 0 and a stop<\/code> position of 2. To increment in steps of 2, we’ll set the step<\/code> parameter to 2.<\/p>\n\r\nnp.arange(start = 0, stop = 8, step = 2)\r\n<\/pre>\nThe code creates a ndarray<\/code> object like this:<\/p>\n![\"The](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2018\/10\/np-arange-0-to-6-by-2.png\")
<\/p>\n
Essentially, the code creates the following sequence of values stored as a NumPy array: 0, 2, 4, 6<\/code>. <\/p>\nLet’s take a step back and analyze how this worked. The output range begins at 0. This is because we set start = 0<\/code>.<\/p>\nThe output range then consists of values starting from 0 and incrementing in steps of 2: 2, 4, 6<\/code>.<\/p>\nThe range stops<\/em> at 6. Why? We set the stop<\/code> parameter to 8. Remember though, numpy.arange() will create a sequence up to but excluding<\/em> the stop<\/code> value. So once arange() gets to 6, the function can’t go any further. If it attempts to increment by the step value of 2, it will produce the value of 8, which should be excluded, according to the syntax stop = 8<\/code>. Again, np.arange will produce values up to but excluding<\/em> the stop<\/code> value.<\/p>\nSpecify the data type for np.arange<\/h4>\n
As noted above, you can also specify the data type of the output array by using the dtype<\/code> parameter.<\/p>\nHere’s an example:<\/p>\n
\r\nnp.arange(start = 1, stop = 5, dtype = 'float')\r\n<\/pre>\n![\"A](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2018\/10\/numpy-arange-from-1-to-4-floats.png\")
<\/p>\n
First of all, notice the decimal point at the end of each number. This essentially indicates that these are floats instead of integers.<\/p>\n
How did we create this? This is very straightforward, if you’ve understood the prior examples. <\/p>\n
We’ve called the np.arange function starting from 1 and stopping at 5. And we’ve set the datatype to float by using the syntax dtype = 'float'<\/code>.<\/p>\nKeep in mind that we used floats here, but we could have one of several different data types. Python and NumPy have a couple dozen different data types<\/a>. These are all available when manipulating the dtype<\/code> parameter. <\/p>\nCreate a 2-dimensional array with np.arange<\/h4>\n
It’s also possible to create a 2-dimensional NumPy array with numpy.arange(), but you need to use it in conjunction with the NumPy reshape method<\/a>.<\/p>\nUltimately, we’re going to create a 3 by 3 array with the values from 1 to 9.<\/p>\n
But before we do that, there’s an “intermediate” step that you need to understand.<\/p>\n
…. let’s just create a 1-dimensional array with the values from 1 to 9:<\/p>\n
\r\nnp.arange(start = 1, stop = 10, step = 1)\r\n<\/pre>\nThis code creates a NumPy array like this:<\/p>\n
![\"A](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2018\/10\/np-arange-1-to-9.png\")
<\/p>\n
Notice how the code worked. The sequence of values starts at 1, which is the start<\/code> value. The final value is 9. That’s because we set the stop<\/code> parameter equal to 10; the range of values will be up to but excluding<\/em> the stop<\/code> value. Because we’re incrementing in steps of 1, the last value in the range will be 9.<\/p>\nOk. Let’s take this a step further to turn this into a 3 by 3 array. <\/p>\n
Here, we’re going to use the reshape method to re-shape this 1-dimensional array into a 2-dimensional array.<\/p>\n
\r\nnp.arange(start = 1, stop = 10, step = 1).reshape((3,3))\r\n<\/pre>\n![\"\"](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2018\/10\/2-by-2-numpy-array-from-1-to-9.png\")
<\/p>\n
Notice that this is just a modification of the code we used a moment ago. We’re using np.arange(start = 1, stop = 10, step = 1)<\/code> to create a sequence of numbers from 1 to 9. <\/p>\nThen we’re calling the reshape()<\/code> method<\/a> to re-shape the sequence of numbers. We’re reshaping it from a 1-dimensional NumPy array, to a 2-dimensional array with 3 values along the rows and 3 values along the columns.<\/p>\nnp.arange is common, so make sure you master it<\/h2>\n
In the last few examples, I’ve given you an overview of how the NumPy arange function works. <\/p>\n
It’s pretty straightforward once you understand the syntax, and it’s not that hard to learn.<\/p>\n
Having said that, make sure that you study and practice this syntax. Like all programming techniques, the key to mastery is repeated practice<\/a>. Use the simple examples that I’ve shown above and try to recall the code. Practice and review this code until you know how the syntax works from memory.<\/p>\nIf you have more questions about the NumPy arange function, leave your questions in the comments below.<\/p>\n
For more Python data science tutorials, sign up for our email list<\/h2>\n
Here at Sharp Sight, we teach data science. We want to help you master data science as fast as possible.<\/p>\n
If you sign up for our email list, you’ll receive Python data science tutorials delivered to your inbox.<\/p>\n
Want to learn data science in Python? Sign up now.<\/p>\n
\n\t\t\t\t