- \n
- A quick review of Numpy and Numpy arrays<\/a><\/li>\n
- Introduction to Numpy full<\/a><\/li>\n
- The syntax of np.full<\/a><\/li>\n
- Numpy full examples<\/a><\/li>\n
- Numpy full FAQ<\/a><\/li>\n<\/ul>\n
However, it’s probably better to read the whole tutorial, especially if you’re a beginner.<\/p>\n
<\/a><\/p>\n
A quick review of Numpy and Numpy arrays<\/h2>\n
Quickly, let’s review Numpy and Numpy arrays.<\/p>\n
So what is Numpy? <\/p>\n
To put it simply, Numpy<\/a> is a toolkit for working with numeric data in Python. Said differently, it’s a set of tools for doing data manipulation with numbers.<\/p>\n
More specifically, Numpy operates on special arrays<\/em> of numbers, called Numpy arrays.<\/p>\n
Numpy arrays are arrays of numbers<\/h5>\n
What is a Numpy array?<\/p>\n
You can think of a Numpy array<\/a> like a vector or a matrix<\/a> in mathematics.<\/p>\n
Like a matrix, a Numpy array is just a grid of numbers.<\/p>\n
These Numpy arrays can be 1-dimensional … like a vector:<\/p>\n
![\"A](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2019\/07\/example-of-1D-numpy-array_0-to-3.png\")
<\/p>\nAnd Numpy arrays can be 2-dimensional:<\/p>\n
![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2019\/07\/example-of-2D-numpy-array_0-to-7.png\")
<\/p>\nThey can also have more than two dimensions<\/em>. These higher-dimensional Numpy arrays are like tensors in mathematics (and they are often used in advanced machine learning processes like Python’s Keras and TensorFlow).<\/p>\n
Numpy arrays have a shape<\/h5>\n
One thing to remember about Numpy arrays is that they have a shape<\/em>.<\/p>\n
The shape of a Numpy array is essentially the number of rows and columns. (Or more technically, the number of units along each axis of the array.)<\/p>\n
So let’s say that you have a 2-dimensional Numpy array.<\/p>\n
<\/p>\nThis array has a shape of
(2, 4)<\/code> because it has two rows and four columns.<\/p>\nYou need to know about Numpy array shapes because when we create new arrays using the numpy.full function, we will need to specify a shape for the new array with the
shape =<\/code> parameter.<\/p>\nYou’ll read more about this in the syntax section<\/a> of this tutorial. <\/p>\n
Numpy provides functions for creating and manipulating arrays<\/h5>\n
Essentially, Numpy just provides functions for creating these numeric arrays and manipulating them.<\/p>\n
For example, we can use Numpy to perform summary calculations. We can use Numpy functions to calculate the mean of an array<\/a> or calculate the median of an array<\/a>.<\/p>\n
And Numpy has functions to change the shape of existing arrays. So we use Numpy to combine arrays together<\/a> or reshape a Numpy array<\/a>.<\/p>\n
But before we do any of those things, we need an array of numbers in the first place. <\/p>\n
Numpy has a variety of ways to create Numpy arrays, like Numpy arrange<\/a> and Numpy zeroes<\/a>.<\/p>\n
One of the other ways to create an array though is the Numpy full function.<\/p>\n
<\/a><\/p>\n
A quick introduction to Numpy full<\/h2>\n
The Numpy full function is fairly easy to understand. <\/p>\n
It essentially just creates a Numpy array that is “full” of the same value.<\/p>\n
So for example, you could use it to create a Numpy array that is filled with all 7s:<\/p>\n
![\"A](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2019\/09\/numpy-full-example-7s.png\")
<\/p>\nIt can get a little more complicated though, because you can specify quite a few of the details of the output array. For example, you can specify how many rows and columns. You can also specify the data type (e.g.,
integer<\/code>,float<\/code>, etc).<\/p>\nThat being said, to really understand how to use the Numpy full function, you need to know more about the syntax.<\/p>\n
<\/a><\/p>\n
The syntax of np.full<\/h2>\n
The syntax of the Numpy full function is fairly straight forward.<\/p>\n
Moreover, if you’ve learned about other Numpy functions, some of the details might look familiar (like the
dtype<\/code> parameter).<\/p>\nBut on the assumption that you might need some extra help understanding this, I want to carefully break the syntax down.<\/p>\n
np.full syntax<\/h3>\n
To call the Numpy full function, you’ll typically use the code
np.full()<\/code>.<\/p>\nHaving said that, you need to remember that how exactly you call the function depends on how you’ve imported numpy. If you’ve imported Numpy with the code
import numpy as np<\/code> then you’ll call the function asnp.full()<\/code>. But if you’ve imported numpy differently, for example with the codeimport numpy<\/code>, you’ll call the function differently.<\/p>\nFor the most part here, I’ll refer to the function as np.full.<\/p>\n
Ok. So you call the function with the code
np.full()<\/code>. Then inside of the function there are a set of parameters that enable you to control exactly how the function behaves.<\/p>\n![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2019\/09\/np-full-syntax-explanation.png\")
<\/p>\nLet’s take a closer look at those parameters.<\/p>\n
The parameters of np.full<\/h3>\n
The three main parameters of np.full are:<\/p>\n
- \n
shape<\/code><\/li>\nfill_value<\/code><\/li>\ndtype<\/code><\/li>\n<\/ul>\nThere’s actually a fourth parameter as well, called
order<\/code>. However, we don’t use theorder<\/code> parameter very often, so I’m not going to cover it in this tutorial.<\/p>\nLet’s examine each of the three main parameters in turn.<\/p>\n
shape<\/code> (required)<\/h6>\nThe
shape<\/code> parameter specifies the shape of the output array.<\/p>\nRemember, the output of the Numpy full function is a Numpy array. <\/p>\n
Also remember that all Numpy arrays have a shape<\/em>. The shape of a Numpy array is the number of rows and columns.<\/p>\n
When we specify a shape with the
shape<\/code> parameter, we’re essentially specifying the number of rows and columns we want in the output array. That’s it.<\/p>\nTo do this, we need to provide a number or a list of numbers as the argument to
shape<\/code>.<\/p>\n![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2019\/09\/np-full-shape-parameter.png\")
<\/p>\nIf we provide a single integer
n<\/code> as the argument, the output will be a 1-dimensional Numpy array withn<\/code> observations.<\/p>\nBut if we provide a list of numbers as the argument, the first number in the list will denote the number of rows and the second number will denote the number of columns of the output. (And if we provide more than two numbers in the list, np.full will create a higher-dimensional array.)<\/p>\n
This might not make a lot of sense yet, but sit tight. I’ll show you examples in the examples section of this tutorial<\/a>.<\/p>\n
fill_value<\/code><\/h6>\nThe
fill_value<\/code> parameter is easy to understand.<\/p>\nIt’s the value that you want to use as the individual elements of the array.<\/p>\n
So if you set
fill_value = 7<\/code>, the output will contain all 7s. If you setfill_value = 102<\/code>, then every single element of the output array will be 102.<\/p>\ndtype<\/code><\/h6>\nFinally, there’s the dtype parameter. <\/p>\n
This just enables you to specify the data type of the elements of the output array. <\/p>\n
By default, Numpy will use the data type of the
fill_value<\/code>. So if your fill value is an integer, the output data type will be an integer, etc.<\/p>\nBut you can manually specify the output data type here.<\/p>\n
In the simplest cases, you’ll use data types like
int<\/code> (integer) orfloat<\/code>, but there are more complicated options since Numpy recognizes a large variety of data types<\/a>.<\/p>\nFor the sake of simplicity, I’m not going to work with any of the more exotic data types … we’ll stick to floats and ints.<\/p>\n
Ok … now that you’ve learned about the syntax, let’s look at some working examples.<\/p>\n
<\/a><\/p>\n
Numpy full examples<\/h2>\n
Using Numpy full is fairly easy once you understand how the syntax works<\/a>.<\/p>\n
Still, I want to start things off simple. We’ll start with simple examples and increase the complexity as we go.<\/p>\n
Examples:<\/strong><\/p>\n
- \n
- Create a 1-dimensional array filled with the same number<\/a><\/li>\n
- Create a 2-dimensional array filled with the same number<\/a><\/li>\n
- Modify the data type of the output array<\/a><\/li>\n<\/ul>\n
Run this code first<\/h4>\n
One quick note before you run any code …<\/p>\n
You need to make sure to import Numpy properly.<\/p>\n
To import Numpy run this code:<\/p>\n
\r\nimport numpy as np\r\n<\/pre>\n
This will enable us to call functions from the Numpy package.<\/p>\n
(Note: this assumes that you already have Numpy installed<\/em>. If you don’t have Numpy installed, the import statement won’t work! If you don’t have Numpy installed, I recommend using Anaconda<\/a>.)<\/p>\n
Ok, with that out of the way, let’s look at the first example.<\/p>\n
<\/a><\/p>\n
EXAMPLE 1: Create a 1-dimensional array filled with the same number<\/h3>\n
This first example is as simple as it gets.<\/p>\n
We’re going to create a Numpy array filled with all 7s.<\/p>\n
\r\nnp.full(shape = 3, fill_value = 7)\r\n<\/pre>\n
And here’s the output:<\/p>\n
\r\narray([7, 7, 7])\r\n<\/pre>\n
This is really simple.<\/p>\n
To specify that we want the array to be filled with the number ‘7’, we set
fill_value = 7<\/code>. <\/p>\nBy setting
shape = 3<\/code>, we’re indicating that we want the output to have three elements.<\/p>\nSo the code
np.full(shape = 3, fill_value = 7)<\/code> produces a Numpy array filled with three 7s.<\/p>\nRedo without parameter names<\/h6>\n
Quickly, I want to redo that example without<\/em> the explicit parameter names. <\/p>\n
Among Python programmers, it’s extremely<\/em> common to remove the actual parameters and to only use the arguments to those parameters.<\/p>\n
Let me show you:<\/p>\n
\r\nnp.full(3, 7)\r\n<\/pre>\n
OUT:<\/p>\n
\r\narray([7, 7, 7])\r\n<\/pre>\n
In terms of output, this the code
np.full(3, 7)<\/code> is equivalent tonp.full(shape = 3, fill_value = 7)<\/code>. The output is exactly the same. Numpy knows that the “3” is the argument to theshape<\/code> parameter and the “7” is the argument to thefill_value<\/code> parameter.<\/p>\nUnfortunately, I think
np.full(3, 7)<\/code> is harder to read, particularly if you’re a beginner and you haven’t memorized the syntax yet.<\/p>\nHaving said that, I think it’s much better as a best practice to explicitly type out the parameter names.<\/p>\n
<\/a><\/p>\n
EXAMPLE 2: Create a 2-dimensional array filled with the same number<\/h3>\n
Next, let’s create a 2-dimensional array filled with the same number.<\/p>\n
Here, we’re going to create a 2 by 3 Numpy array filled with 7s.<\/p>\n
To do this, we’re going to call the np.full function with
fill_value = 7<\/code> (just like in example 1). This will fill the array with 7s.<\/p>\nBut to specify the shape<\/em> of the array, we will set
shape = (2,3)<\/code>. <\/p>\nLet’s take a look:<\/p>\n
\r\nnp.full(shape = (2,3), fill_value = 7)\r\n<\/pre>\n
Which creates the following output:<\/p>\n
\r\narray([[7, 7, 7],\r\n [7, 7, 7]])\r\n<\/pre>\n
This is very straight forward.<\/p>\n
By setting
shape = (2,3)<\/code>, we’re indicating that we want the output to have 2 rows and and 3 columns. The codefill_value = 7<\/code> fills that 2×3 array with 7s.<\/p>\nNote: we can create arrays of different sizes and shapes<\/h6>\n
In the example above, I’ve created a relatively small array. Two rows and three columns.<\/p>\n
But understand that we can create arrays that are much larger.<\/p>\n
Here’s an example of a 5×20 array:<\/p>\n
\r\nnp.full(shape = (5,20), fill_value = 7)\r\n<\/pre>\n
OUT:<\/p>\n
\r\narray([[7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7],\r\n [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7],\r\n [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7],\r\n [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7],\r\n [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7]])\r\n<\/pre>\n
You could even go a step further and create an array with thousands of rows or columns (or more).<\/p>\n
Like almost all of the Numpy functions, np.full is flexible in terms of the sizes and shapes that you can create with it.<\/p>\n
<\/a><\/p>\n
EXAMPLE 3: Modify the data type of the output array<\/h3>\n
Now, let’s build on example 2 and increase the complexity just a little.<\/p>\n
Here, we’re going to create a Numpy array that’s filled with floating point numbers instead of integers.<\/p>\n
Just like in example 2<\/a>, we’re going to create a 2×3 array filled with 7s. <\/p>\n
Now remember, in example 2<\/a>, we set
fill_value = 7<\/code>. But notice that the value “7” is an integer<\/em>. Because of this, np.full just produced an output array filled with integers. That’s the default. By default, the output data type matches the data type offill_value<\/code>.<\/p>\nIt’s possible to override that default though and manually set the data type by using the
dtype<\/code> parameter.<\/p>\nLet’s take a look:<\/p>\n
\r\nnp.full(shape = (2,3), fill_value = 7, dtype = float)\r\n<\/pre>\n
OUT:<\/p>\n
\r\narray([[7., 7., 7.],\r\n [7., 7., 7.]])\r\n<\/pre>\n
Here, we have a 2×3 array filled with 7s, as expected.<\/p>\n
But notice that the array contains floating point numbers. You can tell, because there is a decimal point after each number. You could also check the dtype attribute of the array with the code
np.full(shape = (2,3), fill_value = 7, dtype = float).dtype<\/code>, which would show you that the data type isdtype('float64')<\/code>.<\/p>\nThis is a simple example with a fairly familiar data type. Just keep in mind that Numpy supports a wide range of data types<\/a>, including a few “exotic” options for Numpy (try some cases with
dtype = np.bool<\/code>).<\/p>\n<\/a><\/p>\n
EXAMPLE 4: Create a 3-dimensional array with np.full<\/h3>\n
For the final example, let’s create a 3-dimensional array.<\/p>\n
So far, we’ve been creating 1-dimensional and 2-dimensional arrays. We’ve been sticking to smaller sizes and shapes just to keep the examples simple (when you’re learning something new, start simple!).<\/p>\n
But you need to realize that Numpy in general, and np.full in particular can work with very large arrays with a large number of dimensions.<\/p>\n
So let’s look at the slightly more complicated example of a 3D array.<\/p>\n
To do this, we’re going to provide more arguments to the
shape<\/code> parameter. <\/p>\nRemember from the syntax section<\/a> and the earlier examples that we can specify the shape of the array with the
shape<\/code> parameter. If we provide a single number as the argument toshape<\/code>, it creates a 1D array. If we provide a list of two<\/em> numbers (i.e.,shape = [2,3]<\/code>), it creates a 2D array.<\/p>\nSo how do you think we create a 3D array?<\/p>\n
Pass an extra number to
shape<\/code>.<\/p>\nLet’s take a look.<\/p>\n
\r\nnp.full(shape = (2,3,4), fill_value = 7)\r\n<\/pre>\n
OUT:<\/p>\n
\r\narray([[[7, 7, 7, 7],\r\n [7, 7, 7, 7],\r\n [7, 7, 7, 7]],\r\n\r\n [[7, 7, 7, 7],\r\n [7, 7, 7, 7],\r\n [7, 7, 7, 7]]])\r\n<\/pre>\n
As you can see, this produces a Numpy array with 2 units along axis-0, 3 units along axis-1, and 4 units along axis-2.<\/p>\n
As a side note, 3-dimensional Numpy arrays are a little counter-intuitive for most people. I hesitate to use the terms ‘rows’ and ‘columns’ because it would confuse people. I’ll probably do a separate blog post to explain 3D arrays in another place.<\/p>\n
Having said that, just be aware that you can<\/em> use Numpy full to create 3-dimensional and higher dimensional Numpy arrays.<\/p>\n
<\/a><\/p>\n
Numpy full FAQ<\/h2>\n
Now that you’ve seen some examples and how Numpy full works, let’s take a look at some common questions about the function.<\/p>\n
Frequently asked questions:<\/strong><\/p>\n
- \n
- Can you fill a Numpy array with True or False?<\/a><\/li>\n
- Is Numpy full slower than Numpy zeros and Numpy empty?<\/a><\/li>\n<\/ul>\n
<\/a><\/p>\n
Can you fill a Numpy array with True or False?<\/h3>\n
Yes, actually you can.<\/p>\n
\r\nnp.full(shape = [2,2], fill_value = True, dtype = bool)\r\n<\/pre>\n
And here is the output:<\/p>\n
\r\narray([[ True, True],\r\n [ True, True]])\r\n<\/pre>\n
As you can see, the code creates a 2 by 2 Numpy array filled with the value
True<\/code>.<\/p>\nNote that there are actually a few other ways to do this with np.full, but using this method (where we explicitly set
fill_value = True<\/code> anddtype = bool<\/code>) is probably the best.<\/p>\n<\/a><\/p>\n
Is Numpy full slower than Numpy zeros and Numpy empty?<\/h3>\n
If you’re just filling an array with the value zero (0), then the Numpy zeros function is faster.<\/p>\n
You can check it out by timing them.<\/p>\n
\r\n%timeit np.zeros(shape = 100000000)\r\n%timeit np.full(shape = 100000000, fill_value = 0)\r\n<\/pre>\n
You can learn more about Numpy zeros in our tutorial about the np.zeros function<\/a>.<\/p>\n
Having said that, if your goal is simply to initialize an empty Numpy array (or an array with an arbitrary value), the Numpy empty function is faster.<\/p>\n
You can learn more about Numpy empty in our tutorial about the np.empty function<\/a>.<\/p>\n
Leave your other questions in the comments below<\/h5>\n
If you have questions about the Numpy full function, leave them in the comments.<\/p>\n
There’s more to learn about Numpy<\/h2>\n
This tutorial should tell you almost everything you need to know about the Numpy full function.<\/p>\n
But if you’re new to using Numpy, there’s a lot<\/em> more to learn about Numpy more generally.<\/p>\n
For example, there are several other ways to create simple arrays. You can create an empty array<\/a> with the Numpy empty function. Or you can create an array filled with zeros<\/a> with the Numpy zeros function. And obviously there are functions like np.array and np.arange.<\/p>\n
- Is Numpy full slower than Numpy zeros and Numpy empty?<\/a><\/li>\n<\/ul>\n
- Create a 2-dimensional array filled with the same number<\/a><\/li>\n
- Introduction to Numpy full<\/a><\/li>\n