- \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 Loadtxt<\/h2>\n
Numpy loadtxt is a function for the Numpy package. <\/p>\n
As you’re probably aware, Numpy is a package for the Python<\/a> programming language that enables a programmer to work with Numeric data.<\/p>\n
This package has a variety of tools for creating, aggregating, reshaping, and manipulating numeric data. It’s one of the primary toolkits for doing data science and machine learning in Python.<\/p>\n
And although it’s primarily used to wrangle and manipulate numeric data, before we do that data wrangling, we often need to get<\/em> our numeric data from some source.<\/p>\n
That’s where Numpy loadtxt comes in.<\/p>\n
Load data stored in a text file with Numpy Loadtxt<\/h4>\n
Numpy loadtxt enables you to load<\/em> numeric data that’s stored in a text<\/em> file.<\/p>\n
So, for example, if you have row-and-column data that’s stored in a text file, where the numbers are separated by commas (a so-called
csv<\/code> file), you can use Numpy loadtxt to load the data into your Python environment.<\/p>\n![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2099\/04\/numpy-loadtxt_simple-visual-example.png\")
<\/p>\nBut this is a fairly flexible tool that gives you a lot of fine-grained control over how you import your text data.<\/p>\n
And how exactly you use it depends on the syntax.<\/p>\n
That being the case, let’s take a look at the syntax of the function.<\/p>\n
<\/a><\/p>\n
The syntax of Numpy Loadtxt<\/h2>\n
In this section of the tutorial, we’ll look at the syntax of Numpy loadtxt.<\/p>\n
We’ll look at the high-level syntax, and we’ll also look at some optional parameters that change how the function works.<\/p>\n
A quick note about the syntax<\/h4>\n
One quick reminder about the syntax.<\/p>\n
When we use Numpy (or any other Python package), we need to import that package first.<\/p>\n
And how we import a package will impact the exact syntax that we use.<\/p>\n
For example, when we import Numpy, we almost always do it with this code:<\/p>\n
\r\nimport numpy as np\r\n<\/pre>\n
This is the standard convention among Python users.<\/p>\n
When we import Numpy like this, it enables us to call Numpy functions with the prefix
np<\/code>.<\/p>\nI’m reminding you of this, because (as I noted) this changes the syntax slightly.<\/p>\n
Going forward, I’m going to assume that you’ve imported Numpy like this, with the alias
np<\/code>.<\/p>\nnp.loadtxt syntax<\/h3>\n
Let’s start with the high-level syntax.<\/p>\n
In the simplest case, we can call Numpy loadtxt with the code
np.loadtxt()<\/code>.<\/p>\n![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2099\/04\/numpy-loadtxt-syntax.png\")
<\/p>\nIn this simple case, the first (and only required) input to the function is the name of the text file from which you want to load your data.<\/p>\n
However, np.loadtxt has several optional parameters that enable you to fine-tune how the function works.<\/p>\n
<\/a><\/p>\n
The Parameters and Inputs of Numpy Loadtxt<\/h3>\n
Here, let’s take a look at the inputs and optional parameters of Numpy loadtxt.<\/p>\n
- \n
filename<\/code><\/li>\ndtype<\/code><\/li>\ncomments<\/code><\/li>\ndelimiter<\/code><\/li>\nconverters<\/code><\/li>\nskiprows<\/code><\/li>\nusecols<\/code><\/li>\nunpack<\/code><\/li>\nnadmin<\/code><\/li>\nencoding<\/code><\/li>\nmax_rows<\/code><\/li>\nquotechar<\/code><\/li>\nlike<\/code><\/li>\n<\/ul>\nLet’s look at each of these, one at a time.<\/p>\n
filename<\/code> (required)<\/h6>\nThe
filename<\/code> argument is the first input to the Numpy loadtxt.<\/p>\nAs mentioned above, this is the name of the input text file.<\/p>\n
It’s important to point out that this argument is positional<\/em>. Numpy automatically assumes that the first input to the function is the name of the input text file.<\/p>\n
dtype<\/code><\/h6>\nThe
dtype<\/code> parameter specifies the data type of the output Numpy array.<\/p>\nBy default, this is set to
dtype = 'float'<\/code><\/p>\ncomments<\/code><\/h6>\nThe
comments<\/code> parameter enables you to indicate a character or string of characters that designate a comment in the input file.<\/p>\nBy default, this is set to
comments = '#'<\/code>.<\/p>\ndelimiter<\/code><\/h6>\nThe
delimiter<\/code> specifies the delimiter character that separates the columns in the input text file. <\/p>\nBy default, this is set to
delimiter = None<\/code>. With this default, np.loadtxt assumes that whitespace separates the columns.<\/p>\nIf you have a comma separated file, you would use
delimiter = ','<\/code>.<\/p>\n(I’ll show you an example of this in the examples section<\/a>.)<\/p>\n
converters<\/code><\/h6>\nThe
converters<\/code> parameter enables you to specify a function that will “convert” the strings by operating on them in some way.<\/p>\nAlternatively, instead of providing a single function to operate on all columns, you can indicate a specific converter function for any column of the input.<\/p>\n
skiprows<\/code><\/h6>\nThe
skiprows<\/code> parameter specifies the number of rows in the input file to “skip” as it parses the text data.<\/p>\nBy default, this is set to
skiprows = 0<\/code>.<\/p>\nusecols<\/code><\/h6>\nThe
usecols<\/code> parameter specifies which columns to retrieve from the input file.<\/p>\nBy default, this is set to
usecols = None<\/code>, which reads all of the columns.<\/p>\nIf you want to specify specific columns, you can provide the numeric index inside of a list or tuple. For example, to extract columns 1 and 3, you would use
usecols = [1,3]<\/code>. (Remember: Python indexing starts at 0).<\/p>\nunpack<\/code><\/h6>\nThe
unpack<\/code> parameter allows you to “unpack” the text file into multiple Numpy arrays (as opposed to one array).<\/p>\nBy default, this is set to
unpack = False<\/code>.<\/p>\nIf you set this to
unpack = True<\/code>, you will be able to unpack the output into multiple arrays. For example:<\/p>\n\r\nmyarray_1, myarray_2 = np.loadtxt(...)\r\n<\/pre>\n
ndmin<\/code><\/h6>\nThe
ndmin<\/code> parameter specifies the minimum number of dimensions of the output array.<\/p>\nBy default, this is set to
ndmin = 0<\/code>.<\/p>\nAlternatively, the other valid arguments are
1<\/code> or2<\/code>.<\/p>\nencoding<\/code><\/h6>\nThe
encoding<\/code> parameter enables you to specify the encoding of the text file.<\/p>\nBy default, this is set to
encoding = 'bytes'<\/code>.<\/p>\nIf you override this, then the strings will be treated as unicode, and the strings will be processed by any specified converters.<\/p>\n
max_rows<\/code><\/h6>\nThe
max_rows<\/code> parameter specifies the maximum number of rows to read from the text file (after any rows that are skipped byskiprows<\/code>).<\/p>\nBy default, this is set to
max_rows = None<\/code>, which reads all of the rows.<\/p>\nquotechar<\/code><\/h6>\nThe
quotechar<\/code> parameter enables you to specify a character that designates a quoted item.<\/p>\nBy default, this is set to
quotechar = None<\/code>, which disables quoting for the load process.<\/p>\nlike<\/code><\/h6>\nThe
like<\/code> parameter enables you to specify an object type besides a Numpy array, so that the output is an array-like object, instead of a proper Numpy array.<\/p>\n<\/a><\/p>\n
Examples of How to Use Numpy Loadtxt<\/h2>\n
Now that we’ve looked at the syntax and parameters of Numpy loadtxt, let’s look at some examples.<\/p>\n
Examples:<\/strong><\/p>\n
- \n
- Load a Numpy array from a text file<\/a><\/li>\n
- Load an array from a text file using a specific delimiter<\/a><\/li>\n
- Use a specific data type for the loaded data<\/a><\/li>\n
- Use a specific character to identify comments in the text file being loaded<\/a><\/li>\n<\/ul>\n
Setup Code (run this first)<\/h4>\n
Before you run the examples, you’ll need to run some setup code.<\/p>\n
Specifically, you need to import Numpy and create a Numpy array that we can work with.<\/p>\n
Import Numpy<\/h5>\n
First, you can import Numpy with this code:<\/p>\n
\r\nimport numpy as np\r\n<\/pre>\n
Remember what I wrote earlier in this tutorial: importing Numpy like this enables us to call Numpy functions with the prefix
np<\/code>. <\/p>\nCreate Numpy Array<\/h5>\n
Second, we’ll create a Numpy array that we can use in our examples.<\/p>\n
Here, we’ll create a 2D array with the numbers from 1 to 6, using the Numpy array function<\/a>:<\/p>\n
\r\nmy_array = np.array([[1,2,3],[4,5,6]])\r\n<\/pre>\n
And let’s print it out to take a look:<\/p>\n
\r\nprint(my_array)\r\n<\/pre>\n
OUT:<\/p>\n
\r\n[[1 2 3]\r\n [4 5 6]]\r\n<\/pre>\n
As you can see, this is a simple 2-dimensional array with six values.<\/p>\n
In all of the examples, we’re actually going to use Numpy savetxt first to save this array to a text file<\/a>. Then, we’ll load it back into Python with Numpy loadtxt.<\/p>\n
<\/a><\/p>\n
EXAMPLE 1: Load a Numpy array from a text file<\/h3>\n
First, we’ll start with a simple example.<\/p>\n
We’ll load a Numpy array from a simple text file.<\/p>\n
As in all of our examples, for the purposes of illustration, this will have two steps:<\/p>\n
- \n
- save a Numpy array to a text file<\/li>\n
- load the array back into our environment, with Numpy loadtxt<\/li>\n<\/ul>\n
Save Numpy array to Text File<\/h4>\n
First, we’re going to save our Numpy array to a text file:<\/p>\n
\r\nnp.savetxt('my_numpy_data.txt', my_array)\r\n<\/pre>\nIf you want to understand how this works, I recommend reading our tutorial about Numpy savetxt<\/a>.<\/p>\n
(Note: you should be able to find this file on your computer, and open it with a text editor.)<\/p>\n
Load Numpy array from Text File<\/h4>\n
Now, we’re going to load the file back into our Python environment with Numpy loadtxt.<\/p>\n
\r\nnp.loadtxt('my_numpy_data.txt')\r\n<\/pre>\nOUT:<\/p>\n
\r\narray([[1., 2., 3.],\r\n [4., 5., 6.]])\r\n<\/pre>\n
As you can see, Numpy loadtxt has loaded the data back into our environment as a Numpy array.<\/p>\n
Notice as well, that the numbers are all formatted as floats, which is the default.<\/p>\n
We’ll change the number format in one of the future examples.<\/p>\n
<\/a><\/p>\n
EXAMPLE 2: Load an array from a text file using a specific delimiter<\/h3>\n
Next, we’re going to load a file that has a specific delimiter between the columns.<\/p>\n
By default, Numpy loadtxt assumes that the columns are separated by whitespace.<\/p>\n
But in this example, we’ll load a file where the columns are separated by commas.<\/p>\n
You’ll notice that in the previous example<\/a>, the columns were separated by spaces by default.<\/p>\n
Here, we’ll change that so that the columns are separated by commas.<\/p>\n
Save Numpy array to Text File<\/h4>\n
First, we’re going to save our Numpy array to a text file, with commas separating the columns:<\/p>\n
\r\nnp.savetxt('my_numpy_data.txt', my_array, delimiter = ',')\r\n<\/pre>\nIf you find this file on your computer, you’ll see that the columns are separated by commas.<\/p>\n
(Again, if you want to understand how this works, I recommend reading our tutorial about Numpy savetxt<\/a>.)<\/p>\n
Load Numpy array from Text File<\/h4>\n
Next, we’ll load the file with Numpy loadtxt using the
delimiter<\/code> parameter to specify that the columns are separated by commas:<\/p>\n\r\nnp.loadtxt('my_numpy_data.txt', delimiter = ',')\r\n<\/pre>\nOUT:<\/p>\n
\r\narray([[1., 2., 3.],\r\n [4., 5., 6.]])\r\n<\/pre>\n
Here, np.loadtxt has parsed the comma-separated data, and loaded the data into a Numpy array.<\/p>\n
<\/a><\/p>\n
EXAMPLE 3: Use a specific data type for the loaded data<\/h3>\n
Now, we’re going to use the
dtype<\/code> parameter to load the numbers as integers.<\/p>\nSave Numpy array to Text File<\/h4>\n
First, we’ll save our Numpy array,
my_array<\/code>, to a text file with Numpy save. <\/p>\n\r\nnp.savetxt('my_numpy_data.txt', my_array, fmt = '%i')\r\n<\/pre>\nHere, we’ve used the
fmt<\/code> parameter to save the data as integers.<\/p>\nHowever, if you try to load the data with Numpy loadtxt, it will import the data as floats by default.<\/p>\n
To fix this, we’ll need to use the
dtype<\/code> parameter.<\/p>\nLoad Numpy array from Text File<\/h4>\n
Here, we’ll set
dtype = int<\/code>, which will cause Numpy loadtxt to load the data as integers.<\/p>\n\r\nnp.loadtxt('my_numpy_data.txt', dtype = int)\r\n<\/pre>\nOUT:<\/p>\n
\r\narray([[1, 2, 3],\r\n [4, 5, 6]])\r\n<\/pre>\n
Notice that the values in the array are loaded as integers (i.e,
int<\/code>s).<\/p>\nAnd remember: there are a variety of data types that you can select. We’ve just used integers for this particular example.<\/p>\n
<\/a><\/p>\n
EXAMPLE 4: Use a specific character to identify comments in the text file being loaded<\/h3>\n
Finally, let’s do an example where we strip out the comments in a file.<\/p>\n
Here, we’ll use the
comments<\/code> parameter to identify (and remove) comment lines in the text file.<\/p>\nSave Numpy array to Text File<\/h4>\n
First, we need to create a text file that has comment lines in it.<\/p>\n
To do this, we’ll use Numpy savetxt and add a header and footer with the
header<\/code> andfooter<\/code> parameters.<\/p>\nAdditionally, we’ll set the
comments<\/code> parameter tocomments = '** '<\/code> to specify a that'** '<\/code> designates a comment line (i.e., the header and footer lines).<\/p>\n\r\nnp.savetxt('my_numpy_data.txt'\r\n ,my_array\r\n ,header = 'This is header text'\r\n ,footer = 'This is footer text'\r\n ,comments = '** '\r\n )\r\n<\/pre>\nIf you check
my_numpy_data.txt<\/code>, you’ll see the header and footer prefixed with the comment string:<\/p>\n\r\n** This is header text\r\n1.000000000000000000e+00 2.000000000000000000e+00 3.000000000000000000e+00\r\n4.000000000000000000e+00 5.000000000000000000e+00 6.000000000000000000e+00\r\n** This is footer text\r\n<\/pre>\n
(Again, if you want to understand how this works, I recommend reading our tutorial about Numpy savetxt<\/a>.)<\/p>\n
Load Numpy array from Text File<\/h4>\n
Now, we’ll load the file using Numpy loadtxt.<\/p>\n
When we do this, we’ll set
comments = '**'<\/code> to specify that the header and footer lines, which begin with'**'<\/code>, are comments that need to be stripped out.<\/p>\n\r\nnp.loadtxt('my_numpy_data.txt', comments = '**')\r\n<\/pre>\nOUT:<\/p>\n
\r\narray([[1., 2., 3.],\r\n [4., 5., 6.]])\r\n<\/pre>\n
As you can see, when we run this code, it strips out the header and footer comment lines, and loads the numeric data into a Numpy array.<\/p>\n
<\/a><\/p>\n
Frequently asked questions about Numpy Load Text<\/h2>\n
Now that you’ve learned about Numpy loadtxt 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 a binary file instead of a text file?<\/a><\/li>\n
- How do I save Numpy array to a text file?<\/a><\/li>\n<\/ul>\n
<\/a><\/p>\n
Question 1: How do you load a binary file instead of a text file?<\/h3>\n
If you want to load your Numpy data from a binary file instead of a text file, you should use Numpy load.<\/p>\n
You can read about Numpy Load in this tutorial<\/a>.<\/p>\n
- How do I save Numpy array to a text file?<\/a><\/li>\n<\/ul>\n
- How do you load a binary file instead of a text file?<\/a><\/li>\n
- Load an array from a text file using a specific delimiter<\/a><\/li>\n
- Syntax<\/a><\/li>\n