- \n
- A quick review of Numpy<\/a><\/li>\n
- How to Flatten Numpy Arrays<\/a><\/li>\n
- The syntax of Numpy flatten<\/a><\/li>\n
- Numpy flatten examples<\/a><\/li>\n<\/ul>\n
Having said that, if you’re new to Numpy, I recommend reading the whole tutorial.<\/p>\n
A quick introduction to Numpy Flatten<\/h2>\n
So what does Numpy flatten do?<\/p>\n
Very simply: Numpy flatten “flattens” out a Numpy array.<\/p>\n
![\"A](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2020\/03\/numpy-flatten-visua-example.png\")
<\/p>\nTo understand this though, it helps to know a few things about Numpy.<\/p>\n
<\/a><\/p>\n
A quick review of Numpy<\/h3>\n
Let’s do a quick review of Numpy and Numpy arrays.<\/p>\n
You probably know that Numpy arrays are a type of object that hold numeric data<\/a>. Numpy arrays contain numbers in a row and column form.<\/p>\n
Here’s a visual example of a 2-dimentional numpy array.<\/p>\n
![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2020\/03\/numpy-array_2d_example.png\")
<\/p>\nNumpy arrays can be 2-dimentional like the array above, but also 1-dimentional or n-dimentional.<\/p>\n
We use can Numpy<\/a> functions to create Numpy arrays (i.e., arrays of numeric data). And we can also use Numpy functions and methods to manipulate Numpy arrays.<\/p>\n
Creating Numpy arrays<\/h3>\n
There are a variety of Numpy functions for creating Numpy arrays. For example, we can create arrays that contain all zeros<\/a> using the np.zeros function. We can create Numpy arrays within a numeric range<\/a> using np.arange. And we can create Numpy arrays out of Python lists using np.array<\/a>. <\/p>\n
Those are just a few methods (there are quite a few others).<\/p>\n
Numpy arrays have a “shape”<\/h4>\n
It’s important to understand that Numpy arrays have a “shape.” <\/p>\n
The shape of an array is essentially the number of rows and columns.<\/p>\n
For example, an array with a shape of
(2,3)<\/code> has 2 rows and 3 columns.<\/p>\nReshaping Numpy arrays<\/h3>\n
Often, when working with Numpy arrays, we need to reshape the array. That is, we need to re-organize the elements of the array into a new “shape” with a different number of rows and columns.<\/p>\n
One common way is by using the Numpy reshape method<\/a>, which enables us to specify the exact number of rows and columns of the output array. The reshape method gives us a lot of control over the output.<\/p>\n
But there’s actually another simple way to reshape your array.<\/p>\n
Let’s say you want to reshape your array from a 2-dimensional array (with multiple rows and columns) into a 1-dimensional array, with only one row.<\/p>\n
There’s an easy way to do that. You can use the Numpy flatten method.<\/p>\n
<\/a><\/p>\n
How to Flatten Numpy Arrays<\/h2>\n
So again, what does flatten do?<\/p>\n
It just “flattens” out a Numpy array.<\/p>\n
Numpy flatten changes the shape of a Numpy array from a multi-dimensional array, to a 1-dimensional array.<\/p>\n
<\/p>\nIt’s a very simple tool. It really only does one thing, and the syntax is very straightforward.<\/p>\n
Let’s take a look.<\/p>\n
<\/a><\/p>\n
The syntax of Numpy flatten<\/h2>\n
The syntax is very simple, but before we get into it, I need to remind you of one thing.<\/p>\n
A quick note about importing Numpy<\/h4>\n
We’re going to need to use a couple of Numpy functions going forward. <\/p>\n
Exactly how we call those functions depends on how we import Numpy.<\/p>\n
In the rest of this tutorial, we’re going to assume that you’ve imported Numpy with the following code:<\/p>\n
\r\nimport numpy as np\r\n<\/pre>\n
This is the common convention among almost all Python programmers who use Numpy.<\/p>\n
When we import Numpy with the code
import numpy as np<\/code>, we can use the prefixnp<\/code> when we call our Numpy functions.<\/p>\nAgain, that’s the convention we’ll be using in the rest of this tutorial.<\/p>\n
Numpy Flatten syntax<\/h3>\n
When we call the Numpy flatten method, we need to call it as a method based of of an existing Numpy array.<\/p>\n
So let’s say that you have a Numpy array called
my_array<\/code>.<\/p>\nYou can type the name of the array, then use dot notation to call the method.<\/p>\n
![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2020\/03\/numpy-flatten-syntax-explanation.png\")
<\/p>\nSo if you have a Numpy array called
my_array<\/code>, you can call the method with the codemy_array.flatten()<\/code>.<\/p>\nThat’s basically it, with the exception of one parameter.<\/p>\n
Let’s quickly talk about that.<\/p>\n
The parameters of Numpy flatten<\/h3>\n
The flatten method only has one parameter: the
order<\/code> parameter.<\/p>\nLet’s talk about it.<\/p>\n
order<\/code> (optional)<\/h5>\nThe
order<\/code> parameter enables you to specify the order of the observations in the flattened output array.<\/p>\nKeep in mind that the
order<\/code> parameter is optional. If you don’t use it in your syntax, it will default toorder = 'C'<\/code>.<\/p>\nHowever, you have a few options for the
order<\/code> parameter. Let’s talk about two of them.<\/p>\norder = ‘C’<\/h6>\n
If you set
order = 'C'<\/code>, the flatten method will flatten the elements out in a row first fashion.<\/p>\n![\"A](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2020\/03\/numpy-flatten-order-c.png\")
<\/p>\n(Note that it’s called the
'C'<\/code> method because this is how data are stored and retrieved in the C programming language.)<\/p>\nThis is the default behavior, so if you do not use the
order<\/code> parameter in your syntax, Numpy flatten will automatically flatten your array by row.<\/p>\norder = ‘F’<\/h6>\n
If you set
order = 'F'<\/code>, the flatten method will flatten the elements out in a column first fashion.<\/p>\n![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2020\/03\/numpy-flatten-order-F.png\")
<\/p>\n(Note that it’s called the
'F'<\/code> method because this is how data are stored and retrieved in the Fortran programming language. I know. It’s old school.)<\/p>\nThe output of Numpy flatten<\/h5>\n
The flatten method returns a new array with the elements collapsed into one dimension.<\/p>\n
So remember: the flatten method will not directly reshape your original array. It produces a new array.<\/p>\n
<\/a><\/p>\n
Examples of how to use Numpy Flatten<\/h2>\n
Ok. Now that we’ve taken a look at the syntax, let’s look at some examples.<\/p>\n
Examples:<\/strong><\/p>\n
- \n
- Use numpy flatten to flatten a 2-d array<\/a><\/li>\n
- Flatten an array by row<\/a><\/li>\n
- Flatten an array by column<\/a><\/li>\n<\/ul>\n
Run this code first to import Numpy<\/h4>\n
Before we run the examples, we need to import Numpy.<\/p>\n
To import Numpy, run this code:<\/p>\n
\r\nimport numpy as np\r\n<\/pre>\n
By importing this code, we will be able to use the alias ‘
np<\/code>‘ in our syntax. We can use that ‘np<\/code>‘ as a prefix before our Numpy functions.<\/p>\n(Note, this is a common convention among Numpy users.)<\/p>\n
Run this code to create a 2D array<\/h5>\n
Before we run our example, we also need to create a Numpy array.<\/p>\n
To do this, we’ll use the Numpy arange function to create an array of integers<\/a>, and we’ll use the Numpy reshape method to reshape it into 2-dimensions<\/a>.<\/p>\n
\r\nmy_array = np.arange(start = 1, stop = 7).reshape([2,3])\r\n<\/pre>\n
And let’s 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
This is a simple, 2D array that contains the values 1 to 6.<\/p>\n
Ok. Now let’s look at some examples.<\/p>\n
<\/a><\/p>\n
EXAMPLE 1: Use numpy flatten to flatten a 2-d array<\/h3>\n
First, we’ll just do a simple example.<\/p>\n
Here, we’re going to flatten a our 2D numpy array,
my_array<\/code>.<\/p>\n\r\nmy_array.flatten()\r\n<\/pre>\n
OUT:<\/p>\n
\r\narray([1, 2, 3, 4, 5, 6])\r\n<\/pre>\n
Explanation<\/h6>\n
So what happened here?<\/p>\n
Our input array,
my_array<\/code>, is a 2-dimensional array with 2 rows and 3 columns.<\/p>\nWhen we use the flatten function, it just flattens it out. <\/p>\n
![\"A](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2020\/03\/numpy-flatten-simple-example-1.png\")
<\/p>\nKeep in mind that it does this row-wise by default.<\/p>\n
Ultimately, the flatten method produces a new output array that has been “flattened” into 1 dimension.<\/p>\n
<\/a><\/p>\n
EXAMPLE 2: Flatten an array by row<\/h3>\n
Next, let’s use the “
order<\/code>” parameter. <\/p>\nHere, we’ll set
order = 'C'<\/code> to explicitly flatten the input array by row. (Remember from the syntax explanation above<\/a> that when we setorder = 'C'<\/code>, it flattens the array row-wise).<\/p>\nLet’s take a look.<\/p>\n
\r\nmy_array.flatten(order = 'C')\r\n<\/pre>\n
OUT:<\/p>\n
\r\narray([1, 2, 3, 4, 5, 6])\r\n<\/pre>\n
Explanation<\/h6>\n
When we set
order = 'C'<\/code>, the flatten method flattens the array row-wise.<\/p>\n![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2020\/03\/numpy-flatten-example-order-C.png\")
<\/p>\nSo the output is just a 1D array, with the elements reordered row-wise based on the input array.<\/p>\n
(Note that the output here is the same as the output for example 1<\/a>. That’s because if we don’t use the
order<\/code> parameter, Numpy flatten defaults toorder = 'C'<\/code>.)<\/p>\n<\/a><\/p>\n
EXAMPLE 3: Flatten an array by column<\/h3>\n
Finally, let’s use Numpy flatten with
order = 'F'<\/code>.<\/p>\nThis will flatten the elements of the array column-wise.<\/p>\n
\r\nmy_array.flatten(order = 'F')\r\n<\/pre>\n
OUT:<\/p>\n
\r\narray([1, 4, 2, 5, 3, 6])\r\n<\/pre>\n
Explanation<\/h6>\n
By setting
order = 'F'<\/code>, we’re instructing the flatten method to flatten out the elements column wise<\/i>.<\/p>\n![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2020\/03\/numpy-flatten-example-order-F_v2.png\")
<\/p>\nNotice that in the output array, the elements are arranged differently from the output in example 2<\/a>.<\/p>\n
In example 2, the elements were re-arranged row-wise.<\/p>\n
However here, when we set
order = 'F'<\/code>, the elements have been re-arranged and flattened column-wise.<\/p>\n<\/a><\/p>\n
Leave your questions in the comments below<\/h3>\n
Do you still have questions about the Numpy flatten method?<\/p>\n
Leave your questions in the comments section below.<\/p>\n
Join our course to learn more about Numpy<\/h2>\n
The examples you’ve seen in this tutorial should be enough to get you started, but if you’re serious about learning Numpy, you should enroll in our premium course called Numpy Mastery<\/em>.<\/p>\n
There’s a lot more to learn about Numpy, and Numpy Mastery<\/em> will teach you everything, including:<\/p>\n
- \n
- How to create Numpy arrays<\/li>\n
- How to use the Numpy random functions<\/li>\n
- What the “Numpy random seed” function does<\/li>\n
- How to reshape, split, and combine your Numpy arrays<\/li>\n
- and more …<\/li>\n<\/ul>\n
Moreover, it will help you completely master<\/em> the syntax within a few weeks. You’ll discover how to become “fluent” in writing Numpy code.<\/p>\n
Find out more here:<\/p>\n
\nLearn More About Numpy Mastery<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
This tutorial will show you how to use the Numpy flatten method. It will explain the syntax of the method and show you how to flatten an array in Numpy. The following is a table of contents. If you’re looking for something specific, you can click on any of the links to jump to the … Read more<\/a><\/p>\n","protected":false},"author":1,"featured_media":5083,"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,62,58],"tags":[],"publishpress_future_action":{"enabled":false,"date":"2024-05-18 05:57:08","action":"change-status","newStatus":"draft","terms":[],"taxonomy":"category"},"_links":{"self":[{"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/posts\/4883"}],"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=4883"}],"version-history":[{"count":0,"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/posts\/4883\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/media\/5083"}],"wp:attachment":[{"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/media?parent=4883"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/categories?post=4883"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/tags?post=4883"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
- Flatten an array by row<\/a><\/li>\n
- How to Flatten Numpy Arrays<\/a><\/li>\n