✳ Numpy

✅ numpy 개요

▶ type, shape, dtype

import numpy as np

array1 = np.array([1, 2, 3])
print('array1 type : {0}'.format(type(array1)))
print('array1 shape : {0}'.format(array1.shape))
print('array1 {0}차원'.format(array1.ndim))
print('array1 dtype: {0}'.format(array1.dtype))

print("")

array2 = np.array([[1, 2, 3],
                 [4, 5, 6]])
print('array2 type : {0}'.format(type(array2)))
print('array2 shape : {0}'.format(array2.shape))
print('array2 {0}차원'.format(array2.ndim))

print("")

array3 = np.array([[1, 2, 3]])
print('array3 type : {0}'.format(type(array3)))
print('array3 shape : {0}'.format(array3.shape))
print('array3 {0}차원'.format(array3.ndim))

array1 type : <class 'numpy.ndarray'>
array1 shape : (3,)
array1 1차원
array1 dtype: int32

array2 type : <class 'numpy.ndarray'>
array2 shape : (2, 3)
array2 2차원

array3 type : <class 'numpy.ndarray'>
array3 shape : (1, 3)
array3 2차원

mixed_list = [1, 2, 'string_data']
mixed_array = np.array(mixed_list)
print('mixed_array dtype :', mixed_array.dtype) # type이 섞여있을 경우 더 큰 data type으로 casting

mixed_array dtype : <U11

array_int = np.array([1, 2, 3])
array_float = array_int.astype('float64')
print(array_int.dtype)
print(array_float.dtype)

int32
float64

▶ arange, zeros, ones

print('sequence array')
sequence_array = np.arange(10)
print(sequence_array)

print('zero array')
zero_array = np.zeros((3, 2), dtype='int32')
print(zero_array)

print("one array")
one_array = np.ones((3, 2)) # default type : float64
print(one_array)

sequence array
[0 1 2 3 4 5 6 7 8 9]
zero array
[[0 0]
 [0 0]
 [0 0]]
one array
[[1. 1.]
 [1. 1.]
 [1. 1.]]

▶ reshape

ndarray의 차원과 크기를 변화

array1 = np.arange(10)
array2 = array1.reshape(2, 5)
array3 = array2.reshape(5, 2)

print('array1 : {0} \n array2 : {1} \n array3 : {2}'.format(array1, array2, array3))

array1 : [0 1 2 3 4 5 6 7 8 9] 
 array2 : [[0 1 2 3 4]
 [5 6 7 8 9]] 
 array3 : [[0 1]
 [2 3]
 [4 5]
 [6 7]
 [8 9]]

-1를 인자로 사용하면 기존의 ndarray와 호환되는 shape으로 변환

array1 = np.arange(10)
array2 = array1.reshape(-1, 5)
array3 = array2.reshape(-1, 2)
print('array1 : {0} \n array2 : {1} \n array3 : {2}'.format(array1, array2, array3))

array1 : [0 1 2 3 4 5 6 7 8 9] 
 array2 : [[0 1 2 3 4]
 [5 6 7 8 9]] 
 array3 : [[0 1]
 [2 3]
 [4 5]
 [6 7]
 [8 9]]

호환이 불가능한 reshape 은 Value Error 발생

array1 = np.arange(10)
array2 = array1.reshape(-1, 4) # 인자로 -1를 사용하더라도 10개의 data를 고정된 4개의 column을 가진 row로는 변경불가

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Input In [22], in <cell line: 2>()
      1 array1 = np.arange(10)
----> 2 array2 = array1.reshape(-1, 4)

ValueError: cannot reshape array of size 10 into shape (4)

▶ Indexing, Slicing

1. 특정 데이터만 추출
2. Slicing: 연속된 인덱스상의 ndarray 추출
3. Fancy Indexing: 일정한 인덱싱 집합을 list 또는 ndarray형태로 저장해 해당 위치에 있는 데이터의 ndarray 반환
4. Boolean Indexing: 특정 조건에 해당하는지 여부를 기반으로 True인 인덱스의 data의 ndarray반환

2차원 slicing

array1 = np.arange(1, 10).reshape(3, 3)
print('--- array1 ---')
print(array1)

array2 = array1[1:, :2]
print('--- array2 ---')
print(array2)

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

fancy indexing

array3 = array1[[0, 1], 2]
print('--- array3 ---')
print(array3)

--- array3 ---
[3 6]

boolean indexing

1. 필터링 조건 확인
2. True에 해당하는 index 값 저장 (True값이 아닌 index를 저장)
3. 지정된 index data set으로 ndarray return

# 5보다 큰 값만 indexing 하기
array4 = array1[array1 > 5]
print('--- array4 ---')
print(array4)

--- array4 ---
[6 7 8 9]

▶ 행렬의 정렬 : sort(), argsort()

• np.sort() : numpy에서 호출 -> 원본 유지한 채 정렬된 새 행렬 return
• ndarray.sort() : 행렬 자체에서 호출 -> 원본 행렬 자체를 정렬한 채 return

org_array = np.array([ 3, 1, 9, 5]) 
print('원본 행렬:', org_array)

# np.sort( )로 정렬 
sort_array1 = np.sort(org_array)         
print ('np.sort( ) 호출 후 반환된 정렬 행렬:', sort_array1) 
print('np.sort( ) 호출 후 원본 행렬:', org_array)

# ndarray.sort( )로 정렬
sort_array2 = org_array.sort()
print('org_array.sort( ) 호출 후 반환된 행렬:', sort_array2)
print('org_array.sort( ) 호출 후 원본 행렬:', org_array)

원본 행렬: [3 1 9 5]
np.sort( ) 호출 후 반환된 정렬 행렬: [1 3 5 9]
np.sort( ) 호출 후 원본 행렬: [3 1 9 5]
org_array.sort( ) 호출 후 반환된 행렬: None
org_array.sort( ) 호출 후 원본 행렬: [1 3 5 9]

2차원 행렬 정렬

array2d = np.array([[3, 2],
                  [2, 7]])

sorted_array2d_axis0 = np.sort(array2d, axis=0)
print('--- axis0 정렬 ---')
print(sorted_array2d_axis0)

sorted_array2d_axis1 = np.sort(array2d, axis=1)
print('--- axis1 정렬 ---')
print(sorted_array2d_axis1)

--- axis0 정렬 ---
[[2 2]
 [3 7]]
--- axis1 정렬 ---
[[2 3]
 [2 7]]

정렬된 행렬의 index 반환

org_array = np.array([3, 1, 9, 5])
sort_index = np.argsort(org_array)

print('--- asc ---')
print(sort_index)

print('--- desc ---')
sort_index_desc = np.argsort(org_array)[::-1]
print(sort_index_desc)

--- asc ---
[1 0 3 2]
--- desc ---
[2 3 0 1]

name_array = np.array(['John', 'Mike', 'Sarah', 'Kate', 'Samuel'])
score_array= np.array([78, 95, 84, 98, 88])

sort_indices_asc = np.argsort(score_array)
print('성적 오름차순 정렬 시 score_array의 인덱스:', sort_indices_asc)
print('성적 오름차순으로 name_array의 이름 출력:', name_array[sort_indices_asc])

성적 오름차순 정렬 시 score_array의 인덱스: [0 2 4 1 3]
성적 오름차순으로 name_array의 이름 출력: ['John' 'Sarah' 'Samuel' 'Mike' 'Kate']

▶ 선형대수 연산 - 행렬 내적과 전치 행렬 구하기

행렬 내적 (matrix multiplication)

A = np.array([[1, 2, 3],
             [4, 5, 6]])
B = np.array([[7, 8],
             [9, 10],
             [11, 12]])

dot_product = np.dot(A, B)
print(dot_product)

[[ 58  64]
 [139 154]]

전치 행렬

: 행렬의 행과 열 위치를 교환한 원소로 구성한 행렬

A = np.array([[1, 2],
             [3, 4]])
transpose_mat = np.transpose(A)
print(transpose_mat)

[[1 3]
 [2 4]]