- \n
- Introduction<\/a><\/li>\n
- Syntax<\/a><\/li>\n
- Examples<\/a><\/li>\n
- FAQ<\/a><\/li>\n<\/ul>\n
Ok. Let’s get to it.<\/p>\n
<\/a><\/p>\n
A quick introduction to Numpy Random Rand<\/h2>\n
At a high level, the Numpy random rand function is pretty straight forward.<\/p>\n
np.random.rand()<\/code> generates random numbers from the standard uniform distribution (i.e., the uniform distribution from 0 to 1), and outputs those numbers as a Numpy array.<\/p>\nTo help you understand that, let’s quickly review the relevant details about Numpy arrays, and about the uniform distribution.<\/p>\n
Numpy Random Uniform Creates Numpy Arrays<\/h3>\n
First of all, let’s review Numpy and Numpy arrays.<\/p>\n
The
np.random.rand()<\/code> produces random numbers, structured as a Numpy array.<\/p>\nA Numpy array is a Python<\/a> data structure that we use for storing and manipulating numeric data.<\/p>\n
Numpy arrays have a row-and-column structure, and they can come in a variety of shapes and sizes. They can be 1-dimensional, 2-dimensional, or multi dimensional. Here’s a quick example of a 2D Numpy array:<\/p>\n
![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2020\/03\/numpy-array_2d_example.png\")
<\/p>\nAdditionally, the Numbers inside of a Numpy array can have a variety of different properties.<\/p>\n
We Use Numpy Functions to Create and Manipulate Numpy Arrays<\/h3>\n
The Numpy package<\/a> has a variety of functions for working with Numpy arrays. For example, there are tools for summing the numbers<\/a> in a Numpy array, calculating the mean<\/a> of the numbers, calculating the standard deviation<\/a>, and so on.<\/p>\n
But there are also Numpy functions for creating arrays with specific properties.<\/p>\n
For example, there are functions for creating arrays that contain only 1s<\/a>, creating arrays that contain all zeros<\/a>, and creating arrays that contain numbers from specific probability distributions. For example, the Numpy random normal function creates arrays with normally distributed numbers<\/a>.<\/p>\n
The
np.random.rand()<\/code> function is one of these types of functions.<\/p>\nnp.random.rand creates arrays with numbers drawn from the standard uniform distribution<\/h4>\n
The Numpy random rand function creates Numpy arrays that are filled with Numbers from the standard uniform distribution.<\/p>\n
If you’ve taken a class on probability, you might be familiar with the uniform distribution, but let’s quickly review.<\/p>\n
The Uniform Distribution has a Constant Probability Within a Specific Range<\/h5>\n
The uniform distribution has a constant probability density function between a specific range.<\/p>\n
Generally, the probability density function is
![\"f(x) = \frac{1}{high - low}\"](\"https:\/\/www.sharpsightlabs.com\/wp-content\/ql-cache\/quicklatex.com-294017d2df0ad70c78caacecbf399f66_l3.png\" "\\"Rendered")
between a specific range, low<\/code> andhigh<\/code>, and 0 everywhere else. <\/p>\nEssentially, when we use a uniform probability distribution, there’s a constant probability of selecting a number within a specific range, and 0 probability outside that range. Keep in mind that the Numpy random uniform function generates numbers from the general uniform distribution<\/a>.<\/p>\n
The standard uniform distribution is a special case of the uniform distribution<\/h5>\n
The standard<\/em> uniform distribution is a special case of the uniform distribution. In the standard uniform distribution, the boundaries of the range are set to
low = 0<\/code> andhigh = 1<\/code>. So, Numpy random rand is likenp.random.uniform<\/code> withlow = 0<\/code> andhigh = 1<\/code>.<\/p>\n![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2020\/12\/np-random-rand_simple-visual-explanation.png\")
<\/p>\nTo restate and simplify: the standard uniform distribution selects numbers between 0 and 1. The numbers between 0 and 1 have a uniform probability of being selected. Outside of 0 and 1, the probability of selecting a number is 0.<\/p>\n
So that’s essentially what
np.random.rand<\/code> does. Thenp.random.rand<\/code> function creates Numpy arrays that contain values between 0 and 1. And the probability of selecting specific numbers between 0 and 1 is uniform.<\/p>\n![\"A](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2020\/12\/numpy-random-rand_simple-visual-example.png\")
<\/p>\nBut, there are a few details about how the function works. To understand those details, we need to look at the syntax.<\/p>\n
<\/a><\/p>\n
The syntax of np.random.rand<\/h2>\n
Here, I’ll walk you through the syntax of
np.random.rand<\/code>.<\/p>\nA quick note<\/h4>\n
One quick note about the syntax.<\/p>\n
Everything that I’m about to explain about the syntax assumes that you’ve imported Numpy.<\/p>\n
In particular, I’m going to assume that you’ve imported Numpy with the alias ‘
np<\/code>‘.<\/p>\nYou can do that with the code
import numpy as np<\/code>.<\/p>\nThis is the common convention among Python data scientists. And it’s important, because how we import Numpy will slightly affect how we write the syntax.<\/p>\n
np.random.rand syntax<\/h3>\n
Ok, assuming that we’ve imported Numpy with the alias
np<\/code>, we call the function asnp.random.rand()<\/code>.<\/p>\n![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2020\/12\/np-random-rand_syntax-explanation_v2.png\")
<\/p>\nInside of the parenthesis, there are a set of parameters that enable you to modify the size of the output. Let’s take a closer look at those.<\/p>\n
The parameters of np.random.rand<\/h3>\n
The
np.random.rand()<\/code> function has a set of parameters that enable you to control the exact shape of the output.<\/p>\nKeep in mind, that these parameters are optional. In fact, it’s possible to call the function without any parameters at all. In this case,
np.random.rand()<\/code> will return a single random number between 0 and 1.<\/p>\nBut if you use the parameters, you can specify the number of rows, columns, and the number of elements along additional dimensions.<\/p>\n
Each of the following parameters controls an axis.<\/p>\n
- \n
d0<\/code><\/li>\nd1<\/code><\/li>\ndn<\/code><\/li>\n<\/ul>\nLet’s take a look at these so you understand exactly what they do.<\/p>\n
d0<\/code> (optional)<\/h6>\nIf you chose to use the
d0<\/code> parameter, then the argument to this parameter controls the number of elements along axis-0.<\/p>\nSo if you’re creating a 1 dimensional Numpy array,
d0<\/code> controls the total number of elements in the array. <\/p>\n![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2020\/09\/numpy-random-randn_d0.png\")
<\/p>\nIf you’re creating a 2 dimensional or n-dimensional array, then
d0<\/code> controls the number of rows.<\/p>\nRemember: for 1D arrays, axis-0 is the only axis. But for 2D arrays, axis-0 points downwards against the rows. If you’re confused about this, you should review how Numpy axes work<\/a>.<\/p>\n
d1<\/code> (optional)<\/h6>\nThe second parameter,
d1<\/code>, controls the number of elements along axis-1.<\/p>\nRemember: in a 2-dimensional array, axis-1 points horizontally along the columns.<\/p>\n
So if you create a 2D or multi-dimensional array,
d1<\/code> controls the number of columns (andd0<\/code> will control the number of rows).<\/p>\n![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2020\/09\/numpy-random-randn_d0-and-d1_v2.png\")
<\/p>\nBear in mind that you’ll only use
d1<\/code> if you’re creating a 2D or multi dimensional array. And if you used1<\/code>, you’ll also have to used0<\/code>. <\/p>\ndn<\/code> (optional)<\/h6>\nThe previous two parameters (
d0<\/code> andd1<\/code>) generalize for higher dimensional arrays. <\/p>\nIf you want to create an n-dimensional Numpy array,
dn<\/code> controls the number of elements along axis-n. <\/p>\nThe Output of np.random.rand<\/h3>\n
The
numpy.random.rand()<\/code> function outputs a Numpy array that contains numbers drawn from the standard uniform distribution. That is, the array will contain numbers from the range[0, 1)<\/code>.<\/p>\nHaving said that, the exact shape of the output depends on the parameters you use.<\/p>\n
If you call
np.random.rand()<\/code> without any parameters, then it will output a single number.<\/p>\nIf you call the function as
np.random.rand(d0)<\/code>, and use only thed0<\/code> parameter, it will output a 1-dimensional array with the number of elements specified by the argument tod0<\/code>.<\/p>\nAnd if you use the higher order parameters
d0<\/code>,d1<\/code>, …dn<\/code>, thennp.random.rand<\/code> will output a Numpy array of size(d0, d1, ..., dn)<\/code>.<\/p>\nSo essentially, the parameters
d0<\/code>,d1<\/code>, anddn<\/code> control the size and shape of the output array. <\/p>\n<\/a><\/p>\n
Examples: How to Use np.random.rand to Generate Random Uniform Numbers<\/h2>\n
Now that we’ve looked at the syntax, let’s look at some examples. <\/p>\n
It will probably be easier to understand how this works if you see some concrete examples.<\/p>\n
Examples:<\/strong><\/p>\n
- \n
- Generate a single number with np.random.rand<\/a><\/li>\n
- Create a 1D Numpy array with Numpy Random Rand<\/a><\/li>\n
- Create a 2D Numpy array with Numpy Random Rand<\/a><\/li>\n<\/ul>\n
Run this code first<\/h4>\n
One quick note.<\/p>\n
As I mentioned above, before we use Numpy, we need to import the Numpy package. You can do that with the following code: <\/p>\n
\r\nimport numpy as np\r\n<\/pre>\n
Once you do that, you’ll be ready to run the example code.<\/p>\n
<\/a><\/p>\n
EXAMPLE 1: Generate a single number with np.random.rand<\/h3>\n
Ok. First, we’ll generate a single number with Numpy random rand.<\/p>\n
Let’s take a look.<\/p>\n
\r\nnp.random.seed(0)\r\nnp.random.rand()\r\n<\/pre>\n
OUT:<\/p>\n
\r\n0.5488135039273248\r\n<\/pre>\n
Explanation<\/h6>\n
This is really simple.<\/p>\n
When we call
np.random.rand()<\/code> without any parameters, it outputs a single number, drawn randomly from the standard uniform distribution (i.e., the uniform distribution between 0 and 1).<\/p>\nHere, we also used Numpy random seed to make our code reproducible<\/a>. That being the case, if you run this code, you should get the same output.<\/p>\n
<\/a><\/p>\n
EXAMPLE 2: Create a 1D Numpy array with Numpy Random Rand<\/h3>\n
Next, we’re going to create a 1-dimensional Numpy array, filled with random uniform numbers.<\/p>\n
\r\nnp.random.seed(0)\r\nnp.random.rand(3)\r\n<\/pre>\n
OUT:<\/p>\n
\r\narray([0.5488135 , 0.71518937, 0.60276338])\r\n<\/pre>\n
Explanation<\/h6>\n
Here, we’ve called Numpy random rand and we provided a single number, 3, as an argument.<\/p>\n
This argument value is being passed to the
d0<\/code> parameter.<\/p>\nEffectively, when we call
np.random.rand()<\/code> with a single numeric argument, the function creates a 1-dimensional array, with the number of elements specified by the input value.<\/p>\nSo the input value is 3, and the output array has 3 elements.<\/p>\n
(Also note that we’ve used Numpy random seed to make the output reproducible.)<\/p>\n
<\/a><\/p>\n
EXAMPLE 3: Create a 2D Numpy array with Numpy Random Rand<\/h3>\n
Finally, let’s create a 2-dimensional array with Numpy random rand.<\/p>\n
To do this, we’re going to call the function with two integer arguments:<\/p>\n
\r\nnp.random.seed(0)\r\nnp.random.rand(2, 3)\r\n<\/pre>\n
OUT:<\/p>\n
\r\narray([[0.5488135 , 0.71518937, 0.60276338],\r\n [0.54488318, 0.4236548 , 0.64589411]])\r\n<\/pre>\n
Explanation<\/h6>\n
Here, we’ve called
np.random.rand<\/code> with 2 arguments … the values 2 and 3.<\/p>\nThe value 2 is being passed to the
d0<\/code> argument, and the value 3 is being passed to thed1<\/code> argument.<\/p>\nRemember, when we create a 2D array,
d0<\/code> controls the number of rows andd1<\/code> controls the number of columns.<\/p>\n<\/p>\nSo here, when we call the function as
np.random.rand(2, 3)<\/code>, Numpy random rand produces a Numpy array with 2 rows and 3 columns<\/em>. The values are drawn randomly from the standard uniform distribution.<\/p>\nNote also that once again, we’ve used Numpy random seed to make our code reproducible.<\/p>\n
<\/a><\/p>\n
Frequently Asked Questions about Numpy Random Rand<\/h2>\n
Now that you’ve learned about the syntax of Numpy Random Rand, and seen some examples, let’s look at a common question about the function.<\/p>\n
Frequently asked questions:<\/strong><\/p>\n
- \n
- What’s the difference between
np.random.rand<\/code> andnp.random.uniform<\/code>?<\/a><\/li>\n<\/ul>\n<\/a><\/p>\n
What’s the difference between
np.random.rand<\/code> andnp.random.uniform<\/code>?<\/h3>\nnumpy.random.rand()<\/code> andnumpy.random.uniform()<\/code> are very similar functions.<\/p>\nBoth functions generate random numbers drawn from the uniform distribution. <\/p>\n
Both functions output Numpy arrays.<\/p>\n
The difference is that
np.random.rand()<\/code> is like a special case ofnp.random.uniform()<\/code>.<\/p>\nLet me explain.<\/p>\n
numpy.random.uniform<\/code> generates random numbers from the uniform distribution, but it allows you to specify the low end of the range and the high end of the range for the uniform distribution.<\/p>\nnumpy.random.rand<\/code> also generates random numbers from the uniform distribution, but the low end of the range is set 0 and the high end of the range is set to 1.<\/p>\nSo the
np.random.rand<\/code> function is like a special case ofnp.random.uniform<\/code>.<\/p>\nTo see this, try running the following code:<\/p>\n
\r\nnp.random.seed(0)\r\nnp.random.rand(3)\r\n<\/pre>\n
\r\nnp.random.seed(0)\r\nnp.random.uniform(size = 3, low = 0, high = 1)\r\n<\/pre>\n
You’ll notice that these produce the same output.<\/p>\n
Beyond that, Numpy random uniform has a slightly different syntax. To learn more about this function, check out our tutorial about Numpy random uniform<\/a>.<\/p>\n
Leave your other questions in the comments below<\/h5>\n
Do you have other questions about the Numpy random rand function?<\/p>\n
If so, just leave your question in the comments section at the bottom of the page.<\/p>\n
Join our course to learn more about Numpy<\/h2>\n
Here in this tutorial, I’ve explained how to use the
np.random.rand<\/code> function.<\/p>\nThis should help you understand this particular function, but if you really want to learn Numpy, there’s a lot more to learn.<\/p>\n
If you’re serious about mastering Numpy, and serious about data science in Python, you should consider joining our premium course called Numpy Mastery<\/em>.<\/p>\n
Numpy Mastery will teach you everything you need to know about Numpy, including:<\/p>\n
- \n
- How to create Numpy arrays<\/li>\n
- How to use the Numpy random functions<\/li>\n
- What the “Numpy random seed” function does<\/li>\n
- How to reshape, split, and combine your Numpy arrays<\/li>\n
- How to perform mathematical operations on Numpy arrays<\/li>\n
- and more …<\/li>\n<\/ul>\n
Moreover, it will help you completely master<\/em> the syntax within a few weeks. We’ll show you a practice system that will enable you to memorize all of the Numpy syntax you learn. If you have trouble remembering Numpy syntax, this is the course you’ve been looking for.<\/p>\n
Find out more here:<\/p>\n
\nLearn More About Numpy Mastery<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
In this tutorial, I’ll show you how to use the np.random.rand function (AKA, Numpy random rand) to create Numpy arrays filled with random uniform numbers. I’ll explain exactly what this function does, how the syntax works, and I’ll show you step-by-step examples of how to use it. If you need something specific, you can click … Read more<\/a><\/p>\n","protected":false},"author":1,"featured_media":5756,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_et_pb_use_builder":"","_et_pb_old_content":"","_et_gb_content_width":"","om_disable_all_campaigns":false,"footnotes":""},"categories":[31,62,58],"tags":[],"publishpress_future_action":{"enabled":false,"date":"2024-05-04 08:05:19","action":"change-status","newStatus":"draft","terms":[],"taxonomy":"category"},"_links":{"self":[{"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/posts\/5057"}],"collection":[{"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/comments?post=5057"}],"version-history":[{"count":0,"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/posts\/5057\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/media\/5756"}],"wp:attachment":[{"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/media?parent=5057"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/categories?post=5057"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/tags?post=5057"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
- Create a 1D Numpy array with Numpy Random Rand<\/a><\/li>\n
- Syntax<\/a><\/li>\n