Changhyoni_developer

### 2021.12.18

배열 전치 및 축 변경

#In[]
import numpy as np

a2 = np.array([[1,2,3,], [4,5,6], [7,8,9]])

print(a2)
print(a2.T)

#Out[]
[[1 2 3]
 [4 5 6]
 [7 8 9]]

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

#In[]
a3 = np.array([[[1,2,3], [4,5,6], [7,8,9]],
               [[1,2,3], [4,5,6], [7,8,9]],
               [[1,2,3], [4,5,6], [7,8,9]]])

print(a3)
print(a3.T)

#Out[]
[[[1 2 3]
  [4 5 6]
  [7 8 9]]

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

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

 [[2 2 2]
  [5 5 5]
  [8 8 8]]

 [[3 3 3]
  [6 6 6]
  [9 9 9]]]

#In[]
print(a2)
print(a2.swapaxes(1,0))

#Out[]
[[1 2 3]
 [4 5 6]
 [7 8 9]]

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

#In[]
print(a3)
print(a3.swapaxes(0,1))       #0차원 축과 1차원 축을 바꿔라
print(a3.swapaxes(1,2))       #1차원 축과 2차원 축을 바꿔라

#Out[]
[[[1 2 3]
  [4 5 6]
  [7 8 9]]

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

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

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

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

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

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

배열 재구조화

• reshape(): 배열의 형상을 변경

#In[]
n1 = np.arange(1, 10)
print(n1)
print(n1.reshape(3,3))

#Out[]
[1 2 3 4 5 6 7 8 9]

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

• newaxis(): 새로운 축 추가

#In[1]
print(n1)
#Out[1]
[1 2 3 4 5 6 7 8 9]


#In[2]
print(n1[np.newaxis, :5])
#Out[2]
[[1 2 3 4 5]]


#In[3]
print(n1[:5, np.newaxis])
#Out[3]
[[1]
 [2]
 [3]
 [4]
 [5]]

배열 크기 변경 resize()

• 배열 모양만 변경

#In[1]
n2 = np.random.randint(0, 10, (2,5))
print(n2)
#Out[1]
[[4 4 8 0 7]
 [1 1 3 8 9]]

#In[2]
n2.resize((5,2))
print(n2)
#Out[2]
[[4 4]
 [8 0]
 [7 1]
 [1 3]
 [8 9]]

• 배열 크기 증가
• 남은 공간은 0으로 채워짐

#In[]
n2.resize((5,5))
print(n2)

#Out[]
[[7 1 6 8 1]
 [1 8 7 4 3]
 [0 0 0 0 0]
 [0 0 0 0 0]
 [0 0 0 0 0]]
 
 #코랩에서 실행이 안되어서 주피터노트북에서 실행!(값이 달라졌음)

• 배열 크기 감소
• 포함되지 않은 값은 삭제됨

#In[]
n2.resize((3,3))
print(n2)

#Out[]
[[7 1 6]
 [8 1 1]
 [8 7 4]]

배열 추가

• append(): 배열의 끝에 값 추가

#In[]
a2 = np.arange(1, 10).reshape(3,3)
print(a2)
b2 = np.arange(10,19).reshape(3,3)
print(b2)

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

• axis 지정이 없으면 1차원 배열 형태로 변형되어 결합

#In[]
c2 = np.append(a2, b2)
print(c2)

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

• axis를 0으로 지정
• shape[0]을 제외한 나머지 shape은 같아야 함

#In[]
c2 = np.append(a2, b2, axis = 0)
print(c2)

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

• axis를 1로 지정
• shape[1]을 제외한 나머지 shape은 같아야 함

#In[]
c2 = np.append(a2, b2, axis = 1)
print(c2)

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

배열 연결

• concatenate(): 튜플이나 배열의 리스트를 인수로 사용해 배열 연결

#In[1]
a1 = np.array([1,3,5])
b1 = np.array([2,4,6])
np.concatenate([a1,b1])

#Out[1]
array([1, 3, 5, 2, 4, 6])

#In[2]
c1 = np.array([7,8,9])
np.concatenate([a1,b1,c1])

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

#In[1]
a2 = np.array([[1,2,3,],
               [4,5,6]])
np.concatenate([a2,a2])
#Out[1]
array([[1, 2, 3],
       [4, 5, 6],
       [1, 2, 3],
       [4, 5, 6]])
       
#In[2]
np.concatenate([a2,a2],axis=1)
#Out[2]
array([[1, 2, 3, 1, 2, 3],
       [4, 5, 6, 4, 5, 6]])

• vstack(): 수직 스택(vertical stack), 1차원으로 연결

#In[]
np.vstack([a2,a2])

#Out[]
array([[1, 2, 3],
       [4, 5, 6],
       [1, 2, 3],
       [4, 5, 6]])

• hstack(): 수평 스택(horizontal stack), 2차원으로 연결

#In[]
np.hstack([a2,a2])

#Out[]
array([[1, 2, 3, 1, 2, 3],
       [4, 5, 6, 4, 5, 6]])

• dstack(): 깊이 스택(depth stack), 3차원으로 연결

#In[]
np.dstack([a2,a2])

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

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

• stack(): 새로운 차원으로 연결

#In[]
np.stack([a2,a2])

#Out[]
array([[[1, 2, 3],
        [4, 5, 6]],

       [[1, 2, 3],
        [4, 5, 6]]])

배열 분할

• split(): 배열 분할

#In[1]
a1 = np.arange(0,10)
print(a1)
#Out[1]
[0 1 2 3 4 5 6 7 8 9]

#In[2]
b1, c1 = np.split(a1,[5])
print(b1, c1)
#Out[2]
[0 1 2 3 4] [5 6 7 8 9]

#In[3]
np.split(a1, [2,4,6,8])
#Out[3]
[array([0, 1]), array([2, 3]), array([4, 5]), array([6, 7]), array([8, 9])]

• vsplit(): 수직 분할, 1차원으로 분할

#In[]
a2 = np.arange(1, 10).reshape(3,3)
print(a2)

b2, c2 = np.vsplit(a2, [2])
print(b2)
print(c2)

#Out[]
[[1 2 3]
 [4 5 6]
 [7 8 9]]
 
[[1 2 3]
 [4 5 6]]
 
[[7 8 9]]

• hsplit(): 수평 분할, 2차원으로 분할

#In[]
a2 = np.arange(1, 10).reshape(3,3)
print(a2)

b2, c2 = np.hsplit(a2, [2])

print(b2)
print(c2)

#Out[]
[[1 2 3]
 [4 5 6]
 [7 8 9]]
 
[[1 2]
 [4 5]
 [7 8]]
 
[[3]
 [6]
 [9]]

• dsplit(): 깊이 분할, 3차원으로 분할

#In[]
a3 = np.arange(1, 28).reshape(3,3,3)
print(a3)

b3, c3 = np.dsplit(a3, [2])

print(b3)
print(c3)

#Out[]
[[[ 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]]]
--------------------
[[[ 1  2]
  [ 4  5]
  [ 7  8]]

 [[10 11]
  [13 14]
  [16 17]]

 [[19 20]
  [22 23]
  [25 26]]]
-----------------
[[[ 3]
  [ 6]
  [ 9]]

 [[12]
  [15]
  [18]]

 [[21]
  [24]
  [27]]]

### 2021.12.18

배열 값 삽입

• insert(): 배열의 특정 위치에 값 삽입
• axis를 지정하지 않으면 1차원 배열로 변환
• 추가할 방향을 axis로 지정
• 원본 배열 변경없이 새로운 배열 반환

#In[1]
import numpy as np
a1 = np.array([1,2,3,4,5])
 
print(a1)
b1 = np.insert(a1, 0, 10)    # a1의 0번째에 10을 넣어라!
print(b1)

#Out[1]
[1 2 3 4 5]
[10  1  2  3  4  5]

#In[2]
print(a1)
#Out[2]
[1 2 3 4 5]      #a1의 값은 변하지 않는다!

#In[3]
c1 = np.insert(a1, 2, 10)
print(c1)
#Out[3]
[ 1  2 10  3  4  5]

#In[1]
a2 = np.array([[1,2,3,], [4,5,6], [7,8,9]])
print(a2)
#Out[1]
[[1 2 3]
 [4 5 6]
 [7 8 9]]

#In[2]
b2 = np.insert(a2, 1, 10, axis=0)
print(b2)
#Out[2]
[[ 1  2  3]
 [10 10 10]
 [ 4  5  6]
 [ 7  8  9]]

#In[3]
c2 =np.insert(a2, 1, 10, axis=1)
print(c2)
#Out[3]
[[ 1 10  2  3]
 [ 4 10  5  6]
 [ 7 10  8  9]]

배열 값 수정

• 배열의 인덱싱으로 접근하여 값 수정

#In[]
print(a1)
a1[0] = 6
a1[1] = 7
print(a1)

#Out[]
[1 2 3 4 5]
[6 7 3 4 5]

#In[1]
a1[0:1] = 9
print(a1)
#Out[1]
[9 7 3 4 5]

#In[2]
i = np.array([1,3,4])
a1[i] = 0
print(a1)
#Out[2]
[9 0 3 0 0]

#In[3]
a1[i] += 4
print(a1)
#Out[3]
[9 4 3 4 4]

#In[]
print(a2)
a2[1, 1] = 1
a2[2, 2] = 2
a2[0] = 1
print(a2)

#Out[]
[[1 2 3]
 [4 5 6]
 [7 8 9]]
[[1 1 1]
 [4 1 6]
 [7 8 2]]

#In[1]
a2[1:, 2] = 9
print(a2)

#Out[1]
[[1 1 1]
 [4 1 9]
 [7 8 9]]

#In[2]
row = np.array([0,1])
col = np.array([1,2])
a2[row,col] = 0
print(a2)

#Out[2]
[[1 0 1]
 [4 1 0]
 [7 8 9]]

배열 값 삭제

• delete(): 배열의 특정 위치에 값 삭제
• axis를 지정하지 않으면 1차원 배열로 변환
• 삭제할 방향을 axis로 지정
• 원본 배열 변경없이 새로운 배열 반환

#In[]
print(a1)
b1 = np.delete(a1, 1)
print(b1)

#Out[]
[9 4 3 4 4]
[9 3 4 4]

#In[1]
print(a2)
#Out[1]
[[1 0 1]
 [4 1 0]
 [7 8 9]]

#In[2]
b2 = np.delete(a2, 1, axis=0)
print(b2)
#Out[2]
[[1 0 1]
 [7 8 9]]

#In[3]
c2 = np.delete(a2, 1, axis=1)
print(c2)
#Out[3]
[[1 1]
 [4 0]
 [7 9]]

배열 복사

• 리스트 자료형과 달리 배열의 슬라이스는 복사본이 아님

#In[1]
print(a2)
#Out[1]
[[1 0 1]
 [4 0 0]
 [7 8 9]]

#In[2]
a2_sub = a2[:2, :2]
print(a2_sub)
#Out[2]
[[1 0]
 [4 0]]

#In[3]
a2_sub[:, 1] = 2
print(a2_sub)
#Out[3]
[[1 2]
 [4 2]]

#In[4]
print(a2)
#Out[4]
[[1 2 1]
 [4 2 0]
 [7 8 9]]
 
 #넘파이는 슬라이싱한 값이 변경되면 원본값도 변경된다.

• copy(): 배열이나 하위 배열 내의 값을 명시적으로 복사

#In[1]
print(a2)
#Out[1]
[[1 2 1]
 [4 2 0]
 [7 8 9]]
 
#In[2]
a2_sub_copy = a2[:2, :2].copy()
print(a2_sub_copy)
#Out[2]
[[1 2]
 [4 2]]

#In[3]
a2_sub_copy[:, 1] = 0
print(a2_sub_copy)
#Out[3]
[[1 0]
 [4 0]]

#In[4]
print(a2)
#Out[4]
[[1 2 1]
 [4 2 0]
 [7 8 9]]
 
 #copy()를 통해서 복사하면 원본은 변경이 되지 않는다.

### 2021.12.16

배열 속성 정보

import numpy as np

def array_info(array):
  print(array)
  print("ndim : ", array.ndim)
  print("shape : ", array.shape)
  print("dtype : ", array.dtype)
  print("size : ", array.size)
  print("itemsize : ", array.itemsize)
  print("nbytes : ", array.nbytes)
  print("strides : ", array.strides)

#In[]
a1 = np.array([1,2,3,4,5])

array_info(a1)

#Out[]
[1 2 3 4 5]
ndim :  1
shape :  (5,)
dtype :  int64
size :  5
itemsize :  8        
nbytes :  40        #size * itemsize
strides :  (8,)     #다음으로 넘어가기위한 itemsize

#In[]
a2 = np.array([[1,2,3,], [4,5,6], [7,8,9]])

array_info(a2)

#Out[]
[[1 2 3]
 [4 5 6]
 [7 8 9]]
ndim :  2
shape :  (3, 3)
dtype :  int64
size :  9
itemsize :  8
nbytes :  72
strides :  (24, 8)     #다음 차원으로 넘어갈때 필요한 바이트

#In[]
a3 = np.array([[[1,2,3], [4,5,6], [7,8,9]],
               [[1,2,3], [4,5,6], [7,8,9]],
               [[1,2,3], [4,5,6], [7,8,9]]])
               
array_info(a3)

#Out[]
[[[1 2 3]
  [4 5 6]
  [7 8 9]]

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

 [[1 2 3]
  [4 5 6]
  [7 8 9]]]
ndim :  3
shape :  (3, 3, 3)
dtype :  int64
size :  27
itemsize :  8
nbytes :  216
strides :  (72, 24, 8)

인덱싱(Indexing)

#In[]
print(a1)
print(a1[0])
print(a1[-1])
print(a1[-2])

#Out[]
[1 2 3 4 5]
1
5
4

#In[]
print(a2)
print(a2[0, 2])
print(a2[1, 1])
print(a2[2, -1])
print(a2[0, :])

#Out[]
[[1 2 3]
 [4 5 6]
 [7 8 9]]
3
5
9
[1 2 3]

#In[1]
print(a3)
#Out[1]
[[[1 2 3]
  [4 5 6]
  [7 8 9]]

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

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

#In[2]
print(a3[0,0,0])
#Out[2]
1

#In[3]
print(a3[1,:,:])
#Out[3]
[[1 2 3]
 [4 5 6]
 [7 8 9]]

#In[4]
print(a3[:,1,:])
#Out[4]
[[4 5 6]
 [4 5 6]
 [4 5 6]]

불리언 인덱싱(Boolean Indexing)

• 배열 각 요소의 선택 여부를 불리언(True or False)로 지정
• True 값인 인덱스의 값만 조회

#In[]
print(a1)
b1 = [False, True, True, False, True]
print(a1[b1])

#Out[]
[1 2 3 4 5]
[2 3 5]

#In[]
print(a1)
b2 = np.random.randint(0, 2, (3,3), dtype=bool)
print(b2)
print(a2[b2])

#Out[]
[1 2 3 4 5]

[[False  True False]
 [False  True False]
 [False False  True]]
 
[2 5 9]

팬시 인덱싱(Fancy Indedxing)

#In[1]
print(a1)
print(a1[0], a1[2])
#Out[1]
[1 2 3 4 5]
1 3

#In[2]
ind = [0,2]
print(a1[ind])
#Out[2]
[1 3]

#In[3]
ind = np.array([[0,1],
                [2,0]])
print(a1[ind])
#Out[3]
[[1 2]
 [3 1]]

#In[1]
print(a2)
#Out[1]
[[1 2 3]
 [4 5 6]
 [7 8 9]]

#In[2]
row = np.array([0,2])
col = np.array([1,2])
print(a2[row, col])
print(a2[:, col])
print(a2[row, :])

#Out[2]
[2 9]

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