reshape python что это
numpy.reshape¶
Gives a new shape to an array without changing its data.
a : array_like
Array to be reshaped.
newshape : int or tuple of ints
order : <‘C’, ‘F’, ‘A’>, optional
Read the elements of a using this index order, and place the elements into the reshaped array using this index order. ‘C’ means to read / write the elements using C-like index order, with the last axis index changing fastest, back to the first axis index changing slowest. ‘F’ means to read / write the elements using Fortran-like index order, with the first index changing fastest, and the last index changing slowest. Note that the ‘C’ and ‘F’ options take no account of the memory layout of the underlying array, and only refer to the order of indexing. ‘A’ means to read / write the elements in Fortran-like index order if a is Fortran contiguous in memory, C-like order otherwise.
reshaped_array : ndarray
This will be a new view object if possible; otherwise, it will be a copy. Note there is no guarantee of the memory layout (C- or Fortran- contiguous) of the returned array.
It is not always possible to change the shape of an array without copying the data. If you want an error to be raise if the data is copied, you should assign the new shape to the shape attribute of the array:
The order keyword gives the index ordering both for fetching the values from a, and then placing the values into the output array. For example, let’s say you have an array:
You can think of reshaping as first raveling the array (using the given index order), then inserting the elements from the raveled array into the new array using the same kind of index ordering as was used for the raveling.
Python: numpy.reshape() function Tutorial with examples
In this article we will discuss how to use numpy.reshape() to change the shape of a numpy array.
numpy.reshape()
Python’s numpy module provides a function reshape() to change the shape of an array,
It returns a new view object if possible, otherwise returns a copy. But in most scenario it returns a view and therefore it is very good in performance with big arrays.
Let’s understand this with more examples,
First, import the numpy module,
Converting shapes of Numpy arrays using numpy.reshape()
Use numpy.reshape() to convert a 1D numpy array to a 2D Numpy array
Let’s first create a 1D numpy array from a list,
Now suppose we want to convert this 1D array to a 2D numpy array or matrix of shape (3X3) i.e. 3 rows and 3 columns. Let’s see how to do that using reshape(),
We passed the array and a tuple (shape) as arguments to the numpy.reshape() function and it returned a new 2D view of the passed array.
New shape must be compatible with the original shape
The new shape provided in reshape() function must be compatible with the shape of the array passed.
Suppose if we are trying to convert a 1D array of length N to a 2D Numpy array of shape (R,C), then R * C must be equal to N, otherwise it will raise an error. For example,
Let’s checkout an example or incompatible conversion
We tried to create a matrix / 2D array of shape (3,2) i.e. 6 elements but our 1D numpy array had 9 elements only therefore it raised an error,
Using numpy.reshape() to convert a 1D numpy array to a 3D Numpy array
To convert a 1D Numpy array to a 3D Numpy array, we need to pass the shape of 3D array as a tuple along with the array to the reshape() function as arguments
We have a 1D Numpy array with 12 items,
Now let’s convert this 1D array to a 3D numpy array of shape (2X3X2),
Till now we have seen examples where we converted 1D array to either 2D or 3D. But using reshape() function we can convert an array of any shape to any other shape. Like,
Use numpy.reshape() to convert a 3D numpy array to a 2D Numpy array
Suppose we have a 3D Numpy array of shape (2X3X2),
Let’s convert this 3D array to a 2D array of shape 2X6 using reshape() function,
Use numpy.reshape() to convert a 2D numpy array to a 1D Numpy array
Suppose we have a 2D Numpy array of shape (3X3),
Let’s convert this 2D array to a 1D array,
numpy.reshape() returns a new view object if possible
Whenever possible numpy.reshape() returns a view of the passed object. If we modify any data in the view object then it will be reflected in the main object and vice-versa. Let’s understand this with an example,
Suppose we have a 1D numpy array,
let’s create a 2D view object of the 1D Numpy array using reshape(),
Now modify the second element in the original 1D numpy array.
Although we modified the 1D array only but this change should be visible in the 2D view object too. Let’s confirm this,
Whatever object reshape() returns, we can check its base attribute to confirm if its view or not. If base attribute is None then it is not a view object, whereas if is not None then it is a view object and base attributes points to the original array object i.e.,
numpy.reshape() & different type of order parameters
Let’s understand this with an example,
Suppose we have a 1D array,
Convert 1D to 2D array row wise with order ‘C’
When we pass the order parameter as ‘C’ (default value of order parameter), then items from input array will be read row wise i.e.
Items from 1D array were read row wise i.e.
Convert 1D to 2D array column wise with order ‘F’
When we pass the order parameter as ‘F’, then items from input array will be read column wise i.e.
Items from 1D array were read column wise i.e.
Convert 1D to 2D array by memory layout with parameter order “A”
Both ‘C’ and ‘F’ options do not consider the memory layout of the input array. Whereas, when we pass the order parameter as ‘A’, then items from the input array will be read based on internal memory layout. Let’s understand by an example,
Create a 1D numpy array
Create a 2D view object from this 1D numpy array and then get a transpose view object of that 2D array,
Now let’s convert this transposed view object to a 1D numpy array using order ‘C’ i.e. row wise based on current shape.
It read the elements row wise from the current shape of the view object and the memory layout of the original array was not considered. Now let’s convert this transposed view object to a 1D numpy array using order ‘A’ i.e. based on memory layout of original array,
It reads the elements row wise from the based on the memory layout of the original 1D array. It does not consider the current view of the input array i.e. a view object.
Convert the shape of a list using numpy.reshape()
In reshape() function we can pass a list too instead of array.For example, let’s use reshape() function to convert a list to 2D numpy array,
Now let’s convert this 2D numpy array to a list of list,
Reshape numpy arrays in Python — a step-by-step pictorial tutorial
Visualize how numpy reshapes multidimensional arrays
Dec 25, 2019 · 8 min read
How does the numpy reshape() method reshape arrays? Have you been confused or have you struggled understanding how it works? This tutorial will walk you through reshaping in numpy. If you want a pdf copy of the cheatsheet above, you can download it here.
You might also like my tutorial on reshaping pandas dataframes:
Reshape pandas dataframe with pivot_table in Python — tutorial and visualization
Convert long to wide with pd.pivot_table
Reshape pandas dataframe with melt in Python — tutorial and visualization
Visualize how pd.melt reshapes pandas dataframes from wide to long form
Create a Python numpy array
Use np.arange() to generate a numpy array containing a sequence of numbers from 1 to 12. See documentation here.
Reshape with reshape() method
Use reshape() method to res h ape our a1 array to a 3 by 4 dimensional array. Let’s use 3_4 to refer to it dimensions: 3 is the 0th dimension (axis) and 4 is the 1st dimension (axis) (note that Python indexing begins at 0). See documentation here.
Reshape along different dimensions
By default, reshape() reshapes the array along the 0th dimension (row). This behavior can be changed via the order parameter (default value is ‘C’ ). See documentation for more information.
Test: What’s the dimension/shape of array a1?
Flatten/ravel to 1D arrays with ravel()
The ravel() method lets you convert multi-dimensional arrays to 1D arrays (see docs here). Our 2D array ( 3_4) will be flattened or raveled such that they become a 1D array with 12 elements.
If you don’t specify any parameters, ravel() will flatten/ravel our 2D array along the rows (0th dimension/axis). That is, row 0 [1, 2, 3, 4] + row 1 [5, 6, 7, 8] + row 2 [9, 10, 11, 12].
If you want to flatten/ravel along the columns (1st dimension), use the order parameter.
Concatenate/stack arrays with np.stack() and np.hstack()
Create two 1D arrays
Use np.stack() to concatenate/stack arrays. By default, np.stack() stacks arrays along the 0th dimension (rows) (parameter axis=0 ). See docs for more info.
Stack along the 1st dimension ( axis=1 )
Concatenate as a long 1D array with np.hstack() (stack horizontally)
Create multi-dimensional array (3D)
Multi-dimensional arrays are very common and are known as tensors. They’re used a lot in deep learning and neural networks. If you’re into deep learning, you’ll be reshaping tensors or multi-dimensional arrays regularly.
Let’s begin by first create two different 3 by 4 arrays. We’ll combine them to form a 3D array later.
Create a 3D array by stacking the arrays along different axes/dimensions
Let’s print the arrays to see how they look like. See the figure above for visualizations.
Because the three 3D arrays have been created by stacking two arrays along different dimensions, if we want to retrieve the original two arrays from these 3D arrays, we’ll have to subset along the correct dimension/axis.
Test: How can we retrieve our a1 array from these 3D arrays?
Flatten multidimensional arrays
Ravel column by column ( order=’F’ ) to 1D array
Reshape multidimensional arrays
We can also use reshape() to reshape multi-dimensional arrays.
Final remarks
I hope now you have a better understanding of how numpy reshapes multi-dimensional arrays. I look forward to your thoughts and comments. Also, check out this visual introduction to numpy and data representation.
If you want a pdf copy of the cheatsheet above, you can download it here. If you find this post useful, follow me and visit my site for more data science tutorials.
If you are interested in improving your data science skills, the following articles might be useful:
NumPy array reshape (Shape transformation without data change)
In this tutorial, you will learn about reshaping the NumPy arrays. This tutorial focuses on the reshaping technique using the NumPy array reshape function. The shape of an array is defined as the total number of elements in each dimension of the array.
Reshaping an array means change either the number of elements in an array or changing the dimension of the array or both.
The reshape() method of the NumPy module is used to change an array’s shape without changing the data.
How does NumPy reshape works?
The reshape() method of the NumPy module can change the shape of an array. For instance, you have a table with rows and columns; you can change the rows into columns and columns into rows.
Take a real example of an array with 12 columns and only 1 row.
You can reduce the columns from 12 to 4 and add the remaining data of the columns into new rows. As demonstrated in the figure below:
The NumPy reshaping technique lets us reorganize the data in an array. The numpy.reshape() method does not change the original array, rather it generates a view of the original array and returns a new (reshaped) array. The syntax for numpy.reshape() is given below:
The method reshape() will return a reshaped array with the same data.
Reshape 1d to 2d
To convert 1D array to 2D array, call the reshape() function with 1D array as the input. Consider the following example in which we have a 1D array with ten elements.
We will convert this array into a 2D array such that the new array has two dimensions with five elements each or five columns.
Output: 
The reshape() function takes the input array, then a tuple that defines the shape of the new array.
The shape (2, 5) means that the new array has two dimensions and we have divided ten elements of the input array into two sets of five elements.
Remember that the number of elements in the output array should be the same as in the input array.
Reshape 1d to 3d
In the following example, we have twelve elements in the 1D input array. We have to divide the elements into three dimensions such that each dimension has four elements.
Output: 
Reshape 2d to 1d
In the following code, we have a 2D array with four columns. The code below will reshape the array into one dimension containing all elements.
Output: 
In the reshape() method, the tuple (1, 8) means a 1D output array with eight columns.
Reshape 2d to 3d
The code below converts a 2D array to a 3D array with the same number of elements.
Output: 
The new array has three dimensions with four columns or four elements in each dimension.
Reshape 3d to 1d
The following code converts three dimensions of an array into one dimension.
Output: 
Rshape 3d to 2d
To convert a 3-dimensional array into 2D, consider the code below:
Output: 
Reshape 4d to 2d
To convert a 4D array to a 2D array, consider the following example:
Output: 
If you want to convert an array of an unknown dimension to a 1D array, use reshape(-1) as shown below:
Output: 
Reshape 0d to 1d
An array with one dimension and length equals one is called a 0D array. In other words, a 0-dimensional array is a scalar quantity with a constant length of 1. In the following code we will reshape a 0-dimensional array to a 1-dimensional array:
Output: 
In the above example, first, we have created a 0-dimensional array. As a 0-dimensional array is a scalar quantity, therefore, there is only one item. We cannot add more than one item or any dimensions.
The ndim function tells the dimension of an array. Then we used reshape(-1) as in the previous heading to reshape the array to 1-dimension. Once the array is 1-dimensional, you can add elements to an array.
Reshape reverse
In some cases, you need to reverse the shape of the array to its original dimensions.
If you applied the reshape() method to an array and you want to get the original shape of the array back, you can call the reshape function on that array again.
Reversing the shape of an array is demonstrated in the code below:
Output: 
In this example, we have an array of four dimensions. Then we reshaped the array to two dimensions and stored the array in output_array.
On applying the reshape function on the output_array, we got our original array back with the same dimensions. Note that we have given the dimensions of the original array using the shape function.
You can also perform reverse reshape in one line of code as given below:
Reshape order
When using the reshape method to reshape arrays, there is a parameter called order in the syntax of reshape(). The order parameter decides in which index order elements will be fetched and arranged in the reshaped array.
The order parameter can have three values: C, F, and A.
Consider the following example to see a clear picture of how index orders reshape an array.
Output: 
In the above example, in order C or the row-wise operation, the first two rows are combined and then the next two rows are merged. In the column-wise operation, the elements of first and third columns are read first.
In other words, C is row by row operation and F is column by column operation.
Reshape along axes
Axes in an array are the directions along the columns and the rows of the array. In NumPy, axes and dimensions are considered the same. Axes are used to index an array.
In a multidimensional array, there is only one index per one axis. Check out the visual below:
Axis 1 is the direction along the columns and axis 0 is the direction along rows. For example, if you have an array:
We will use axes as [1, 1]. [1, 1] means row 1 and column 1. The NumPy reshape() method reshapes the array along 0 axis or 0-dimension that is along row.
We can change the row operation to column operation by specifying the order argument in the reshape() method. Consider the following example in which we have applied Order C and Order F.
Output: 
Therefore, order C reshaped the array along 0-dimension (row) and order F reshaped the array along 1-dimension (column).
Now let us use axes with NumPy reshape. Note that in NumPy, dimensions are axes. The following example shows how to specify the number of dimensions, number of rows, and number of columns in an array:
Output: 
In this code, there are three arguments in the reshape() method. The first argument that is ‘3’ tells the number of dimensions in the array, the second argument that is ‘4’ specifies the number of rows and the third argument specifies the number of columns.
In other words, you can say that the outermost array has three arrays inside, each of the three arrays further contain four arrays, and all four arrays have one element.
Reshape column to row
The reshape() method does not change column data to row, but it changes the shape of an array that is the dimensions of the array.
Therefore, we can only swap the dimensions of an array with the reshape() method.
For instance, if an array has four rows and three columns, we will reshape it in such a way that the new array has three rows and four columns.
The following example demonstrates how reshape swaps dimensions.
Output: 
We used the transpose() function of NumPy to change column data to row data.
Reshape row to column
In the same way, if an array has three rows and two columns, reshape will change the dimensions such that the new array has three columns and two rows. Consider the following code:
Output: 
Reshape uneven array
If an array is uneven, the reshape method won’t be able to fit all elements into a new array.
This is because the uneven array has an odd number of elements, when you try to reshape this type of array, there must be one element left to put into the new array. Therefore, an error will be thrown. Consider the following example:
Output: 
Reshape an image
You can reshape an array of an image using the reshape method. First, you need to import the image and then convert the image into an array.
Then we will reshape the array and finally convert the reshaped array back to an image. We will apply the reshape() method to the following image:
Consider the example below:
We have converted the image to greyscale to simplify reshaping. Then store the image array in a variable. 
Output: 
Reshape large arrays/throws error
When you do not specify the right dimensions to reshape an array, the reshape() method will throw an error. This problem usually occurs when you reshape an array of a large size.
For example, when reshaping the array of an image, the array is pretty large in size. Therefore, we need to choose appropriate dimensions to reshape the array.
In the last example, we had an array of shape (1200, 1200).
The size of the array was 1,440,000. Now we need to figure out the right dimensions to reshape the array. We will find the factors of 1200.
In the last example, we divided 1200 by 1.5 and multiplied 1200 by 1.5 that gave us 800 and 1800 respectively.
If we specify dimensions that are not equivalent to the size of the original array, reshape will give the following error:
Memory Error
If you have an array of larger size, the reshape() method will throw a memory error. The memory error is thrown when you are short of RAM and you have to load the entire dataset into the memory.
A concept called batch processing was introduced to resolve memory errors.
In batch processing, the data is stored in the hard drive and is divided into small batches. The batches are then loaded into memory one by one. This way memory is not drained.
NumPy reshape() Vs NumPy transpose()
The main difference between NumPy reshape() and transpose() is that reshape() gives a new shape to the array whereas, transpose inverts the axes.
The transpose method only changes rows into columns or columns to rows (inverting axes). The reshape method will take an input array and format the array into the given shape.
This shape can have any dimensions and any number of columns respecting the size of the array.
The following example explains the difference between reshape() and transpose():
Output: 
In the above example, you can see that reshape() method changed the dimensions of the array from 4D to 2D and the number of columns from 3 to 6.
Whereas, transpose() is a constant function that only performs one operation that changes rows into columns and columns into rows.
NumPy reshape() vs NumPy resize()
Both reshape() and resize() methods of the NumPy module are used to define a new size of an array. The main difference between the two methods is that the reshape() method does not make changes to the original array rather it returns a new array as an output.
Whereas, the resize() method makes changes directly to the original array and returns the original array. The following code examples clearly tell the difference between reshape() and resize():
Output: 
In the above output, the original array remains the same.
Output: 
As shown in the code above, the resize() method made changes to the original array. The resize() method does not return anything; whereas, the reshape() method returns a new array with new dimensions.
NumPy reshape() vs NumPy flatten()
The reshape() method reshapes an array to another shape. The NumPy flatten() method as the name says flattens an array. The flatten() method converts an array of any dimension to 1-dimension. The syntax of flatten() is as follows:
It will return a 1-dimensional array. It does not make changes to the original array.
The following example explains how flatten() works:
Output: 
The flatten() method does not make changes to the original array. The input array was three-dimensional and is flattened to 1D using the flatten() method.