In this tutorial I’ll show you how to use the np.random.uniform function (AKA, Numpy random uniform).
I’ll explain what the function does, explain the syntax, and show you clear examples of how the function works.
If you need something specific, you can click on any of the following links and it will take you to the correct location in the tutorial.
Table of Contents:
Having said that, if you really want to understand how this function works, you should probably read the whole thing.
Ok. Let’s get to it.
An introduction to Numpy Random Uniform
So what does Numpy Random Uniform do?
The np.random.uniform function creates Numpy arrays filled with values that are drawn from a uniform probability distribution.
Does that make sense?
Unless you know a lot about Numpy and probability, it might not make sense
… so let me dive in and explain it a little.
Numpy Random Uniform Creates Numpy Arrays
The first thing you need to understand is that the Numpy random uniform function creates Numpy arrays.
As you probably know, Numpy is a package for working with numeric data in Python.
Specifically, Numpy has functions for creating and “wrangling” a data structure called a Numpy array.
A Numpy array is just a data structure that contains numbers inside of a row-and-column structure. A simple Numpy array filled with integers looks something like this:
If you take a look, you can see that a Numpy array is just a row-and-column structure that contains numeric data.
The Numpy Package has many Functions for Creating Numpy Arrays
The Numpy package has a variety of functions for creating Numpy arrays with different types of properties.
For example, the Numpy random normal function creates Numpy arrays that are filled with normally distributed numbers.
The Numpy full function creates arrays where every cell in the array contains the exact same number.
Numpy zeroes creates arrays that are filled with zeros.
So Numpy has a variety of functions for creating Numpy arrays with different types of numbers.
Numpy Random Uniform Creates Arrays Drawn From a Uniform Distribution
And with that in mind, let’s return to numpy.random.uniform.
Like some of the other Numpy functions that I just mentioned – like np.random.normal and np.zeroes – the Numpy random uniform function creates Numpy arrays.
But it creates Numpy arrays with very specific types of numbers.
In particular, the np.random.uniform function creates Numpy arrays that contain numbers drawn from a uniform distribution.
What does that mean?
Let’s quickly review the uniform distribution to find out.
A Quick Review of the Uniform Distribution
The uniform distribution is a type of probability distribution.
Remember, a probability distribution is a function that gives the probability of different outcomes.
When we’re talking about probability distributions in Numpy, we’re talking about the probability of choosing a specific number.
Now, let’s tie that to the uniform distribution.
The Uniform Distribution Draws Numbers From a Range, with a Constant Probability
How does the uniform distribution work?
In the uniform distribution, there is a range that we can define by low
and high
.
Inside of that range, the probability of drawing a particular number is given by .
But the probability of drawing a number outside of that range is 0.
That’s why we call it the “uniform” distribution. The probability of a particular outcome inside the range is constant and uniform.
np.random.uniform creates arrays filled with values drawn from the uniform distribution
Let’s bring this back to the np.random.uniform function.
When we use Numpy random uniform, it creates a Numpy array that’s filled with numeric values. Those numeric values are drawn from within the specified range, specified by low
to high
. The function will randomly select N values from that range, where N is given by the size
parameter.
So in the simple example above, size
is set to 3, so the function creates a Numpy array with 3 values. The values are randomly selected from the range from 0 to 1 (the low
and high
values, respectively).
That’s really it at a high level.
But just to make sure that everything is clear, we’ll look carefully at the syntax. And later, I’ll show you some examples.
The syntax of np.random.unifirm
Let’s take a look at the syntax.
A quick note
One quick note: whenever we use a package like Numpy, we need to import that package.
Exactly how we import the package will impact the exact syntax that we use.
The common convention among data scientists is to import Numpy with the alias ‘np
‘.
You can do that with the code:
import numpy as np
When we do this, we can call our Numpy functions with the prefix np
.
np.random.uniform syntax
Ok, back to the syntax.
When you call Numpy random uniform, you start by simply calling the function as np.random.uniform.()
.
Then, inside the parenthesis, we have 3 major parameters that control how the function works: size
, low
, and high
.
Let’s take a look at those.
The parameters of numpy.random.uniform
Each parameter controls some aspect of how the function works.
size
(required)
The size
parameter controls the number of elements in the output array.
So if you set size = 3
, the output Numpy array will have 3 elements. If you set size = 5
, the output will have 5 elements.
You can also set the size with a tuple of values. In this case, the function will create a multi dimensional array. So if you set size = (2,3)
, np.random.uniform will create a Numpy array with 2 rows and 3 columns.
Keep in mind that the size
parameter is optional. If you do not provide a value to the size
parameter, the function will output a single value between low
and high
.
low
The low
parameter sets the lower boundary of the possible output values.
Keep in mind that the range of possible outputs includes low
. So if you set low = 0
, the value 0 is a possible output value.
Also keep in mind that this parameter is optional. If you don’t explicitly provide an argument to this parameter, it will default to 0.
high
The high
parameter sets the upper boundary of possible output values.
Note that the value of the high
parameter is excluded. So if you set high = 1
, the exact value 1 will not be possible.
Also keep in mind that you need to provide an argument to the high parameter. Having said that, you do not need to explicitly use the parameter name itself. Said differently, you can pass an argument to this parameter by position.
The Output of np.random.normal
The output of Numpy random normal is a Numpy array of size size
, where the values are drawn from the uniform distribution with the low value low
and high value high
.
So now that you know how the syntax works, let’s look at some examples.
Examples of how to Use Numpy Random Uniform
Ok. Here, I’ll show you several different examples of how to use the np.random.uniform function.
You can click on any of the links below, and it will take you to the specific example.
Examples:
- Draw 3 values from the range
[0,1)
- Create a 2-dimensional array of uniformly distributed numbers
- Create an array of values from a specific range
Run this code first
One quick thing before you run the examples.
You’ll need to import Numpy.
You can do that by running the following code:
import numpy as np
By doing this, we’ll be able to call our Numpy functions with the prefix ‘np
‘.
EXAMPLE 1: Draw 3 values from the range [0,1)
First, we’ll create a Numpy array with 3 values drawn from the range [0,1)
.
np.random.seed(55) np.random.uniform(size = 3, low = 0, high = 1)
OUT:
array([0.09310829, 0.97165592, 0.48385998])
Explanation
So what’s going on here?
Here, we’re setting the size parameter to size = 3
. This causes the function to create a Numpy array with 3 values.
We’re also setting low = 0
and high = 1
. Those settings define the range of possible values.
The output is simply 3 numbers between 0 and 1.
(Note that we’re also using the Numpy random seed function here in order to set the seed of the random number generator. If you don’t understand that, you should read our blog post about Numpy random seed.)
EXAMPLE 2: Create a 2-dimensional array of uniformly distributed numbers
Next, let’s create a 2-dimensional array of uniformly distributed numbers.
This will work in a way that’s very similar to example 1.
The main difference is the argument to the size
parameter.
Here, we’ll set size = (2,3)
.
np.random.seed(0) np.random.uniform(size = (2,3), low = 0, high = 1)
OUT:
array([[0.5488135 , 0.71518937, 0.60276338], [0.54488318, 0.4236548 , 0.64589411]])
Explanation
Look carefully at the output.
The output is a Numpy array with 2 rows and columns. That’s because we set the size
parameter to size = (2,3)
. When we pass a tuple of values to the size
parameter, it’s telling Numpy to create a multi-dimensional array … in this case, an array with 2 rows and 3 columns.
Then, because we set low = 0
and high = 1
, all of the values in the array are between 0 and 1.
(Note again: we’re also using the Numpy random seed function here in order to set the seed of the random number generator. If you don’t understand that, you should read our tutorial post about Numpy random seed.)
EXAMPLE 3: Create an array of values from a specific range
Finally, let’s create an array of values drawn uniformly from a specific range.
Here, we’ll create a Numpy array with 3 values.
But the values will be drawn from the range [50, 60)
.
We can set the low end and high end of the range with the low
and high
parameters.
np.random.seed(0) np.random.uniform(size = 3, low = 50, high = 60)
OUT:
array([55.48813504, 57.15189366, 56.02763376])
Explanation
Here, we’ve set the size
parameter to size = 3
. Because of this, the output has 3 values.
We’ve also set low = 50
and high = 60
. Because of this, all of the values are between 50 and 60. That is, all of the values were randomly selected from the range [50,60)
with equal probability.
Leave your other questions in the comments below
Do you have other questions about Numpy random uniform?
If so, just leave your questions in the comments section below.
Join our course to learn more about Numpy
In this blog post, I’ve shown you how to use np.random.uniform.
This function is good for some tasks when you’re working with numeric data. But if you really want to master data manipulation with numeric data, you need to know a lot more about Numpy.
If you’re serious about learning Numpy, you should consider joining our premium course called Numpy Mastery.
Numpy Mastery will teach you everything you need to know about Numpy, including:
- How to create Numpy arrays
- How to use the Numpy random functions
- What the “Numpy random seed” function does
- How to Numpy axes work
- How to reshape, split, and combine your Numpy arrays
- Applying mathematical operations on Numpy arrays
- and more …
Moreover, when you join the course, you’ll get access to our specialized practice system. This practice system will enable you to memorize all of the Numpy syntax that you learn. You’ll master it all within a few short weeks.
If you have trouble remembering Numpy syntax, this is the course you’ve been looking for.
Find out more here:
Great explanation for some of us who are Python newbies!
Good to hear that it was useful. I try to write these so they are crystal clear for beginners.
thank you
You’re welcome
The values in the output are decided by what factor? like it says the output is a number with uniform probability distribution within the range given as low and high. So, the output with 3 values are decided by what factor? cause i think only two numbers could have that same probability of occurrence! Please explain or correct me if i am wrong
I’m not sure what you mean by “only two numbers could have the same probability”. Why do you think that?
Take for example the code:
OUT:
This code selects 3 numbers (
size = 3
) between 0 and 1 (low = 0, high = 1
).There are millions of decimal numbers between 0 and 1 (eg.,
.20846054
).And there’s a algorithm that randomly selects 3 of those numbers between 0 and 1.
(Note that because we’re using Numpy random seed, we’ll get the same three numbers every time we run the code. If you want them to be different every time, remove
np.random.seed
).