[Numpy] Array manipulation

1. ndarray를 다루는 여러가지 메소드

1) Reshape

- data는 그대로 유지한 채 배열의 형태만 변경

- 변경할 shape형태에 -1을 사용하면 인터프리터가 자동으로 연산

- 성립될 수 없는 shape으로 모양을 변형하려고 하면(정수로 안떨어지면) 에러 발생

my_array = np.arange(10)
my_new_array = my_array.reshape(2,5)
my_new_array2 = np.reshape(my_array, (2,-1))

print(my_array)
print(my_new_array)
print(my_new_array2)

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

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

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

 

*(1,6)과 (6,)의 차이

- 둘다 6개의 원소를 갖고 형태상으로 일차원 array

- (1,6)은 2차원 array이고 (6,)는 1차원 array이다.

 

2) transpose

- ndarray 객체는 T속성 혹은 transpose메소드를 통해 치환할 수 있다.

- 치환: 행과 열을 바꿈

- 어떤 행렬의 전치행렬을 반환하는 메소드

print(my_new_array) #(2,5) shape

## 출력
[[0 1 2 3 4]
 [5 6 7 8 9]]
 
my_new_array = my_new_array.T
print(my_new_array) #(5,2) shape

## 출력
[[0 5]
 [1 6]
 [2 7]
 [3 8]
 [4 9]]
 
my_new_array = np.transpose(my_new_array)
print(my_new_array) #(2,5) shape

## 출력
[[0 1 2 3 4]
 [5 6 7 8 9]]
 
my_3d_array = np.arange(8).reshape(2,2,2)
print(my_3d_array)

## 출력
[[[0 1]
  [2 3]]

 [[4 5]
  [6 7]]]
  
my_3d_array = my_3d_array.T
# 2D가 아닐 경우에는 항상 처음과 마지막 axis간의 치환이 이루어진다
# (0,0,1) = 1 인데 transpose를 하면 (1,0,0)의 위치로 1이라는 원소가 들어가게 된다.
print(my_3d_array)

## 출력
[[[0 4]
  [2 6]]

 [[1 5]
  [3 7]]]

 

3) swapaxes

특정 축들간의 변경(transpose의 일반화 버전)을 해주는 함수.

my_3d_array = np.arange(8).reshape(2,2,2)
print(my_3d_array)

## 출력
[[[0 1]
  [2 3]]

 [[4 5]
  [6 7]]]
  
my_3d_array = np.swapaxes(my_3d_array,0,1) # 0번째와 1번째 축 간의 교환
# 원소 5의 위치가 (1,0,1) 이었는데 (0,1,1)로 위치가 바뀜
print(my_3d_array)

## 출력
[[[0 1]
  [4 5]]

 [[2 3]
  [6 7]]]

 

4) flatten and ravel

- 두 메소드 모두 다차원 array를 1차원으로 평탄화하는 함수

- ravel(): view를 반환

- flatten(): 독립된 copy를 반환

arr = np.array([[1, 2, 3], [4, 5, 6]])
flat_arr = arr.flatten()

print(flat_arr)  # 출력: [1 2 3 4 5 6]

ravel_arr = arr.ravel()

print(ravel_arr)  # 출력: [1 2 3 4 5 6]

 

5) Expanding and Squeezing

Expanding: 배열에 새로운 차원을 추가하는 과정으로 배열의 차원을 늘린다.

# 1차원 배열 생성
arr = np.array([1, 2, 3])

print(arr.shape)  
# (3,) 1차원 배열

# Expand_dims 적용
expanded_arr = np.expand_dims(arr, axis=0)

print(expanded_arr.shape)  
# (1, 3) 2차원 배열

Squeezing: 배열에서 크기가 1인 차원(축)을 제거하는 과정으로 이를 통해 배열의 차원을 축소한다.

# 3차원 배열 생성 (1, 3, 1)
arr = np.array([[[1], [2], [3]]])

print(arr.shape) 
# (1, 3, 1)

# Squeeze 적용
squeezed_arr = np.squeeze(arr)

print(squeezed_arr.shape)  
# (3,)

 

Expanding과 Squeezing은 배열의 형태를 조작하여 특정 연산이나 함수와의 호환성을 높이는데 유용하게 사용된다.

---

2. ndarray의 결합과 분리

1. 결합

hstack, vstack, stack(hstack과 vstack의 일반화 버전), concatenate

 

1) hstack(horizontal stack)

numpy 배열을 수평으로 쌓는다.

count_to_ten = np.arange(1,11)
count_to_twenty = np.hstack([count_to_ten, count_to_ten+10])
## count_to_ten이라는 배열에 10을 더한 배열을 count_to_ten 배열에 수평으로 쌓는다.
print(count_to_twenty)

## 출력
[ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20]

 

2) vstack(vertical stack)

numpy 배열을 수직으로 쌓는다.

count_to_twenty = np.vstack([count_to_ten, count_to_ten+10]) ## count_to_ten이라는 배열에 10을 더한 배열을 count_to_ten 배열에 수직으로 쌓는다.
print(count_to_twenty)

## 출력
[[ 1  2  3  4  5  6  7  8  9 10]
 [11 12 13 14 15 16 17 18 19 20]]

 

3) stack

새로운 축을 생성하여 그 방향으로 numpy배열을 결합한다.

a = np.arange(1,5).reshape(2,2)
print(a, a.ndim, a.shape)
print("------------------------")
print(np.stack([a,a+4,a+8]), np.stack([a,a+4,a+8]).shape) #axis = 0
print("------------------------")
print(np.stack([a,a+4,a+8],axis=1), np.stack([a,a+4,a+8],axis=1).shape) #axis = 1
print("------------------------")
print(np.stack([a,a+4,a+8],axis=2), np.stack([a,a+4,a+8],axis=2).shape) #axis = 2

## 출력
[[1 2]
 [3 4]] (2, 2)
------------------------
[[[ 1  2]
  [ 3  4]]

 [[ 5  6]
  [ 7  8]]

 [[ 9 10]
  [11 12]]] (3, 2, 2)
------------------------
[[[ 1  2]
  [ 5  6]
  [ 9 10]]

 [[ 3  4]
  [ 7  8]
  [11 12]]] (2, 3, 2)
------------------------
[[[ 1  5  9]
  [ 2  6 10]]

 [[ 3  7 11]
  [ 4  8 12]]] (2, 2, 3)

 

4) concatenate

stack과는 다르게 기존에 있던 축을 활용하여 배열을 연장하는 방식이다.

axis를 통해 행 방향으로 연장할지 열 방향으로 연장할지 정할 수 있다.

a = np.arange(1,5).reshape(2,2)
print(np.concatenate([a,a+4,a+8]), np.concatenate([a,a+4,a+8]).shape) # axis=0 행 방향

## 출력
[[ 1  2]
 [ 3  4]
 [ 5  6]
 [ 7  8]
 [ 9 10]
 [11 12]] (6, 2)
 
print(np.concatenate([a,a+4,a+8],axis=1), np.concatenate([a,a+4,a+8],axis=1).shape) # axis=1 열 방향
## print(np.concatenate([a,a+4,a+8],axis=2), np.concatenate([a,a+4,a+8],axis=2).shape)
## axis=2는 없는 축이기 때문에 오류발생

## 출력
[[ 1  2  5  6  9 10]
 [ 3  4  7  8 11 12]] (2, 6)

 

2. 분리

1) split

- ndarray를 분리하는 메소드로 np.split(arr,indices_or_section,axis)방식을 취한다.

- 첫번째 인자인 array는 원본 ndarray이고 세번째 인자인 axis는 분리하는 축 방향을 의미한다. (0이 기본값)

- indices_or_sections에 해당하는 정수가 N이라면 분리되는 배열이 N개의 동일한 값을 가진다.

(나눌 수 없다면 오류 혹은 정렬된 1D의 꼴이라면 배열의 요소값을 기준으로 값을 나눈다.)

x = np.arange(6)
print(np.split(x,2)) ## 2등분
print(np.split(x,3)) ## 3등분
## print(np.split(x,4)) ## 6개의 원소를 4등분 할 수 없음(오류)

## 출력
[array([0, 1, 2]), array([3, 4, 5])]
[array([0, 1]), array([2, 3]), array([4, 5])]
#-------------------------------

x = np.arange(6)
print(np.split(x,(2,3))) ## 인덱스 2와 3을 기준으로 분리(인덱스 2 이전에 한번 끊고, 3 이전에 한번 끊고)
print(np.split(x,[2,4,5,9])) ## 인덱스 2,4,5,9를 기준으로 분리

## 출력
[array([0, 1]), array([2]), array([3, 4, 5])]
[array([0, 1]), array([2, 3]), array([4]), array([5]), array([], dtype=int64)]
#-------------------------------

x = np.arange(6).reshape(2,3)
print(np.split(x,2)) # axis=0, shape이 (2,3)이므로 0번째 축인 2가 2로 등분이 가능함
print(np.split(x,3,axis=1)) # axis = 1, shape이 (2,3)이므로 1번째 축인 3이 3으로 등분이 가능함

## 출력
[array([[0, 1, 2]]), array([[3, 4, 5]])]

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