- \n
- Introduction<\/a><\/li>\n
- Syntax<\/a><\/li>\n
- Examples<\/a><\/li>\n
- Frequently Asked Questions<\/a><\/li>\n<\/ul>\n
<\/a><\/p>\n
A Quick Introduction to Numpy Load<\/h2>\n
The Numpy load function is pretty straight forward: it “loads” Numpy arrays from Numpy storage files (i.e.,
.npy<\/code> files and.npz<\/code> files).<\/p>\nThat being the case, let’s quickly review stored Numpy files.<\/p>\n
A quick review of Numpy and stored Numpy files<\/h3>\n
As you probably know, Numpy is a data science package for Python<\/a> that is used for numerical data manipulation and analysis.<\/p>\n
When we use Numpy, we use it inside our Python working environment.<\/p>\n
But sometimes, we need to store our data in an external file that we can put on a computer disk for long term storage. These long-term files that store Numpy array data are
.npy<\/code> and.npz<\/code> files. We can create.npy<\/code> and.npz<\/code> files with Numpy save<\/a> and Numpy savez<\/a>.<\/p>\nLater though, if we want to work with those stored arrays again, we need to re-load those array files from those
.npy<\/code> or.npz<\/code> files back into our working environment.<\/p>\nHow do we do this?<\/p>\n
We do it with Numpy load.<\/p>\n
![\"A](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2099\/04\/numpy-load_simple-visual-example.png\")
<\/p>\nSo essentially, we put Numpy array data in long-term storage with Numpy save, and we can load it back into our working environment later with Numpy load.<\/p>\n
Numpy load is fairly easy to use, but a few details depend on how exactly you use the syntax.<\/p>\n
Let’s take a look at it.<\/p>\n
<\/a><\/p>\n
The syntax of Numpy Load<\/h2>\n
Here, we’ll look at the exact syntax of Numpy load including some of the details like optional parameters.<\/p>\n
A quick note<\/h4>\n
One note about the syntax.<\/p>\n
Whenever we use a Python package such as Numpy, we need to load it into our environment before we can use it.<\/p>\n
Exactly how<\/em> we load a package actually impacts the syntax.<\/p>\n
The reason for this is because we often import a package with an alias<\/em>.<\/p>\n
In the case of Numpy, we typically import it with the alias
np<\/code>, like this:<\/p>\n\r\nimport numpy as np\r\n<\/pre>\n
Again, this is important, because when we import Numpy like this, it allows us to call Numpy functions with the prefix
np<\/code>.<\/p>\nEverything else going forward in this tutorial assumes that you’ve imported Numpy with the
import<\/code> statement shown above.<\/p>\nnp.load syntax<\/h3>\n
In the simplest case, the syntax for Numpy load is simple.<\/p>\n
Assuming that you’ve imported Numpy with the alias
np<\/code>, you type the function asnp.load()<\/code>.<\/p>\nInside the parenthesis, you provide the name of the
.npy<\/code> or.npz<\/code> file that you want to load.<\/p>\n![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2099\/04\/Screen-Shot-2022-08-10-at-11.35.39-PM.png\")
<\/p>\nThe first argument to the function is the name of the file from which you want to load your data.<\/p>\n
Then there are a few optional parameters that you can use to modify the behavior of the function.<\/p>\n
<\/a><\/p>\n
The Parameters and Inputs of Numpy Load<\/h3>\n
Let’s look quickly at the parameters of Numpy load:<\/p>\n
- \n
filename<\/code><\/li>\nmmap_mode<\/code><\/li>\nallow_pickle<\/code><\/li>\nfix_imports<\/code><\/li>\nencoding<\/code><\/li>\n<\/ul>\nfilename<\/code> (required)<\/h6>\nThe
filename<\/code> argument is the first input to the function, and it is required.<\/p>\nKeep in mind that this argument is a positional argument. Python assumes that the first input to Numpy load is the name of the file you want to load.<\/p>\n
This filename will typically be a
.npy<\/code> file or an.npz<\/code> file.<\/p>\nmmap_mode<\/code><\/h6>\nThe
mmap_mode<\/code> parameter controls whether or not the function uses memory mapping<\/a>.<\/p>\nBy default, this is set to
mmap_mode = None<\/code>.<\/p>\nOther possible arguments to this parameter are: <\/p>\n
- \n
- \u2018r+\u2019<\/li>\n
- \u2018r\u2019<\/li>\n
- \u2018w+\u2019<\/li>\n
- \u2018c\u2019<\/li>\n<\/ul>\n
If you use any of these arguments, Numpy load will memory map the file using the mode that’s specified by the argument that you choose.<\/p>\n
Note that according to the official documentation, “memory mapping is especially useful for accessing small fragments of large files without reading the entire file into memory.”<\/p>\n
allow_pickle<\/code><\/h6>\nThis parameter controls whether the function will be able to load “pickled” arrays stored in an
npy<\/code> ornpz<\/code> file.<\/p>\nBy default, this parameter is set to
allow_pickle = False<\/code>. <\/p>\nLoading pickled data can cause security issues, which is one reason why this parameter is set to
False<\/code> by default.<\/p>\nfix_imports<\/code><\/h6>\nThe
fix_imports<\/code> parameter is helpful if you attempt to load pickled data that was stored on a Python 2 system into a Python 3 system.<\/p>\nBy default, this parameter is set to
fix_imports = True<\/code>. <\/p>\nencoding<\/code><\/h6>\nThis parameter controls what encoding
np.load<\/code> uses when it reads Python 2 strings.<\/p>\nBy default, this is set to
encoding='ASCII'<\/code>.<\/p>\nNumpy Load Output<\/h3>\n
Numpy load returns the Numpy arrays that are stored in the file.<\/p>\n
As you’ll see in the examples, this can be either a single numpy array, in the case of an
.npy<\/code> file.<\/p>\nOr it can be multiple arrays, in the case of an
.npz<\/code> file. In this case, you will be able to access the arrays by name, using the stored name of the array as a “key” (much like a dictionary).<\/p>\nYou’ll see an example of this in example 2<\/a>.<\/p>\n
<\/a><\/p>\n
Examples of How to Use Numpy Load<\/h2>\n
Now that you’ve seen the syntax, let’s look at some simple examples of how to use Numpy load.<\/p>\n
Examples:<\/strong><\/p>\n
- \n
- Load a single Numpy array from an
.npy<\/code> file<\/a><\/li>\n- Load a multiple Numpy arrays from an .npz file, with specific array names<\/a><\/li>\n<\/ul>\n
Run this code to import Numpy<\/h4>\n
Before you run the examples, you’ll need to run some preliminary setup code.<\/p>\n
Specifically, you need to import Numpy.<\/p>\n
You can do that with this code:<\/p>\n
\r\nimport numpy as np\r\n<\/pre>\n
Remember: when we import Numpy with the alias
np<\/code>, we can usenp<\/code> as a prefix when we call the function. I explained this in the syntax section above.<\/p>\n<\/a><\/p>\n
EXAMPLE 1: Load a single Numpy array from an .npy file<\/h3>\n
In this example, we’re going to load a single numpy array from an
.npy<\/code> file.<\/p>\nThis will require a few steps. We will:<\/p>\n
- \n
- create a Numpy array<\/li>\n
- save the Numpy array to an
.npy<\/code> file<\/li>\n- load the array using Numpy load<\/li>\n<\/ul>\n
Let’s do each of those, one at a time.<\/p>\n
Create Array<\/h4>\n
First, we’l create a Numpy simple array that we can store, and then load.<\/p>\n
To do this, we’ll use the Numpy array function<\/a> to manually create an array with a specific set of values.<\/p>\n
We’ll call np.array, and store the array with the name,
my_array<\/code>.<\/p>\n\r\n# CREATE NUMPY ARRAY\r\nmy_array = np.array([[0,2,4],[1,3,5]])\r\n<\/pre>\n
Now, let’s print it out:<\/p>\n
\r\nprint(my_array)\r\n<\/pre>\n
OUT:<\/p>\n
\r\n[[0 2 4]\r\n [1 3 5]]\r\n<\/pre>\n
This is a simple array with 2 rows and 3 columns. <\/p>\n
We’ll be able to save this with Numpy save<\/a>, and then load it with Numpy load.<\/p>\n
Create npy file<\/h4>\n
Now, we’ll save our Numpy array in order to create an
.npy<\/code> file.<\/p>\n\r\nnp.save('my_array_temp.npy', my_array)\r\n<\/pre>\nHere, we’ve called np.save and created an
.npy<\/code> file calledmy_array_temp.npy<\/code>.<\/p>\nLoad npy file<\/h4>\n
Now, we’re going to load our Numpy array by calling
np.load<\/code> on the file we just created,my_array_temp.npy<\/code>.<\/p>\n\r\nnp.load('my_array_temp.npy')\r\n<\/pre>\nOUT:<\/p>\n
\r\narray([[0, 2, 4],\r\n [1, 3, 5]])\r\n<\/pre>\n
As you can see, when you call np.load, it loads the array stored in the .npy file to your Python environment. Remember: this is the array that we created previously and stored with Numpy save.<\/p>\n
Importantly, the way that I’ve called np.load here, the array has simply been sent to the console.<\/p>\n
If you want to keep that array with a variable name, you need to pass the output to a variable, like this:<\/p>\n
\r\nmy_reloaded_array = np.load('my_array_temp.npy')\r\n<\/pre>\n<\/a><\/p>\n
EXAMPLE 2: Load a multiple Numpy arrays from an .npz file, with specific array names<\/h3>\n
In this example, we’re going to load two<\/em> Numpy arrays. This time, we’re going to load our arrays from an
.npz<\/code> file, where we’ve stored the arrays with specific names<\/a>.<\/p>\nAgain: this will require multiple steps. We will:<\/p>\n
- \n
- create two Numpy arrays<\/li>\n
- save the arrays to an
.npz<\/code> file, with specific names<\/em><\/li>\n- load the arrays using Numpy load<\/li>\n<\/ul>\n
Let’s do it.<\/p>\n
Create Arrays<\/h4>\n
For the first step of this example, we’re going to create two Numpy arrays.<\/p>\n
Here, we’ll create a 1-dimensional of integers using Numpy arange<\/a>.<\/p>\n
We’ll also create an array with the logs of those numbers<\/a> using Numpy log.<\/p>\n
\r\ninteger_array = np.arange(start = 1, stop = 6)\r\nlog_array = np.log(integer_array)\r\n<\/pre>\n
And let’s print those arrays out:<\/p>\n
\r\nprint(integer_array)\r\nprint(log_array)\r\n<\/pre>\n
OUT:<\/p>\n
\r\n[1 2 3 4 5]\r\n\r\n[0. 0.69314718 1.09861229 1.38629436 1.60943791]\r\n<\/pre>\n
We’re going to save these arrays with specific names, using Numpy savez<\/a>.<\/p>\n
Create npz file<\/h4>\n
Here, we’re going to use Numpy savez to save both of these Numpy arrays to a single
.npz<\/code> file.<\/p>\nMoreover, we’re going to save those files with specific names<\/em> inside the
.npz<\/code> file.<\/p>\n\r\nnp.savez('my_arrays_temp.npz', int_arr = integer_array, log_arr = log_array)\r\n<\/pre>\nTo learn more about how this works, you can read our tutorial about Numpy savez<\/a>.<\/p>\n
Load the Arrays<\/h4>\n
And now that we have the arrays stored to an
npz<\/code> file, we’ll load the arrays with Numpy load.<\/p>\n\r\nloaded_arrays = np.load('my_arrays_temp.npz')\r\n<\/pre>\nHere, we’ve loaded the
npz<\/code> file to the variable calledloaded_arrays<\/code>.<\/p>\nWhen we load an npz file like this, we can inspect the contents using the
files<\/code> attribute:<\/p>\n\r\nloaded_arrays.files\r\n<\/pre>\n
OUT:<\/p>\n
\r\n['int_arr', 'log_arr']\r\n<\/pre>\n
As you can see, there are two arrays in this loaded npz file. These are the Numpy arrays that we stored in the previous section using Numpy save.<\/p>\n
To retrieve the contents of the arrays, we can treat
loaded_arrays<\/code> like a container, and use the file names we just printed out as the keys. This will retrieve the stored numpy arrays:<\/p>\n\r\nloaded_arrays['array_2d']\r\nloaded_arrays['linspace_array_1d']\r\n<\/pre>\n
OUT:<\/p>\n
\r\narray([1, 2, 3, 4, 5])\r\n\r\narray([0., 0.69314718, 1.09861229, 1.38629436, 1.60943791])\r\n<\/pre>\n
Here, we’ve used the file names associated with
loaded_arrays<\/code>, and loaded them by referencing the file names like container keys. Provide the file name and it retrieves the stored Numpy array.<\/p>\n<\/a><\/p>\n
Frequently asked questions about Numpy Load<\/h2>\n
Now that you’ve learned about Numpy load and seen some examples, let’s review some frequently asked questions about the function.<\/p>\n
Frequently asked questions:<\/strong><\/p>\n
- \n
- How do you load Numpy data from a text file?<\/a><\/li>\n<\/ul>\n
<\/a><\/p>\n
Question 1: How do you load Numpy data from a text file?<\/h3>\n
Numpy load works with
.npy<\/code> or.npz<\/code> files, but if you want to load numeric data that’s stored in a text file, you need to use Numpy loadtxt.<\/p>\nTo learn more, you can read our tutorial about Numpy loadtxt<\/a>.<\/p>\n
Leave your other questions in the comments below<\/h5>\n
Do you have other questions about Numpy load? <\/p>\n
If so, leave your questions in the comments section below.<\/p>\n
Join our course to learn more about Numpy<\/h2>\n
In this tutorial, I’ve shown you how to use Numpy load.<\/p>\n
Numpy load is useful if you strictly need to load a Numpy array, but if you really want to master numeric data manipulation in Python, you’ll need to learn a lot more Numpy.<\/p>\n
That said, if you’re serious about learning Numpy, 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 Numpy axes work<\/li>\n
- What the “Numpy random seed” function does<\/li>\n
- How to use the Numpy random functions<\/li>\n
- How to reshape, split, and combine your Numpy arrays<\/li>\n
- Applying mathematical operations on Numpy arrays<\/li>\n
- and more …<\/li>\n<\/ul>\n
The course will also provide you with our unique practice system. This practice system will enable you to memorize<\/em> all of the Numpy syntax that you learn.<\/p>\n
If you’re struggled to remember Numpy syntax, this is the course you’ve been looking for.<\/p>\n
If you practice like we show you, you’ll memorize all of the critical Numpy syntax in only a few weeks.<\/p>\n
Find out more here:<\/p>\n
<\/p>\n
\nLearn More About Numpy Mastery<\/a>\n<\/p>\n
<\/strong><\/p>\n","protected":false},"excerpt":{"rendered":"
In this tutorial, I’ll show you how to use Numpy load to load Numpy arrays from stored npy or npz files. So I’ll explain what Numpy load does, I’ll explain the syntax of np.load, and I’ll show you step-by-step examples of how to use it. If you need something specific, you can click on any … Read more<\/a><\/p>\n","protected":false},"author":1,"featured_media":6908,"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,79,62,58],"tags":[],"publishpress_future_action":{"enabled":false,"date":"2024-05-23 22:06:40","action":"change-status","newStatus":"draft","terms":[],"taxonomy":"category"},"_links":{"self":[{"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/posts\/6890"}],"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=6890"}],"version-history":[{"count":0,"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/posts\/6890\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/media\/6908"}],"wp:attachment":[{"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/media?parent=6890"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/categories?post=6890"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/tags?post=6890"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
- load the arrays using Numpy load<\/li>\n<\/ul>\n
- load the array using Numpy load<\/li>\n<\/ul>\n
- Load a multiple Numpy arrays from an .npz file, with specific array names<\/a><\/li>\n<\/ul>\n
- Load a single Numpy array from an
- Syntax<\/a><\/li>\n