{"id":15007,"date":"2021-10-20T04:25:49","date_gmt":"2021-10-20T04:25:49","guid":{"rendered":"https:\/\/machinelearningplus.com\/?p=15007"},"modified":"2022-03-08T15:36:01","modified_gmt":"2022-03-08T15:36:01","slug":"numpy-reshape","status":"publish","type":"post","link":"https:\/\/machinelearningplus.com\/python\/numpy-reshape\/","title":{"rendered":"Numpy Reshape – How to reshape arrays and what does -1 mean?"},"content":{"rendered":"\r\n

How to reshape a numpy array?<\/h2>\r\n\r\n\r\n\r\n

The numpy.reshape()<\/code> function is used to reshape a numpy array without changing the data in the array. It is a very common practice to reshape arrays to make them compatible for further calculations.<\/p>\r\n\r\n\r\n\r\n

In this article, you will learn about the possible use cases of the numpy.reshape<\/code> function.<\/p>\r\n\r\n

numpy.reshape<\/h2>\r\n\r\n\r\n\r\n
    \r\n
  • Syntax:<\/strong> numpy.reshape(a, newshape, order=’C’)<\/li>\r\n
  • Purpose: <\/strong>Gives a new shape to the array without changing the data<\/li>\r\n
  • Parameters:<\/strong>\r\n
      \r\n
    • a:<\/strong> _arraylike<\/em> Array to be reshaped<\/li>\r\n
    • newshape:<\/strong>int or tuples of ints<\/em> Should be compatible with the original shape. If an integer, then the result will be a 1-D array of that length. One shape dimension can be -1. In this case, the value is inferred from the length of the array and remaining dimensions.<\/li>\r\n
    • order:<\/strong>{‘C’, ‘F’, ‘A’}, optional<\/em> Read the elements of a using this index order, and place the elements into the reshaped array using this index order. Detailed usage will be discussed further.<\/li>\r\n<\/ul>\r\n<\/li>\r\n
    • Returns<\/strong> reshaped_array ndarray<\/em><\/li>\r\n<\/ul>\r\n\r\n\r\n\r\n
      # Import Packages<\/span>\r\nimport<\/span> numpy as<\/span> np<\/code><\/pre>\r\n\r\n\r\n\r\n
      1. Numpy.reshape function<\/h2>\r\n\r\n\r\n\r\n
      The numpy.reshape()<\/code> function is used to change the shape of the numpy array without modifying the array data. To use this function, pass the array and the new shape to np.reshape()<\/code>. The shape argument should be passed in the form either “tuple” or “int”.<\/p>\r\n\r\n\r\n\r\n
      Let’s understand this with examples.<\/p>\r\n\r\n\r\n\r\n
      Reshaping 1-D array into a 2-D array<\/h3>\r\n\r\n\r\n\r\n
      In this example, you have to transform a 1-dimensional array of shape (8,) to 2-dimensional array of shape (4,2).<\/p>\r\n\r\n\r\n\r\n
      Step 1: Create a numpy array of shape (8,)<\/strong><\/p>\r\n\r\n\r\n\r\n
      num_array = np.array([1<\/span>,2<\/span>,3<\/span>,4<\/span>,5<\/span>,6<\/span>,7<\/span>,8<\/span>])\r\nnum_array<\/code><\/pre>\r\n\r\n\r\n\r\n
      array([1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>, 6<\/span>, 7<\/span>, 8<\/span>])<\/code><\/pre>\r\n\r\n\r\n\r\n
      Step 2: Use np.reshape()<\/code> function with new shape as (4,2)<\/code><\/strong><\/p>\r\n\r\n\r\n\r\n
      np.reshape(num_array, (4<\/span>,2<\/span>))\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
      array([[1<\/span>, 2<\/span>],\r\n       [3<\/span>, 4<\/span>],\r\n       [5<\/span>, 6<\/span>],\r\n       [7<\/span>, 8<\/span>]])\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
      As you can see the shape of the input array has been changed to a (4,2). This is a 2-D array and contains the smae data present in the original input 1-D array<\/p>\r\n\r\n\r\n\r\n
      Reshaping 2-D array into a 3-D array<\/h3>\r\n\r\n\r\n\r\n
      In this example, you have to transform a2-dimensional array of shape (4,2) to 3-dimensional array of shape (2,2,2).<\/p>\r\n\r\n\r\n\r\n
      Step 1: Create a numpy array of shape (4,2)<\/strong><\/p>\r\n\r\n\r\n\r\n
      num_array = np.array([[1<\/span>, 2<\/span>],\r\n                      [3<\/span>, 4<\/span>],\r\n                      [5<\/span>, 6<\/span>],\r\n                      [7<\/span>, 8<\/span>]])\r\n\r\nnum_array\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
      array([[1<\/span>, 2<\/span>],\r\n       [3<\/span>, 4<\/span>],\r\n       [5<\/span>, 6<\/span>],\r\n       [7<\/span>, 8<\/span>]])\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
      Step 2: Use np.reshape()<\/code> function with new shape as (2, 2, 2)<\/code><\/strong><\/p>\r\n\r\n\r\n\r\n
      np.reshape(num_array, (2<\/span>,2<\/span>,2<\/span>))\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
      array([[[1, 2],\r\n        [3, 4]]<\/span>,\r\n\r\n       [[5, 6],\r\n        [7, 8]]<\/span>])\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
      As you can see the shape of the input array has been changed to a (2, 2, 2). This is a 3-D array and contains the smae data present in the original input 2-D array.<\/p>\r\n\r\n
      2. Can you reshape the numpy array into any shape?<\/h2>\r\n\r\n\r\n\r\n
      The np.reshape()<\/code> function returns the transformed array with the new shape provided in the function. The only condition is that the number of elements in the original array and the number of elements in the transformed array should be equal.<\/p>\r\n\r\n\r\n\r\n
      If you don’t know how to find out the number of elements in an array, simply multiply the number of elements per axis\/dimension. It simply means multiplication of all the numbers mentioned in the shape tuple.<\/p>\r\n\r\n\r\n\r\n
       <\/p>\r\n\r\n\r\n\r\n
      Let’s see what happens if you try to reshape an array with unequal elements<\/p>\r\n\r\n\r\n\r\n
      Step 1: Create a numpy array of shape (5,)<\/strong><\/p>\r\n\r\n\r\n\r\n
      a = np.array([1<\/span>,2<\/span>,3<\/span>,4<\/span>,5<\/span>])\r\na\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
      array([1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>])\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
      Step 2: Use np.reshape()<\/code> function with new shape as (2,5)<\/code><\/strong><\/p>\r\n\r\n\r\n\r\n
      np.reshape(a, (2,5))<\/span>   \r\n\r\n#> Throws ValueError\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
      In this case, a ValueError<\/code> exception is raised. The problem here is that the original array has 5 elements. But the new shape, defined as (2,5)<\/code>, expects 2×5=10 elements. There is a mismatch of the number of elements and therefore, the code failed.<\/p>\r\n\r\n\r\n\r\n
      But what if you wish to reshape to an unknown dimension?<\/p>\r\n\r\n\r\n\r\n
      You can use -1 for the unknown dimension.<\/p>\r\n\r\n\r\n\r\n
      3. What is the meaning of -1 in numpy.reshape?<\/h2>\r\n\r\n\r\n\r\n
      The np.reshape()<\/code> function supports powerful usage of unknown dimensions or placeholder (-1)<\/code>.<\/p>\r\n\r\n\r\n\r\n
      While defining a new shape, you can put one of the dimensions as unknown. Numpy will automatically infer the right dimension for that particular shape. This is to ensure that the input and output arrays have the same number of elements.<\/p>\r\n\r\n\r\n\r\n
      It can be useful in cases when the exact dimensions of the input array is not known but some of the output dimensions are known. Let’s see an example where the input array dimensions are not known but 2 rows are required in the output array.<\/p>\r\n\r\n\r\n\r\n
      Step 1: Create a numpy array<\/strong><\/p>\r\n\r\n\r\n\r\n
      num_array = np.array([[[1, 2], [3, 4]]<\/span>, [[5, 6], [7, 8]]<\/span>])\r\nnum_array\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
      array([[[1, 2],\r\n        [3, 4]]<\/span>,\r\n\r\n       [[5, 6],\r\n        [7, 8]]<\/span>])\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
      Step 2: Use np.reshape()<\/code> function with new shape as (2,-1)<\/code><\/strong><\/p>\r\n\r\n\r\n\r\n
      np.reshape(num_array, (2<\/span>,-1<\/span>))\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
      array([[1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>],\r\n       [5<\/span>, 6<\/span>, 7<\/span>, 8<\/span>]])\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
      The given input array is a 3-D array with shape (2,2,2).<\/p>\r\n\r\n\r\n\r\n
      So what does the -1 in (2, -1) mean?<\/p>\r\n\r\n\r\n\r\n
      The -1 informs numpy to automatically infer the dimension of that axis. So, on applying np.reshape()<\/code> function for shape (2,-1)<\/code>, Numpy is able to infer the last dimension as 4 automatically.<\/p>\r\n\r\n\r\n\r\n
      But what happens if you don’t even put the 1 in the dimension of the output array and simply use just -1 instead?<\/p>\r\n\r\n\r\n\r\n
      4. Flatten the arrays<\/h2>\r\n\r\n\r\n\r\n
      This is an extended use case of using unknown dimensions for reshaping numpy arrays. Unknown dimensions placeholder (-1)<\/code> allows the dimensions to be inferred automatically by numpy. This trick can be used to flatten an array. If (-1)<\/code> placeholder is placed in the np.reshape()<\/code> function, then the function returns a flatten array,<\/p>\r\n\r\n\r\n\r\n
      Let’s see an example below.<\/p>\r\n\r\n\r\n\r\n
      Step 1: Create a 3-D numpy array<\/strong><\/p>\r\n\r\n\r\n\r\n
      a_3d_array = np.array([[[1, 2], [3, 4]]<\/span>, [[5, 6], [7, 8]]<\/span>])\r\na_3d_array\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
      array([[[1, 2],\r\n        [3, 4]]<\/span>,\r\n\r\n       [[5, 6],\r\n        [7, 8]]<\/span>])\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
      Step 2: Use np.reshape()<\/code> function with new shape as (-1)<\/code><\/strong><\/p>\r\n\r\n\r\n\r\n
      np.reshape(a_3d<\/span>_array, (-1<\/span>))\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
      array([1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>, 6<\/span>, 7<\/span>, 8<\/span>])\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
      Here, a 3-D array with shape (2,2,2)<\/code> is flattened to a 1-D array.<\/p>\r\n\r\n\r\n\r\n
      5. How to change the ordering of numpy reshape process?<\/h2>\r\n\r\n\r\n\r\n
      On an abstract level, the np.reshape()<\/code> function works in such a way that it starts with an unrolling or flattening process. This is where all the elements of the input array are flattened into a 1-D array and then rolled back or reshaped according to the input shape provided. But how does numpy decide which dimension element would be flattened first and in which order the elements would be put back? And what if you wish to change this order?<\/p>\r\n\r\n\r\n\r\n
      This order of unrolling can be controlled using the order<\/code> parameter in the np.reshape()<\/code> function. This parameter can take 3 values:<\/p>\r\n\r\n\r\n\r\n
        \r\n
      • C<\/code>: C-like order index<\/li>\r\n
      • F<\/code>: Fortran-like order index<\/li>\r\n
      • A<\/code>: Either in C order or in Fortran order<\/li>\r\n<\/ul>\r\n\r\n\r\n\r\n
        Let’s discuss each of them.<\/p>\r\n\r\n\r\n\r\n
        C-like order index<\/h3>\r\n\r\n\r\n\r\n
        C here stands for the C-language and this order is known as the C-like order index. According to this order, the last index or dimension of the array changes the fastest, and the first index changes the slowest.<\/p>\r\n\r\n\r\n\r\n
        In simple terms, the unrolling starts with the last dimension elements and then proceeds towards the first dimension elements. This ordering is maintained for the rolling back process too when the output array is being created. It is also the default value in np.reshape()<\/code> function.<\/p>\r\n\r\n\r\n\r\n
        Let’s see an example below.<\/p>\r\n\r\n\r\n\r\n
        Step 1: Create a 2-D numpy array<\/strong><\/p>\r\n\r\n\r\n\r\n
        For this case, let’s create a special array. The elements of this 2-D array will correspond to the respective row and column numbers. For example, the element “R1C2” represents elements in the 1st row and 2nd column.<\/p>\r\n\r\n\r\n\r\n
        a_2d_array = np.array([['R1C1'<\/span>, 'R1C2'<\/span>], ['R2C1'<\/span>, 'R2C2'<\/span>], ['R3C1'<\/span>, 'R3C2'<\/span>]])\r\na_2d_array\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
        array([['R1C1'<\/span>, 'R1C2'<\/span>],\r\n       ['R2C1'<\/span>, 'R2C2'<\/span>],\r\n       ['R3C1'<\/span>, 'R3C2'<\/span>]], dtype='<U4'<\/span>)\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
        Step 2: Use np.reshape()<\/code> function with new shape as (2,3)<\/code> and order C<\/code><\/strong><\/p>\r\n\r\n\r\n\r\n
        np.reshape(a_2d_array, (2<\/span>,3<\/span>), order<\/span>='C'<\/span>)\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
        array([['R1C1'<\/span>, 'R1C2'<\/span>, 'R2C1'<\/span>],\r\n       ['R2C2'<\/span>, 'R3C1'<\/span>, 'R3C2'<\/span>]], dtype='<U4'<\/span>)\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
        The output above clearly indicates that in the last dimension of the input 2-D array, columns were flattened first. The elements were flattened in the order “R1C1”, “R1C2”, “R2C1”, and so on. Then during the reshaping process, “R1C1” was placed in 1st row, 1st col, “R1C2” was placed in 1st row, 2nd column, and “R2C1” was placed in 1st row, 3rd column.<\/p>\r\n\r\n\r\n\r\n
        “R2C1” was placed in such a manner so that the output array shape becomes compatible with the input array shape.<\/p>\r\n\r\n\r\n\r\n
        Fortran-like order index<\/h3>\r\n\r\n\r\n\r\n
        F here stands for the language Fortran. Here, the first index or dimension changes the fastest, and the subsequent index changes the slowest. In other words, unrolling process starts with the first dimension and then it proceeds towards the last dimension. This ordering is maintained for the rolling back process too.<\/p>\r\n\r\n\r\n\r\n
        Let’s see an example below.<\/p>\r\n\r\n\r\n\r\n
        Step 1: Create a 2-D numpy array<\/strong><\/p>\r\n\r\n\r\n\r\n
        # Using<\/span> the same array<\/span> created in<\/span> 'C'<\/span> order<\/span>\r\n\r\na_2d_array\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
        array([['R1C1'<\/span>, 'R1C2'<\/span>],\r\n       ['R2C1'<\/span>, 'R2C2'<\/span>],\r\n       ['R3C1'<\/span>, 'R3C2'<\/span>]], dtype='<U4'<\/span>)\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
        Step 2: Use np.reshape()<\/code> function with new shape as (2,3)<\/code> and order F<\/code><\/strong><\/p>\r\n\r\n\r\n\r\n
        np.reshape(a_2d_array, (2<\/span>,3<\/span>), order<\/span>='F'<\/span>)\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
        array([['R1C1'<\/span>, 'R3C1'<\/span>, 'R2C2'<\/span>],\r\n       ['R2C1'<\/span>, 'R1C2'<\/span>, 'R3C2'<\/span>]], dtype='<U4'<\/span>)\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
        The output above depicts that in the first dimension of the input 2-D array, rows were flattened first. The elements were flattened in the order “R1C1”, “R2C1”, “R3C1”, and so on. Then during the reshaping process, “R1C1” was placed in 1st row, 1st column, “R2C1” was placed in 2nd row, 1st column, and “R3C1” was placed in 1st row, 2nd column.<\/p>\r\n\r\n\r\n\r\n
        “R3C1” was placed in such a manner so that the output array shape becomes compatible with the input array shape.<\/p>\r\n\r\n\r\n\r\n
        A order<\/h3>\r\n\r\n\r\n\r\n
        This type of order does not have any specific rules. It depends on how the array is stored in the memory. If the array is stored in a C-like memory, then the C<\/code> order is used and if the array is stored as Fortran-like memory, then the F<\/code> order is used. A user is not aware of what the output result would be and that’s why this ordering is rarely used.<\/p>\r\n\r\n\r\n\r\n
        6. Alternate ways of reshaping arrays<\/h2>\r\n\r\n\r\n\r\n
        Although, a numpy array can be reshaped using np.reshape()<\/code> function but, there are some alternate methods. Two such methods are:<\/p>\r\n\r\n\r\n\r\n
          \r\n
        • Numpy array object function<\/li>\r\n
        • Using np.ravel()<\/code> in combination with np.reshape()<\/code><\/li>\r\n<\/ul>\r\n\r\n\r\n\r\n
          Let’s explore these methods.<\/p>\r\n\r\n\r\n\r\n
          Numpy array object function for reshaping arrays<\/h3>\r\n\r\n\r\n\r\n
          A numpy array object supports almost all the operations that can be performed using the numpy explicit functions. The numpy array can be reshaped by accessing the .reshape()<\/code> function from the numpy array object. See can example below.<\/p>\r\n\r\n\r\n\r\n
          Step 1: Create a numpy array of shape (8,)<\/strong><\/p>\r\n\r\n\r\n\r\n
          num_array = np.array([1<\/span>,2<\/span>,3<\/span>,4<\/span>,5<\/span>,6<\/span>,7<\/span>,8<\/span>])\r\nnum_array\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
          array([1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>, 6<\/span>, 7<\/span>, 8<\/span>])\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
          Step 2: Use .reshape()<\/code> function from numpy array object with new shape as (4,2)<\/code><\/strong><\/p>\r\n\r\n\r\n\r\n
          num_array.reshape((4<\/span>,2<\/span>))\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
          array([[1<\/span>, 2<\/span>],\r\n       [3<\/span>, 4<\/span>],\r\n       [5<\/span>, 6<\/span>],\r\n       [7<\/span>, 8<\/span>]])\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
          Using np.ravel() in combination with np.reshape() for reshaping arrays<\/h3>\r\n\r\n\r\n\r\n
          np.ravel()<\/code> function is used for flattening the numpy arrays. It returns the multidimensional array as a flattened contiguous array. This function can be used in combination with np.reshape()<\/code> function. The result of the ravel function can be passed into the reshape function with a new shape defined and it will still return the correct results.<\/p>\r\n\r\n\r\n\r\n
          Let’s see an example.<\/p>\r\n\r\n\r\n\r\n
          Step 1: Create a numpy array of shape (8,)<\/strong><\/p>\r\n\r\n\r\n\r\n
          num_array = np.array([1<\/span>,2<\/span>,3<\/span>,4<\/span>,5<\/span>,6<\/span>,7<\/span>,8<\/span>])\r\nnum_array\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
          array([1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>, 6<\/span>, 7<\/span>, 8<\/span>])\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
          Step 2: Use np.reshape()<\/code> and np.ravel()<\/code> function with new shape as (4,2)<\/code><\/strong><\/p>\r\n\r\n\r\n\r\n
          np<\/span>.reshape<\/span>(np<\/span>.ravel<\/span>(num_array<\/span>), (4,2))\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
          array([[1<\/span>, 2<\/span>],\r\n       [3<\/span>, 4<\/span>],\r\n       [5<\/span>, 6<\/span>],\r\n       [7<\/span>, 8<\/span>]])\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
          7. Advanced reshaping<\/h2>\r\n\r\n\r\n\r\n
          One of the alternative ways to reshape a numpy array, as mentioned in the above section, is to flat the array using np.ravel()<\/code> function. Then use the output of ravel function as input for np.reshape()<\/code> function along with the new shape for the final output array.<\/p>\r\n\r\n\r\n\r\n
          np.ravel()<\/code> also supports order<\/code> parameter and it works the same way as in the np.reshape()<\/code> function. Therefore, one can have a different order for flattening and reshaping. Let’s discuss these cases.<\/p>\r\n\r\n\r\n\r\n
          Case 1: Flattening in C order, reshaping in F order<\/h3>\r\n\r\n\r\n\r\n
          In this case, the array is flattened using the np.ravel()<\/code> function along with order<\/code> parameter C<\/code>. For the np.reshape()<\/code> function, the order parameter would be F<\/code>.<\/p>\r\n\r\n\r\n\r\n
          Step 1: Create a numpy array of shape (8,)<\/strong><\/p>\r\n\r\n\r\n\r\n
          num_array = np.array([1<\/span>,2<\/span>,3<\/span>,4<\/span>,5<\/span>,6<\/span>,7<\/span>,8<\/span>])\r\nnum_array\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
          array([1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>, 6<\/span>, 7<\/span>, 8<\/span>])\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
          Step 2: Use np.reshape()<\/code> and np.ravel()<\/code> function with new shape as (4,2)<\/code><\/strong><\/p>\r\n\r\n\r\n\r\n
          np.reshape(np.ravel(num_array, order<\/span>='C'<\/span>), (4<\/span>,2<\/span>), order<\/span>='F'<\/span>)\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
          array([[1<\/span>, 5<\/span>],\r\n       [2<\/span>, 6<\/span>],\r\n       [3<\/span>, 7<\/span>],\r\n       [4<\/span>, 8<\/span>]])\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
          Case 2: Flattening in F order, reshaping in C order<\/h3>\r\n\r\n\r\n\r\n
          In this case, the array is flattened using the np.ravel()<\/code> function along with order<\/code> parameter F<\/code>. For the np.reshape()<\/code> function, the order parameter would be C<\/code>.<\/p>\r\n\r\n\r\n\r\n
          Step 1: Create a numpy array of shape (8,)<\/strong><\/p>\r\n\r\n\r\n\r\n
          num_array = np.array([1<\/span>,2<\/span>,3<\/span>,4<\/span>,5<\/span>,6<\/span>,7<\/span>,8<\/span>])\r\nnum_array\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
          array([1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>, 6<\/span>, 7<\/span>, 8<\/span>])\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
          Step 2: Use np.reshape()<\/code> and np.ravel()<\/code> function with new shape as (4,2)<\/code><\/strong><\/p>\r\n\r\n\r\n\r\n
          np.reshape(np.ravel(num_array, order<\/span>='F'<\/span>), (4<\/span>,2<\/span>), order<\/span>='C'<\/span>)\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
          array([[1<\/span>, 2<\/span>],\r\n       [3<\/span>, 4<\/span>],\r\n       [5<\/span>, 6<\/span>],\r\n       [7<\/span>, 8<\/span>]])\r\n<\/code><\/pre>\r\n\r\n\r\n\r\n
          8. Test your knowledge<\/h2>\r\n\r\n\r\n\r\n
          Q1:<\/strong> What if a negative index is passed in the shape tuple? (Assume only one negative index)<\/p>\r\n\r\n\r\n\r\n
          Answer:<\/summary>
          <\/p>\r\n\r\n\r\n\r\n
          Answer:<\/strong> The numpy will automatically infer the -1 as a missing dimension and choose the correct dimension of its own<\/p>\r\n\r\n\r\n\r\n
          <\/div><\/details>\r\n\r\n\r\n\r\n
          Q2:<\/strong> What is the difference between the ‘C’ and ‘F’ order?<\/p>\r\n\r\n\r\n\r\n
          Answer:<\/summary>
          <\/p>\r\n\r\n\r\n\r\n
          Answer:<\/strong> In ‘C’ order, the last index or dimension of the array changes the fastest, and the first index changes the slowest. But in ‘F’ order, the first index or dimension changes the fastest, and the subsequent index changes the slowest.<\/p>\r\n\r\n\r\n\r\n
          <\/div><\/details>\r\n\r\n\r\n\r\n
          Q3:<\/strong> List two ways to flatten a numpy array.<\/p>\r\n\r\n\r\n\r\n
          Answer:<\/summary>
          <\/p>\r\n\r\n\r\n\r\n
          Answer:<\/strong><\/p>\r\n\r\n\r\n\r\n
          1) Using np.ravel()<\/code> function<\/p>\r\n\r\n\r\n\r\n
          2) Using unknown dimension placeholder -1<\/code> in np.shape()<\/code> function<\/p>\r\n\r\n\r\n\r\n
          <\/div><\/details>\r\n\r\n\r\n\r\n
          The Article was contributed by Kaustubh G.<\/p>\r\n","protected":false},"excerpt":{"rendered":"
          How to reshape a numpy array? The numpy.reshape() function is used to reshape a numpy array without changing the data in the array. It is a very common practice to reshape arrays to make them compatible for further calculations.<\/p>\n","protected":false},"author":28,"featured_media":15456,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"site-sidebar-layout":"default","site-content-layout":"default","ast-site-content-layout":"default","site-content-style":"default","site-sidebar-style":"default","ast-global-header-display":"","ast-banner-title-visibility":"","ast-main-header-display":"","ast-hfb-above-header-display":"","ast-hfb-below-header-display":"","ast-hfb-mobile-header-display":"","site-post-title":"","ast-breadcrumbs-content":"","ast-featured-img":"","footer-sml-layout":"","ast-disable-related-posts":"","theme-transparent-header-meta":"default","adv-header-id-meta":"","stick-header-meta":"","header-above-stick-meta":"","header-main-stick-meta":"","header-below-stick-meta":"","astra-migrate-meta-layouts":"default","ast-page-background-enabled":"default","ast-page-background-meta":{"desktop":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"ast-content-background-meta":{"desktop":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"footnotes":""},"categories":[21],"tags":[26,22],"class_list":["post-15007","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-python","tag-numpy","tag-python"],"acf":[],"yoast_head":"\nNumpy Reshape - How to reshape arrays and what does -1 mean? - machinelearningplus<\/title>\n<meta name=\"description\" content=\"The numpy.reshape() is used to reshape a numpy array without changing the data in the array. Read on to know all about reshaping numpy arrays.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/localhost:8080\/python\/numpy-reshape\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Numpy Reshape - How to reshape arrays and what does -1 mean? - machinelearningplus\" \/>\n<meta property=\"og:description\" content=\"The numpy.reshape() is used to reshape a numpy array without changing the data in the array. Read on to know all about reshaping numpy arrays.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/localhost:8080\/python\/numpy-reshape\/\" \/>\n<meta property=\"og:site_name\" content=\"machinelearningplus\" \/>\n<meta property=\"article:published_time\" content=\"2021-10-20T04:25:49+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2022-03-08T15:36:01+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/localhost:8080\/wp-content\/uploads\/2021\/10\/Numpy_Feature_Image-min.png\" \/>\n\t<meta property=\"og:image:width\" content=\"560\" \/>\n\t<meta property=\"og:image:height\" content=\"315\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/png\" \/>\n<meta name=\"author\" content=\"MachineLearningPlus\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"MachineLearningPlus\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"11 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"TechArticle\",\"@id\":\"https:\\\/\\\/localhost:8080\\\/python\\\/numpy-reshape\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/localhost:8080\\\/python\\\/numpy-reshape\\\/\"},\"author\":{\"name\":\"MachineLearningPlus\",\"@id\":\"https:\\\/\\\/machinelearningplus.com\\\/#\\\/schema\\\/person\\\/19596ae889d256d2760a8986abfa5c47\"},\"headline\":\"Numpy Reshape – How to reshape arrays and what does -1 mean?\",\"datePublished\":\"2021-10-20T04:25:49+00:00\",\"dateModified\":\"2022-03-08T15:36:01+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/localhost:8080\\\/python\\\/numpy-reshape\\\/\"},\"wordCount\":1885,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/machinelearningplus.com\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/localhost:8080\\\/python\\\/numpy-reshape\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/machinelearningplus.com\\\/wp-content\\\/uploads\\\/2021\\\/10\\\/Numpy_Feature_Image-min.png\",\"keywords\":[\"Numpy\",\"Python\"],\"articleSection\":[\"Python\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/localhost:8080\\\/python\\\/numpy-reshape\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/localhost:8080\\\/python\\\/numpy-reshape\\\/\",\"url\":\"https:\\\/\\\/localhost:8080\\\/python\\\/numpy-reshape\\\/\",\"name\":\"Numpy Reshape - How to reshape arrays and what does -1 mean? - machinelearningplus\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/machinelearningplus.com\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/localhost:8080\\\/python\\\/numpy-reshape\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/localhost:8080\\\/python\\\/numpy-reshape\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/machinelearningplus.com\\\/wp-content\\\/uploads\\\/2021\\\/10\\\/Numpy_Feature_Image-min.png\",\"datePublished\":\"2021-10-20T04:25:49+00:00\",\"dateModified\":\"2022-03-08T15:36:01+00:00\",\"description\":\"The numpy.reshape() is used to reshape a numpy array without changing the data in the array. Read on to know all about reshaping numpy arrays.\",\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/localhost:8080\\\/python\\\/numpy-reshape\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/localhost:8080\\\/python\\\/numpy-reshape\\\/#primaryimage\",\"url\":\"https:\\\/\\\/machinelearningplus.com\\\/wp-content\\\/uploads\\\/2021\\\/10\\\/Numpy_Feature_Image-min.png\",\"contentUrl\":\"https:\\\/\\\/machinelearningplus.com\\\/wp-content\\\/uploads\\\/2021\\\/10\\\/Numpy_Feature_Image-min.png\",\"width\":560,\"height\":315,\"caption\":\"Numpy Feature Image\"},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/machinelearningplus.com\\\/#website\",\"url\":\"https:\\\/\\\/machinelearningplus.com\\\/\",\"name\":\"machinelearningplus\",\"description\":\"Learn Data Science (AI \\\/ ML) Online\",\"publisher\":{\"@id\":\"https:\\\/\\\/machinelearningplus.com\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/machinelearningplus.com\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/machinelearningplus.com\\\/#organization\",\"name\":\"machinelearningplus\",\"url\":\"https:\\\/\\\/machinelearningplus.com\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/machinelearningplus.com\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/machinelearningplus.com\\\/wp-content\\\/uploads\\\/2022\\\/05\\\/MachineLearningplus-logo.svg\",\"contentUrl\":\"https:\\\/\\\/machinelearningplus.com\\\/wp-content\\\/uploads\\\/2022\\\/05\\\/MachineLearningplus-logo.svg\",\"width\":348,\"height\":36,\"caption\":\"machinelearningplus\"},\"image\":{\"@id\":\"https:\\\/\\\/machinelearningplus.com\\\/#\\\/schema\\\/logo\\\/image\\\/\"}},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/machinelearningplus.com\\\/#\\\/schema\\\/person\\\/19596ae889d256d2760a8986abfa5c47\",\"name\":\"MachineLearningPlus\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/machinelearningplus.com\\\/wp-content\\\/litespeed\\\/avatar\\\/b066ce75243d296fa7b373e34daf3008.jpg?ver=1776364784\",\"url\":\"https:\\\/\\\/machinelearningplus.com\\\/wp-content\\\/litespeed\\\/avatar\\\/b066ce75243d296fa7b373e34daf3008.jpg?ver=1776364784\",\"contentUrl\":\"https:\\\/\\\/machinelearningplus.com\\\/wp-content\\\/litespeed\\\/avatar\\\/b066ce75243d296fa7b373e34daf3008.jpg?ver=1776364784\",\"caption\":\"MachineLearningPlus\"},\"description\":\"Machine Learning Plus is made of a group of enthusiastic folks passionate about Data Science. They help awesome Developers, Business managers and Data Scientists become better at what they do.\",\"url\":\"https:\\\/\\\/machinelearningplus.com\\\/author\\\/team-machinelearningplus\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Numpy Reshape - How to reshape arrays and what does -1 mean? - machinelearningplus","description":"The numpy.reshape() is used to reshape a numpy array without changing the data in the array. Read on to know all about reshaping numpy arrays.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/localhost:8080\/python\/numpy-reshape\/","og_locale":"en_US","og_type":"article","og_title":"Numpy Reshape - How to reshape arrays and what does -1 mean? - machinelearningplus","og_description":"The numpy.reshape() is used to reshape a numpy array without changing the data in the array. Read on to know all about reshaping numpy arrays.","og_url":"https:\/\/localhost:8080\/python\/numpy-reshape\/","og_site_name":"machinelearningplus","article_published_time":"2021-10-20T04:25:49+00:00","article_modified_time":"2022-03-08T15:36:01+00:00","og_image":[{"width":560,"height":315,"url":"https:\/\/localhost:8080\/wp-content\/uploads\/2021\/10\/Numpy_Feature_Image-min.png","type":"image\/png"}],"author":"MachineLearningPlus","twitter_card":"summary_large_image","twitter_misc":{"Written by":"MachineLearningPlus","Est. reading time":"11 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"TechArticle","@id":"https:\/\/localhost:8080\/python\/numpy-reshape\/#article","isPartOf":{"@id":"https:\/\/localhost:8080\/python\/numpy-reshape\/"},"author":{"name":"MachineLearningPlus","@id":"https:\/\/machinelearningplus.com\/#\/schema\/person\/19596ae889d256d2760a8986abfa5c47"},"headline":"Numpy Reshape – How to reshape arrays and what does -1 mean?","datePublished":"2021-10-20T04:25:49+00:00","dateModified":"2022-03-08T15:36:01+00:00","mainEntityOfPage":{"@id":"https:\/\/localhost:8080\/python\/numpy-reshape\/"},"wordCount":1885,"commentCount":0,"publisher":{"@id":"https:\/\/machinelearningplus.com\/#organization"},"image":{"@id":"https:\/\/localhost:8080\/python\/numpy-reshape\/#primaryimage"},"thumbnailUrl":"https:\/\/machinelearningplus.com\/wp-content\/uploads\/2021\/10\/Numpy_Feature_Image-min.png","keywords":["Numpy","Python"],"articleSection":["Python"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/localhost:8080\/python\/numpy-reshape\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/localhost:8080\/python\/numpy-reshape\/","url":"https:\/\/localhost:8080\/python\/numpy-reshape\/","name":"Numpy Reshape - How to reshape arrays and what does -1 mean? - machinelearningplus","isPartOf":{"@id":"https:\/\/machinelearningplus.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/localhost:8080\/python\/numpy-reshape\/#primaryimage"},"image":{"@id":"https:\/\/localhost:8080\/python\/numpy-reshape\/#primaryimage"},"thumbnailUrl":"https:\/\/machinelearningplus.com\/wp-content\/uploads\/2021\/10\/Numpy_Feature_Image-min.png","datePublished":"2021-10-20T04:25:49+00:00","dateModified":"2022-03-08T15:36:01+00:00","description":"The numpy.reshape() is used to reshape a numpy array without changing the data in the array. Read on to know all about reshaping numpy arrays.","inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/localhost:8080\/python\/numpy-reshape\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/localhost:8080\/python\/numpy-reshape\/#primaryimage","url":"https:\/\/machinelearningplus.com\/wp-content\/uploads\/2021\/10\/Numpy_Feature_Image-min.png","contentUrl":"https:\/\/machinelearningplus.com\/wp-content\/uploads\/2021\/10\/Numpy_Feature_Image-min.png","width":560,"height":315,"caption":"Numpy Feature Image"},{"@type":"WebSite","@id":"https:\/\/machinelearningplus.com\/#website","url":"https:\/\/machinelearningplus.com\/","name":"machinelearningplus","description":"Learn Data Science (AI \/ ML) Online","publisher":{"@id":"https:\/\/machinelearningplus.com\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/machinelearningplus.com\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/machinelearningplus.com\/#organization","name":"machinelearningplus","url":"https:\/\/machinelearningplus.com\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/machinelearningplus.com\/#\/schema\/logo\/image\/","url":"https:\/\/machinelearningplus.com\/wp-content\/uploads\/2022\/05\/MachineLearningplus-logo.svg","contentUrl":"https:\/\/machinelearningplus.com\/wp-content\/uploads\/2022\/05\/MachineLearningplus-logo.svg","width":348,"height":36,"caption":"machinelearningplus"},"image":{"@id":"https:\/\/machinelearningplus.com\/#\/schema\/logo\/image\/"}},{"@type":"Person","@id":"https:\/\/machinelearningplus.com\/#\/schema\/person\/19596ae889d256d2760a8986abfa5c47","name":"MachineLearningPlus","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/machinelearningplus.com\/wp-content\/litespeed\/avatar\/b066ce75243d296fa7b373e34daf3008.jpg?ver=1776364784","url":"https:\/\/machinelearningplus.com\/wp-content\/litespeed\/avatar\/b066ce75243d296fa7b373e34daf3008.jpg?ver=1776364784","contentUrl":"https:\/\/machinelearningplus.com\/wp-content\/litespeed\/avatar\/b066ce75243d296fa7b373e34daf3008.jpg?ver=1776364784","caption":"MachineLearningPlus"},"description":"Machine Learning Plus is made of a group of enthusiastic folks passionate about Data Science. They help awesome Developers, Business managers and Data Scientists become better at what they do.","url":"https:\/\/machinelearningplus.com\/author\/team-machinelearningplus\/"}]}},"_links":{"self":[{"href":"https:\/\/machinelearningplus.com\/wp-json\/wp\/v2\/posts\/15007","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/machinelearningplus.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/machinelearningplus.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/machinelearningplus.com\/wp-json\/wp\/v2\/users\/28"}],"replies":[{"embeddable":true,"href":"https:\/\/machinelearningplus.com\/wp-json\/wp\/v2\/comments?post=15007"}],"version-history":[{"count":0,"href":"https:\/\/machinelearningplus.com\/wp-json\/wp\/v2\/posts\/15007\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/machinelearningplus.com\/wp-json\/wp\/v2\/media\/15456"}],"wp:attachment":[{"href":"https:\/\/machinelearningplus.com\/wp-json\/wp\/v2\/media?parent=15007"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/machinelearningplus.com\/wp-json\/wp\/v2\/categories?post=15007"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/machinelearningplus.com\/wp-json\/wp\/v2\/tags?post=15007"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}