## Slicing 3d numpy arrays

numpy slice 2d array
numpy indexing 3d array
numpy reshape 2d to 3d
subsetting 3d numpy array
numpy index array with another array
numpy array shape
numpy 2d array indexing
numpy where 2d array

Consider the following:

```A = np.zeros((2,3))
print(A)

[[ 0.  0.  0.]
[ 0.  0.  0.]]
```

This make sense to me. I'm telling numpy to make a 2x3 matrix, and that's what I get.

However, the following:

```B = np.zeros((2, 3, 4))
print(B)
```

Gives me this:

```[[[ 0.  0.  0.  0.]
[ 0.  0.  0.  0.]
[ 0.  0.  0.  0.]]

[[ 0.  0.  0.  0.]
[ 0.  0.  0.  0.]
[ 0.  0.  0.  0.]]]
```

This doesn't make sense to me. Aren't I telling numpy to make a cube which has 4 2x3 matrices? I'm even more confused because although the data structure looks incorrect, the slicing works exactly as planned:

```print(B[:,:,1])

[[ 0.  0.  0.]
[ 0.  0.  0.]]
```

I'm missing something about how these arrays are constructed, but I'm not sure what. Can someone explain what I'm missing or not understanding?

Thanks so much!

NumPy arrays iterate over the left-most axis first. Thus if `B` has shape (2,3,4), then `B` has shape (3,4) and `B` has shape (3,4). In this sense, you could think of `B` as 2 arrays of shape (3,4). You can sort of see the two arrays in the repr of `B`:

```In : B = np.arange(2*3*4).reshape((2,3,4))
array([[[ 0,  1,  2,  3],
[ 4,  5,  6,  7],       <-- first (3,4) array
[ 8,  9, 10, 11]],

[[12, 13, 14, 15],
[16, 17, 18, 19],      <-- second (3,4) array
[20, 21, 22, 23]]])
```

You can also think of `B` as containing four 2x3 arrays by iterating over the last index first:

```for i in range(4):
print(B[:,:,i])

# [[ 0  4  8]
#  [12 16 20]]
# [[ 1  5  9]
#  [13 17 21]]
# [[ 2  6 10]
#  [14 18 22]]
# [[ 3  7 11]
#  [15 19 23]]
```

but you could just as easily think of `B` as three 2x4 arrays:

```for i in range(3):
print(B[:,i,:])

# [[ 0  1  2  3]
#  [12 13 14 15]]
# [[ 4  5  6  7]
#  [16 17 18 19]]
# [[ 8  9 10 11]
#  [20 21 22 23]]
```

NumPy arrays are completely flexible this way. But as far as the `repr` of `B` is concerned, what you see corresponds to two (3x4) arrays since `B` iterates over the left-most axis first.

```for arr in B:
print(arr)

# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]
# [[12 13 14 15]
#  [16 17 18 19]
#  [20 21 22 23]]
```

Indexing and slicing numpy arrays, The array you get back when you index or slice a numpy array is a view of the original array You can access any row or column in a 3D array. 3D Array Slicing And Indexing Make a three-dimensional array with this code below. Here it will arrange the numbers from 0 to 44 as three two-dimensional arrays of shape 3×5.

B is a 3D matrix. the indices that you specified (2x3x4) is exactly what is printed out. the outermost brackets have 2 elements, the middle brackets have 3 elements, and the innermost brackets have 4 elements.

How to Index, Slice and Reshape NumPy Arrays for Machine Learning, Structures like lists and NumPy arrays can be sliced. in the 2D array, reshapes the array, then summarizes the shape of the new 3D array. Slicing an array. You can slice a numpy array is a similar way to slicing a list - except you can do it in more than one dimension. As with indexing, the array you get back when you index or slice a numpy array is a view of the original array. It is the same data, just accessed in a different order.

I hope the below example would clarify the second part of your question where you have asked about getting a 2X3 matrics when you type `print(B[:,:,1])`

```import numpy as np
B = [[[1,2,3,4],
[5,6,7,8],
[9,10,11,12]],

[[13,14,15,16],
[17,18,19,20],
[21,22,23,24]]]

B = np.array(B)
print(B)
print()
print(B[:,:,1])

[[[ 1  2  3  4]
[ 5  6  7  8]
[ 9 10 11 12]]

[[13 14 15 16]
[17 18 19 20]
[21 22 23 24]]]

[[ 2  6 10]
[14 18 22]]
```

Since the dimension of B is `2X3X4`, It means you have two matrices of size `3X4` as far as `repr` of B is concerned

Now in `B[:,:,1]` we are passing `:` , `:` and `1`. First `:` indicates that we are selecting both the `3X4` matrices. The second `:` indicates that we are selecting all the rows from both the `3X4` matrices. The third parameter `1` indicates that we are selecting only the second column values of all the rows from both the `3X4` matrices. Hence we get

```[[ 2  6 10]
[14 18 22]]
```

Indexing and Slicing of 1D, 2D and 3D Arrays in Numpy, 1D Array Slicing And Indexing. Import Numpy in your notebook and generate a one-dimensional array. Here, I am using a Jupyter Notebook. First, I will cover how to index 1-dimensional arrays. And then, we will also learn how to index 2-dimensional arrays. Lastly, we will touch base on how to slice our Numpy arrays. If you are not familiar with Numpy arrays and how they work, then please make sure to check out the following article: NumPy Tutorial for Beginners – Arrays

Accessing Data Along Multiple Dimensions in an Array, Topic: Indexing into multi-dimensional numpy arrays, Difficulty: Easy, Category: Section. Similar to Python's sequences, we use 0-based indices and slicing to access the retrieving a single element from a 3D-array >>> d3_array[0, 1, 0] 2. The first item of the array can be sliced by specifying a slice that starts at index 0 and ends at index 1 (one item before the ‘to’ index). # simple slicing from numpy import array # define array data = array ( [11, 22, 33, 44, 55]) print (data [0:1]) 1. 2.

Working with Numpy Arrays: Indexing & Slicing, Working with Numpy Arrays: Indexing & Slicing So to access the third element in the array, use the index 2. 1 array1. python. Output: 1 2. Slicing arrays. Slicing in python means taking elements from one given index to another given index. We pass slice instead of index like this: [start:end]. We can also define the step, like this: [start:end:step]. If we don't pass start its considered 0. If we don't pass end its considered length of array in that dimension

Boolean or “mask” index arrays, It is possible to slice and stride arrays to extract arrays of the same number of dimensions, but of different sizes than the original. The slicing and striding works   Indexing and Slicing are two of the most common operations that you need to be familiar with when working with Numpy arrays. You will use them when you would like to work with a subset of the array. This guide will take you through a little tour of the world of Indexing and Slicing on multi-dimensional arrays.