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

decimalnumbers 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`

).just beautiful. This is the kind of explanation I have been searching for. bookmarked this website. Thanks for your help !

I have a couple hundred tutorials and blog posts like this, so check them out.