Time for action – stacking arrays

First, set up some arrays:

In: a = arange(9).reshape(3,3)
In: a
Out:
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])
In: b = 2 * a
In: b
Out:
array([[ 0,  2,  4],
       [ 6,  8, 10],
       [12, 14, 16]])
  1. Horizontal stacking: Starting with horizontal stacking, form a tuple of the ndarray objects and give it to the hstack() function as follows:
    In: hstack((a, b))
Out:
array([[ 0,  1,  2,  0,  2,  4],
       [ 3,  4,  5,  6,  8, 10],
       [ 6,  7,  8, 12, 14, 16]])

    Achieve the same with the concatenate() function as follows (the axis argument here is equivalent to axes in a Cartesian coordinate system and corresponds to the array dimensions):

    In: concatenate((a, b), axis=1)
Out:
array([[ 0,  1,  2,  0,  2,  4],
       [ 3,  4,  5,  6,  8, 10],
       [ 6,  7,  8, 12, 14, 16]])

    This image shows horizontal stacking with the concatenate() function:

    Time for action – stacking arrays
  2. Vertical stacking: With vertical stacking, again, a tuple is formed. This time, it is given to the vstack() function as follows:
    In: vstack((a, b))
Out:
array([[ 0,  1,  2],
       [ 3,  4,  5],
       [ 6,  7,  8],
       [ 0,  2,  4],
       [ 6,  8, 10],
       [12, 14, 16]])

    The concatenate() function produces the same result with the axis set to 0. This is the default value for the axis argument:

    In: concatenate((a, b), axis=0)
Out:
array([[ 0,  1,  2],
       [ 3,  4,  5],
       [ 6,  7,  8],
       [ 0,  2,  4],
       [ 6,  8, 10],
       [12, 14, 16]])

    The following diagram shows vertical stacking with concatenate() function:

    Time for action – stacking arrays
  3. Depth stacking: Additionally, depth-wise stacking using dstack() and a tuple stacks a list of arrays along the third axis (depth). For instance, stack two-dimensional arrays of image data on top of each other:
    In: dstack((a, b))
Out:
array([[[ 0,  0],
        [ 1,  2],
        [ 2,  4]],
       [[ 3,  6],
        [ 4,  8],
        [ 5, 10]],
       [[ 6, 12],
        [ 7, 14],
        [ 8, 16]]])
  4. Column stacking: Stack the one-dimensional arrays with the column_stack() function column-wise as follows:
    In: oned = arange(2)
In: oned
Out: array([0, 1])
In: twice_oned = 2 * oned
In: twice_oned
Out: array([0, 2])
In: column_stack((oned, twice_oned))
Out:
array([[0, 0],
       [1, 2]])

    Two-dimensional arrays are stacked the way hstack() stacks them:

    In: column_stack((a, b))
Out:
array([[ 0,  1,  2,  0,  2,  4],
       [ 3,  4,  5,  6,  8, 10],
       [ 6,  7,  8, 12, 14, 16]])
In: column_stack((a, b)) == hstack((a, b))
Out:
array([[ True,  True,  True,  True,  True,  True],
       [ True,  True,  True,  True,  True,  True],
       [ True,  True,  True,  True,  True,  True]], dtype=bool)

    Yes, you guessed it right! We compared two arrays with the == operator.

    Note

    The == operator is used in Python to compare for equality. When applied to NumPy arrays, the operator performs element-wise comparisons. For more information about the Python comparison operators, have a look at http://www.pythonlearn.com/html-009/book004.html.

  5. Row stacking: NumPy, of course, also has a function that does row-wise stacking. It is called row_stack(), and, for one-dimensional arrays, it just stacks the arrays in rows into a two-dimensional array:
    In: row_stack((oned, twice_oned))
Out:
array([[0, 1],
       [0, 2]])

    The row_stack() function results for two-dimensional arrays are equal to, yes, exactly, the vstack() function results:

    In: row_stack((a, b))
Out:
array([[ 0,  1,  2],
       [ 3,  4,  5],
       [ 6,  7,  8],
       [ 0,  2,  4],
       [ 6,  8, 10],
       [12, 14, 16]])
In: row_stack((a,b)) == vstack((a, b))
Out:
array([[ True,  True,  True],
       [ True,  True,  True],
       [ True,  True,  True],
       [ True,  True,  True],
       [ True,  True,  True],
       [ True,  True,  True]], dtype=bool)

What just happened?

We stacked arrays horizontally, depth wise, and vertically. We used the vstack(), dstack(), hstack(), column_stack(), row_stack(), and concatenate() functions as summarized in the following table:

Function

Description

vstack()

This function stacks arrays vertically

dstack()

This function stacks arrays depth-wise along the third axis

hstack()

This function stacks arrays horizontally

column_stack()

This function stacks one-dimensional arrays as columns to create a two-dimensional array

row_stack()

This function stacks array vertically

concatenate()

This function concatenates a list or a tuple of arrays

The code for this example is in the stacking.py file in this book's code bundle.

Splitting

Arrays can be split vertically, horizontally, or depth wise. The functions involved are hsplit(), vsplit(), dsplit(), and split(). We can either split into arrays of the same shape or indicate the position after which the split should occur.

..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset