[numpy] 01 ndarray 기본과 메소드(함수) 사용법

가장 기본적인 numpy matplotlib 사용 예제

import numpy as np
import matplotlib.pyplot as plt

x = np.array([1,2,3])
y = np.array([2,4,6])

plt.plot(x,y)

[<matplotlib.lines.Line2D at 0x39dae10>]

np.array 함수로 생성하기

x = np.array([1,2,3,4])
print(x)

y = np.array([[2,3,4],[1,2,5]])
print(y)

print(type(y))

[1 2 3 4]
[[2 3 4]
 [1 2 5]]
<class 'numpy.ndarray'>

np.arange 함수로 생성

np.arange(10)

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

np.arange(1,10)

array([1, 2, 3, 4, 5, 6, 7, 8, 9])

np.arange(1,10,2)

array([1, 3, 5, 7, 9])

np.ones, np.zeros 생성하기

np.ones((4,5))

array([[1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1.]])

np.zeros((10,5))

array([[0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.]])

np.ones((2,3,4)) #3차원 텐서,행렬

array([[[1., 1., 1., 1.],
        [1., 1., 1., 1.],
        [1., 1., 1., 1.]],

       [[1., 1., 1., 1.],
        [1., 1., 1., 1.],
        [1., 1., 1., 1.]]])

np.empty, np.full로 생성

np.empty((3,4)) #값이 중요치 않을 때

array([[1.50688244e-312, 0.00000000e+000, 8.76794447e+252,
        2.15895723e+227],
       [6.48224638e+170, 3.67145870e+228, 9.92154585e-096,
        9.03292329e+271],
       [9.08366793e+223, 1.41075687e+232, 1.16070543e-028,
        9.28330511e-310]])

np.full((3,4),7) #7로 채워진 행렬 

array([[7, 7, 7, 7],
       [7, 7, 7, 7],
       [7, 7, 7, 7]])

np.eye로 생성하기

• 단위 행렬 생성하기

np.eye(3)

array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])

np.linspace 생성하기

• A, B까지 C로 균등하게 나눠라

np.linspace(1,10,3)

array([ 1. ,  5.5, 10. ])

np.linspace(0,10,5)

array([ 0. ,  2.5,  5. ,  7.5, 10. ])

reshape 활용하기

• ndarray의 형태, 즉 차원을 바꾸기 위해 사용된다.
• 개수에 따라서 변형이 안될 수도 있다.

x = np.arange(1,16) #1차 행렬
print(x)

x.shape

x.reshape(3,5) # 3행 5열로 바뀜

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





array([[ 1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10],
       [11, 12, 13, 14, 15]])

x.reshape(5,3) # 5행 3열로 바뀜

array([[ 1,  2,  3],
       [ 4,  5,  6],
       [ 7,  8,  9],
       [10, 11, 12],
       [13, 14, 15]])

x.reshape(5,3,1) #3차원으로 바꿈, 5개의 3행 1열

array([[[ 1],
        [ 2],
        [ 3]],

       [[ 4],
        [ 5],
        [ 6]],

       [[ 7],
        [ 8],
        [ 9]],

       [[10],
        [11],
        [12]],

       [[13],
        [14],
        [15]]])

ndarray의 random 서브 모듈

rand 함수

• 0,1 사이의 분포로 랜덤 ndarray 생성

np.random.rand(2,3) #2행 3열의 0~1 랜덤 값 가진 행렬 생성

array([[0.72886999, 0.94910028, 0.31345434],
       [0.18145839, 0.03975984, 0.97423448]])

np.random.rand(15)

array([0.76685888, 0.97187153, 0.53445447, 0.39846169, 0.88127491,
       0.80973821, 0.92785113, 0.12098798, 0.16664534, 0.07807351,
       0.28177186, 0.3736704 , 0.62050166, 0.64313168, 0.74740393])

np.random.rand(5,3,4)

array([[[0.19809477, 0.31378448, 0.74764731, 0.51737236],
        [0.73277931, 0.32572089, 0.00860725, 0.37813462],
        [0.91155975, 0.47526214, 0.55645413, 0.37734492]],

       [[0.14274439, 0.80324797, 0.63827084, 0.21523872],
        [0.38737232, 0.30654081, 0.58666195, 0.79524348],
        [0.52467025, 0.16485654, 0.56141351, 0.79484729]],

       [[0.52959335, 0.13102399, 0.47832497, 0.1724175 ],
        [0.46184438, 0.35510138, 0.00999062, 0.19703025],
        [0.7401764 , 0.33153204, 0.88254557, 0.04658169]],

       [[0.85173741, 0.28403725, 0.97504382, 0.03069827],
        [0.92606823, 0.82850191, 0.84800312, 0.80516618],
        [0.85860437, 0.21754183, 0.78898147, 0.07193757]],

       [[0.48175745, 0.26635793, 0.08558726, 0.8467584 ],
        [0.49038372, 0.22066375, 0.00541887, 0.41744155],
        [0.89321429, 0.07341297, 0.26951571, 0.32354557]]])

randn 함수

• 정규분포도의 확률과 값에 의거하여 표준화(샘플링)된 랜덤 ndarray 생성
• n : normal distribution(정규분포)
• 정규분포 위키

np.random.randn(3,4) #3x4행렬, 정규분포도 값이 확률이반영되어서 생성

array([[ 0.19890271, -1.84710768,  2.13218124, -1.51729918],
       [ 1.90649149,  1.10777241,  0.5964645 ,  0.45329657],
       [ 2.54523749,  1.85428371, -1.60277995,  1.16420599]])

np.random.randn(3,4,5) #3x4x5행렬, 정규분포도 샘플 행렬

array([[[ 1.27443589, -0.478378  ,  0.20368954, -1.21865605,
         -0.71131651],
        [-0.26748836,  0.48619121,  1.02331975,  1.33920463,
          0.94256896],
        [ 0.35255196, -1.22410674,  0.57437183, -0.15700616,
         -0.57488048],
        [ 0.72381501,  0.444919  , -0.42878318, -0.41342329,
          0.17071614]],

       [[ 0.31613786, -1.32956108,  0.24488162,  0.01261359,
          0.74311378],
        [-0.03213392,  1.33757371, -0.25058467, -0.20900166,
         -0.74347582],
        [ 0.28337088,  1.49554953,  0.68548681, -0.89646149,
         -0.68368177],
        [ 1.17517367, -0.38759232, -0.391396  ,  0.79388275,
          0.45003906]],

       [[-0.38866831, -0.09394488,  0.96886688, -0.14885087,
         -0.75609601],
        [ 0.43354328, -0.07213129, -0.0853028 , -0.22082339,
         -1.20875301],
        [-0.79718055,  1.34291183, -0.0036283 ,  0.06244328,
          0.35201333],
        [-0.16138652, -0.67570211,  1.80563662,  1.39896323,
         -0.24474769]]])

randint 함수

• 특정 정수 사이에서 랜덤하게 표준화 행렬 생성
• low값은 필수, high값은 없으면 None이 들어감

np.random.randint(1,100, size=(3,5)) #100은 포함하지 않음

array([[21, 67, 38, 57, 24],
       [ 3, 19, 61, 84, 49],
       [22, 66,  6, 89, 81]])

np.random.randint(1,100, size=(10,)) #100은 포함하지 않음, size는 무조건 튜플이여야되서 하나의 값도 이처럼 넣어줌

array([31, 18, 54, 69, 51, 92, 92, 84, 54, 79])

seed 함수

• seed : 랜덤을 만드는 기준이 되는 값, 보통은 시간에 따라 달라지나 이를 의도된값으로 주면 같은 랜덤값을 매번 같은 값을 얻을 수 있다.
• 랜덤할 값을 동일하게 생성할 수 다시 생성하여, 똑같은 테스트를 해야될 때
• seed 함수는 1회용이다. 랜덤 관련 함수를 생성할 때 미리 한 번 실행해야한다.(스택 채워놓는 느낌)

np.random.seed(100)

np.random.randn(3,4) #seed를 안하고 하면 다시 바뀐다.

array([[-0.58359505,  0.81684707,  0.67272081, -0.10441114],
       [-0.53128038,  1.02973269, -0.43813562, -1.11831825],
       [ 1.61898166,  1.54160517, -0.25187914, -0.84243574]])

choice 함수

• 주어진 1차 ndarray에서 랜덤하게 표준화(샘플링) 행렬을 만든다.
• 정수가 주어진 경우는, np.random.randint(0, 숫자값-1, size=(행,렬)) 과 같은 결과가 나온다.

np.random.choice(100,size=(3,4)) #첫번째 숫자값을 기준으로 만들어진다. 즉 0~99까지. np.random.randint(0,100, size=(행,렬))

array([[ 0, 13, 57, 76],
       [ 3, 70,  3, 84],
       [79, 10, 87, 60]])

x= np.array([1,2,3,1.4,2.5,4,3.3])

np.random.choice(x, size=(2,2)) #x에서 추출해서 2x2행렬을 만듬. 중복 허용

array([[3. , 3.3],
       [3. , 3.3]])

np.random.choice(x, size=(2,2),replace=False) #x에서 추출해서 2x2행렬을 만듬. 중복 불가

array([[3.3, 2. ],
       [1. , 4. ]])

확률분포에 따른 ndarray 생성

• uniform : 균등 분포
• normal : 우리가 아는 정규분포
• 기타 등등

#균등 분포, 1부터 3까지 균등한 분포를 이룰 때의 표준화4x5행렬
np.random.uniform(1.0, 3.0, size=(4,5))

array([[1.7508785 , 1.68747907, 2.31007041, 2.42207599, 1.22707515],
       [1.26605738, 1.91207812, 1.31947246, 2.92328381, 2.67523149],
       [2.04032137, 1.43654452, 1.26983745, 2.95814069, 2.41408699],
       [2.71995111, 1.77434526, 1.50166804, 1.59887604, 2.71379106]])

#정규 분포. 평균(loc)과 표준편차(sacle)을 가진 정규분포에서 추출된 표준화 4x5행렬
np.random.normal(size=(4,5)) #기본 정규분포

array([[-1.98362094,  0.16713678, -0.178894  ,  1.17823916, -0.44340799],
       [ 0.7389539 , -0.15484845, -0.08605564, -0.33575684, -0.13662938],
       [ 0.09277642,  0.18971879, -2.04867192,  0.78378608, -0.23298456],
       [-1.18441143, -0.19779729, -0.85467279,  0.0235975 , -0.17045647]])

# 표준편차 있는 정규분포(기본이 1)
np.random.normal(scale = 2, size=(4,5)) #표준편차2-> 평균에서 많이 멀어진다.

array([[ 2.06469182,  3.2338798 , -0.10966047, -0.4960227 , -0.7934499 ],
       [-0.06709405,  2.06583609, -3.97964448, -0.55606743,  1.53139085],
       [ 1.48829914, -3.44638665,  2.06078485,  0.11942954, -1.86843168],
       [-2.12488227, -1.25889172, -0.60456885,  2.07927779, -1.86193931]])

# 표준편차 있는 정규분포(기본이 1)
np.random.normal(scale = 0.5, size=(4,5)) #분포도가 평균에서 가깝다. 비교적 0.으로 시작되는게 위 값보다 많다.

array([[-0.00677896,  0.18794841, -0.11829118,  0.48957067,  0.5468741 ],
       [-0.69181108,  0.50506694,  0.43633156,  0.51880617,  0.15127385],
       [-0.64905874,  0.42393186, -0.1344382 ,  0.1509915 , -1.13595275],
       [ 0.37880249,  0.43802559,  1.07811   ,  0.64435128, -0.0712676 ]])

# 표준편차 1에 평균 0이라면 위의 rand 함수와 같다.
np.random.rand(4,5)

array([[0.40099783, 0.61950328, 0.50070912, 0.5008895 , 0.6089031 ],
       [0.99536524, 0.24794952, 0.73843341, 0.93004392, 0.58441208],
       [0.88064715, 0.69205912, 0.35141828, 0.82069945, 0.23708496],
       [0.92169367, 0.9188489 , 0.62953071, 0.51222312, 0.29985152]])

표준편차

• 출처 : 위키백과 : https://ko.wikipedia.org/wiki/%ED%91%9C%EC%A4%80_%ED%8E%B8%EC%B0%A8

• 자료의 산포도를 나타내는 수치로, 분산의 양의 제곱근으로 정의된다.

• 표준편차가 작을수록 평균값에서 변량들의 거리가 가깝다.

• 통계학과 확률에서 주로 확률의 분포, 확률변수 혹은 측정된 인구나 중복집합을 나타낸다.

• 일반적으로 모집단의 표준편차는 σ {\displaystyle \sigma } \sigma (시그마)로, 표본의 표준편차는 S {\displaystyle S} S(에스)로 나타낸다.

• 편차(deviation)는 관측값에서 평균 또는 중앙값을 뺀 것이다.
• 분산(variance)은 관측값에서 평균을 뺀 값을 제곱하고, 그것을 모두 더한 후 전체 개수로 나눠서 구한다.
• 즉, 차이값의 제곱의 평균이다. 관측값에서 평균을 뺀 값인 편차를 모두 더하면 0이 나오므로 제곱해서 더한다.

• 표준 편차(standard deviation)는 분산을 제곱근한 것이다. 제곱해서 값이 부풀려진 분산을 제곱근해서 다시 원래 크기로 만들어준다.
• 모 표준 편차(population standard deviation) σ는 모집단의 표준 편차이다. 모 분산 σ2에 제곱근을 씌워서 구한다.
• 표본 표준 편차(sample standard deviation) s는 표본의 표준 편차이다. 표본 분산 s2에 제곱근을 씌워서 구한다.

인덱싱

• 일반 인덱싱과 동일
• 다차원 행렬의 경우 매번 접근을 [index][index]로 하지 않고, [index,index...]를 이용할 수 있다.

1차원 인덱싱

x = np.arange(10)
print(x)

[0 1 2 3 4 5 6 7 8 9]

x[0], x[-1]

(0, 9)

x[3] = 100
print(x)

[  0   1   2 100   4   5   6   7   8   9]

2차원 인덱싱

x = np.arange(10).reshape(2,5)
print(x)

[[0 1 2 3 4]
 [5 6 7 8 9]]

x[0]

array([0, 1, 2, 3, 4])

x[0][0], x[0][-1]

(0, 4)

x[0,0], x[0,-1]

(0, 4)

3차원 인덱싱

x = np.arange(16).reshape(2,2,4)
print(x)

[[[ 0  1  2  3]
  [ 4  5  6  7]]

 [[ 8  9 10 11]
  [12 13 14 15]]]

x[0,0,0]

0

슬라이싱

• 인덱싱처럼 파이썬처럼 기본적인 건 동일하다.
• 여기서도 , 를 사용하여 슬라이싱 할 수 있다.

1차원 벡터 슬라이싱

x = np.arange(10)
print(x)

[0 1 2 3 4 5 6 7 8 9]

x[1:5]

array([1, 2, 3, 4])

x[:]

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

x[3:]

array([3, 4, 5, 6, 7, 8, 9])

2차원 벡터 슬라이싱

x = np.arange(16).reshape(4,4)
print(x)

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]

x[:,1:4] #앞은 행을 :로 했으므로 모든 행을 가져온다. 열은 1:4 했으므로 1~3인덱스만 가져온다.

array([[ 1,  2,  3],
       [ 5,  6,  7],
       [ 9, 10, 11],
       [13, 14, 15]])

x[:,:2] #앞은 행을 :로 했으므로 모든 행을 가져온다. 열은 :2 했으므로 0~1인덱스만 가져온다.

array([[ 0,  1],
       [ 4,  5],
       [ 8,  9],
       [12, 13]])

• 인덱싱과 같이 쓸 수 있는데, 이 경우 차원이 하나 줄어든다.

x[0,1:4] #인덱싱과 같이쓸 수도 있다. 0 인덱스 행에 1~3열 슬라이싱

array([1, 2, 3])

x[:1,1:4] #결과적으로 같은 걸 추출하려했으나, 위의 것과 차원이 다르다.

array([[1, 2, 3]])

3차원 슬라이싱

x = np.arange(64).reshape(4,4,4)
print(x)

[[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]
  [12 13 14 15]]

 [[16 17 18 19]
  [20 21 22 23]
  [24 25 26 27]
  [28 29 30 31]]

 [[32 33 34 35]
  [36 37 38 39]
  [40 41 42 43]
  [44 45 46 47]]

 [[48 49 50 51]
  [52 53 54 55]
  [56 57 58 59]
  [60 61 62 63]]]

x[:3,:,:] #처음 4개의 리스트중 0~2만 가져온다.

array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11],
        [12, 13, 14, 15]],

       [[16, 17, 18, 19],
        [20, 21, 22, 23],
        [24, 25, 26, 27],
        [28, 29, 30, 31]],

       [[32, 33, 34, 35],
        [36, 37, 38, 39],
        [40, 41, 42, 43],
        [44, 45, 46, 47]]])

x[:3,:3,:] #처음 4개의 리스트중 0~2만 가져온다. 그 후 각각의 리스트는 0~2만 가져온다.

array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]],

       [[16, 17, 18, 19],
        [20, 21, 22, 23],
        [24, 25, 26, 27]],

       [[32, 33, 34, 35],
        [36, 37, 38, 39],
        [40, 41, 42, 43]]])

x[:3,:3,:3] ##처음 4개의 리스트중 0~2만 가져온다. 그 후 각각의 리스트는 0~2만 가져온다. 그 다음 0~2인덱스만 가져온다.

array([[[ 0,  1,  2],
        [ 4,  5,  6],
        [ 8,  9, 10]],

       [[16, 17, 18],
        [20, 21, 22],
        [24, 25, 26]],

       [[32, 33, 34],
        [36, 37, 38],
        [40, 41, 42]]])

행렬 형태 바꾸기

ravel, np.ravel 함수

• 다차원 배열을 1차원 배열로
• order 파라미터에 'C'는 row우선 변경, 'F'면 column 우선 변경

x = np.arange(16).reshape(4,4)
print(x)

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]

#첫번째 np모듈의 ravel함수 꺼내기
np.ravel(x)

array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15])

#두번째- ndarray의 메소드 호출
x.ravel()

array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15])

• ravel로 반환된 1차원 행렬은 원본 데이터와 연결되있다.
• 즉, 데이터 주소가 같다.

temp = x.ravel()
print(temp)

[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15]

temp[0] = 100
x

array([[100,   1,   2,   3],
       [  4,   5,   6,   7],
       [  8,   9,  10,  11],
       [ 12,  13,  14,  15]])

flatten

• 다차원배열일 1차원으로
• ravel은 각 데이터의 주소는 동일하고 감싸는 구조(행렬)만 바뀐것.
• flatten은 copy가 적용된 방식,(원본 아닌 복사본) 즉, 원본은 데이터가 안바뀐다.
• order 파라미터에 'C'는 row우선 변경, 'F'면 column 우선 변경

y = np.arange(16).reshape(4,4)
print(y)

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]

y.flatten()

array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15])

temp = y.flatten()
print(temp)

[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15]

temp[0] = 100
y #원본은 변화가 없다.

array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15]])

order 매개변수 적용

x = np.arange(16).reshape(4,4)
print(x)

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]

x.flatten('C')

array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15])

x.flatten('F')

array([ 0,  4,  8, 12,  1,  5,  9, 13,  2,  6, 10, 14,  3,  7, 11, 15])

3차원에서의 ravel과 flatten

x = np.arange(64).reshape(4,4,4)
print(x)

[[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]
  [12 13 14 15]]

 [[16 17 18 19]
  [20 21 22 23]
  [24 25 26 27]
  [28 29 30 31]]

 [[32 33 34 35]
  [36 37 38 39]
  [40 41 42 43]
  [44 45 46 47]]

 [[48 49 50 51]
  [52 53 54 55]
  [56 57 58 59]
  [60 61 62 63]]]

x.flatten('C')

array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
       17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
       34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
       51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63])

x.flatten('F')

array([ 0, 16, 32, 48,  4, 20, 36, 52,  8, 24, 40, 56, 12, 28, 44, 60,  1,
       17, 33, 49,  5, 21, 37, 53,  9, 25, 41, 57, 13, 29, 45, 61,  2, 18,
       34, 50,  6, 22, 38, 54, 10, 26, 42, 58, 14, 30, 46, 62,  3, 19, 35,
       51,  7, 23, 39, 55, 11, 27, 43, 59, 15, 31, 47, 63])

reshape 함수

• ndarray를 다른 차원으로 변경
• 전체 개수가 같게 구조(행렬)을 짜야한다.
• 예 : 이미지 데이터 벡터화
  • 이미지 데이터의 경우 2차원과 3차원이 주를 이룬다.(좌표, RGB)
  • 트레이닝을 위해 이를 1차원 데이터로 바꾼다.(이 경우는 위의 ravel과 flatten이 있지만...일단 패스)

x = np.arange(16)
print(x)
print(x.shape) #행렬 형태 - > (16,) 1차원 16열이란 뜻. size 매개변수 주던 걸 생각하자.
print(x.ndim) #차원 숫자 number of dimention

[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15]
(16,)
1

y = x.reshape(4,4)
print(y)
print(y.shape)
print(y.ndim)

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]
(4, 4)
2

팁 : 행렬 구조를 작성 할 때 하나는 -1로 입력할 수 있다.(유추 가능)

z = np.arange(32)

z1 = z.reshape(4,-1)
print(z1)

[[ 0  1  2  3  4  5  6  7]
 [ 8  9 10 11 12 13 14 15]
 [16 17 18 19 20 21 22 23]
 [24 25 26 27 28 29 30 31]]

z2 = z.reshape(-1,8)
print(z2)

[[ 0  1  2  3  4  5  6  7]
 [ 8  9 10 11 12 13 14 15]
 [16 17 18 19 20 21 22 23]
 [24 25 26 27 28 29 30 31]]

z3 = z.reshape(4,4,-1)
print(z3)
print(z3.shape) # (4,4,2)
print(z3.ndim) # 3

[[[ 0  1]
  [ 2  3]
  [ 4  5]
  [ 6  7]]

 [[ 8  9]
  [10 11]
  [12 13]
  [14 15]]

 [[16 17]
  [18 19]
  [20 21]
  [22 23]]

 [[24 25]
  [26 27]
  [28 29]
  [30 31]]]
(4, 4, 2)
3