[천재교육] 넘파이(Numpy) - 인덱싱, 정렬, 선형대수 연산

Numpy ndarray

Numarray와 Numeric이라는 오래된 Python 패키지를 계승해서 나온 수학 및 과학 연산을 위한 파이썬 패키지.

기본적으로 array(배열)라는 자료를 생성하고 이를 바탕으로 색인, 처리, 연산 등을 하는 기능을 수행한다.

import numpy as np

# 데이터타입 'list'
list1 = [1, 2, 3]

# 데이터타입 'numpy.ndarray'
array1 = np.array(list1)                # array1 = np.array([1,2,3])

print(array1.shape)
=>
(3,)                                               #0행 3열   => 1차원

array2 = np.array([[1,2,3],
                             [2,3,4]])
print(array2.shape)
=>
(2, 3)                                            # 2행 3열    => 2차원

array3 = np.array([[1,2,3]])
print(array3.shape)
=>
(1, 3)                                            # 1행 3열    => 2차원

 

 

 

 

ndarray 생성하기 - arange, zeros, ones

sequence_array = np.arange(10)                            # 0~9까지 범위. range랑 같은 개념이라 보면 될 듯.
sequence_array
=> [0 1 2 3 4 5 6 7 8 9]                                            # sequence_array.shape  =>  (10,)


# (3, 2) shape을 가지는 모든 원소가 0, dtype은 int32 인 ndarray 생성.  
zero_array = np.zeros((3, 2), dtype='int32')
zero_array
=>
[[0 0]                                                                       # zero_array.shape  => (3, 2)
 [0 0]
 [0 0]]


#(3, 2) shape을 가지는 모든 원소가 1인 ndarray 생성. ,
one_array = np.ones((3, 2))
one_array
=>
[[1. 1.]                                                                        # one_array.shape  => (3, 2)
 [1. 1.]
 [1. 1.]]

 

 

 

reshape (ndarray의 차원과 크기를 변경) 

array1 = np.arange(10)
print(array1)
=>
[0 1 2 3 4 5 6 7 8 9]


array2 = array1.reshape(2, 5)                                    # 2행 5열
array2
=>
array([[0, 1, 2, 3, 4],
           [5, 6, 7, 8, 9]])


array3 = array1.reshape(-1,5)                                    # -1 이란 할 수 있는 한 최대로 / 5열
array3
=>
array([[0, 1, 2, 3, 4],
          [5, 6, 7, 8, 9]])


array4 = array1.reshape(5,-1)                                      #5 행 최대열
array4
=>
array([[0, 1],
          [2, 3],
          [4, 5],
          [6, 7],
          [8, 9]])

 

 

 

 

슬라이싱 인덱싱

array1d = np.arange(start=1, stop=10)
array1d
=>
array([1, 2, 3, 4, 5, 6, 7, 8, 9])


array2d = array1d.reshape(3,3)
array2d
=>
 [[1 2 3]
 [4 5 6]
 [7 8 9]]


array2d[0:2, 0:2]
=>
 [[1 2]
 [4 5]]


array2d[1:3, 0:3]
=>
 [[4 5 6]
 [7 8 9]]


array2d[1:3, :]
=>
 [[4 5 6]
 [7 8 9]]


array2d[:, :]
=>
 [[1 2 3]
 [4 5 6]
 [7 8 9]]


array2d[:2, 1:]                 # 2번 인덱스 행 전까지, 1번 인덱스 열부터
=>
 [[2 3]
 [5 6]]


array2d[:2, 0]
=>
[1 4]

 

 

 

팬시 인덱싱

array1d = np.arange(start=1, stop=10)
array2d = array1d.reshape(3,3)
array2d
=>
[[1 2 3]
 [4 5 6]
 [7 8 9]]


array3 = array2d[[0,1], 2]           # [[0,1], 2]  => 0번 행, 1번 행 / [[0,1], 2]  => 2번 열
array3.tolist()                              # 리스트로 출력하기
=>
[3, 6]


array4 = array2d[[0,1], 0:2]
array4.tolist()
=>
[[1, 2], [4, 5]]


array5 = array2d[[0,1]]
array5.tolist()
=>
[[1, 2, 3], [4, 5, 6]]

 

 

 

불린 인덱싱

array1d = np.arange(start=1, stop=10)
array1d
=>
[1 2 3 4 5 6 7 8 9]


array3 = array1d[array1d > 5]            # 불린 인덱싱
array3
=>
[6 7 8 9]                                               # 불린 인덱싱 조의 참인 값만 나옴


val = array1d > 5
val
=>
array([False, False, False, False, False, True, True, True, True])



boolean_indexes = np.array([False, False, False, False, False,  True,  True,  True,  True])
array3 = array1d[boolean_indexes]                         # 불린 인덱스로 필터링
array3
=>
[6 7 8 9]                                                                   # 참인 값만 나온다



indexes = np.array([5,6,7,8])                                    # 5~8번 인덱스
array4 = array1d[indexes]                                        # 일반 인덱스로 필터링
array4
=>
[6 7 8 9]

 

 

 

 

행렬의 정렬

1. sort( )

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

sort_array1 = np.sort(org_array)                        # np.sort() 정렬해도 원본데이터(org_array)는 변하지 않는다.        
sort_array1
=>
[1 3 5 9]

sort_array2 = org_array.sort()                             # sort()는 정렬 후 원본도 정렬된다.
sort_array2
=>
[1 3 5 9]

org_array
=>
[1 3 5 9]

sort_array1_desc = np.sort(org_array)[::-1]           # 내림차순 정렬
sort_array1_desc
=>
[9 5 3 1]



array2d = np.array([[8, 12], 
                               [7, 1 ]])

sort_array2d_axis0 = np.sort(array2d, axis=0)        # 로우 방향으로 정렬
sort_array2d_axis0
=>
[[ 7  1]
[ 8 12]]


sort_array2d_axis1 = np.sort(array2d, axis=1)          # 컬럼 방향으로 정렬
sort_array2d_axis1 
=>
 [[ 8 12]
 [ 1  7]]

 

 

2. argsort( )

org_array = np.array([ 3, 1, 9, 5]) 
sort_indices = np.argsort(org_array)                         # 위 데이터를 정렬하면 [1, 3, 5, 9]

sort_indices                                                   
=> [1 0 3 2]                                                                # 정렬한 데이터의 원래 인덱스 번호 반환


org_array = np.array([ 3, 1, 9, 5]) 
sort_indices_desc = np.argsort(org_array)[::-1]         # 내림차순 정렬 후 인덱스 번호 반환
sort_indices_desc
=>
[2 3 0 1]



※ 실제 활용
import numpy as np

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)                 # 성적 오름차순 정렬 시 인덱스 번호 반환
sort_indices_asc
=>
[0 2 4 1 3]

# 이렇게 두 array와 np.argsort를 이용해 성적 오름차순대로 이름을 출력할 수 있다.
name_array[sort_indices_asc]              
=>
['John' 'Sarah' 'Samuel' 'Mike' 'Kate']

 

 

 

선형대수 연산 

1. 행렬내적 (행렬 곱하기)

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

dot_product = np.dot(A, B)
dot_product

=>

# 1행의 값들 * 1열의 값들

 

2. 전치 행렬

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

=>

#1열 -> 1행으로 간다