Numpy ndarray 개요¶

# pip install numpy

import numpy as np
# 별명의 관례적으로 쓰이므로 웬만하면 맞춰주는 게 좋다

## 파이썬 list 값을 ndarray로 변환
# 1차원 
array1 = np.array([1,2,3])
print('array1 type: ', type(array1))

# shape : 몇 차원인지 보여줌
print('array1 array 형태: ',array1.shape)
# (3,) : 3행 (1차원)

# 2차원 -리스트 안에 리스트
array2 = np.array([[1,2,3],
                 [2,3,4]])

print('array2 type: ', type(array2))
print('array2 array 형태: ', array2.shape)
# (2,3) : 2행 3열 (2차원)

array3 = np.array([[1,2,3]])

print('array3 type: ', type(array3))
print('array3 array 형태: ', array3.shape)
# (1,3) : 1행 3열 (2차원)

# ndim 차원 확인
print('array1: {:0}차원, array2: {:1}차원, array3: {:2}차원'.format(array1.ndim, array2.ndim, array3.ndim))

list1 = [1,2,3]
print(type(list1))

array1 = np.array(list1)
print(type(array1))

print(array1)
print(array1.dtype)

list2 = [1,2,'test']
array2 = np.array(list2)
print(array2, array2.dtype)

list3 = [1, 2, 3.0]
array3 = np.array(list3)
print(array3, array3.dtype)

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

array_int1= array_float.astype('int32')
print(array_int1, array_int1.dtype)

array_float1 = np.array([1.1, 2.1, 3.1])
array_int2= array_float1.astype('int32')
print(array_int2, array_int2.dtype)

# 파이썬의 range()
sequence_array = np.arange(10)
print(sequence_array)
print(sequence_array.dtype, sequence_array.shape)

# 0으로 초기화 int32 
# zeros
zero_array = np.zeros((3,2),dtype='int32')
print(zero_array)
print(zero_array.dtype, zero_array.shape)

# 1. 로 초기화 float64
# ones
one_array = np.ones((3,2))
print(one_array)
print(one_array.dtype, one_array.shape)

array1 = np.arange(10) # index는 0부터
print(array1)

array2 = array1.reshape(2,5)
print(array2)

array3 = array1.reshape(5,2)
print('array3:\n',array3)

# 10개로 만들 수 없는 사이즈
array1.reshape(4,3)

# -1을 사용하면 가능한 사이즈 자동 생성
array1 = np.arange(10)
print(array1)

array2 = array1.reshape(-1,5)
print('array2 shape:',array2.shape)

array3 = array1.reshape(5,-1)
print('array3 shape:',array3.shape)

# -1을 사용해도 불가능한 사이즈는 오류
array1 = np.arange(10)
array4 = array1.reshape(-1,4)

# 3차원 ndarray 생성
array1 = np.arange(8)
array3d = array1.reshape((2,2,2)) # 3개부터는 튜플 형태로!
print('array3d:\n',array3d.tolist())

# 대괄호가 3개!

# 3차원 ndarray를 2차원 ndarray로 변환
array5 = array3d.reshape(-1,1)
print('array5:\n',array5.tolist())
print('array5 shape:',array5.shape)

# 1차원 ndarray를 2차원 ndarray로 변환
array6 = array1.reshape(-1,1)
print('array6:\n',array6.tolist())
print('array6 shape:',array6.shape)

# 1에서 9까지의 1차원 narray 생성
array1 = np.arange(start=1, stop=10) # 10까지 넣어야 9까지 나옴
print('array1:', array1)

value = array1[2]
print(value)
print(type(value))
# index는 0 부터 시작하므로 array1[2]는 3번째 index 위치의 데이터 값을 의미

print('맨 뒤의 값:', array1[-1], '/ 맨 뒤에서 두 번째 값:',array1[-2])

# 값 바꾸기
array1[0] = 9
array1[8] = 0
print('array1:',array1)

# 2차원 인덱싱
array1d = np.arange(start=1, stop=10)
array2d = array1d.reshape(3,3)
print(array2d)

print('(row=0,col=0) index 가리키는 값:', array2d[0,0] )
print('(row=0,col=1) index 가리키는 값:', array2d[0,1] )
print('(row=1,col=0) index 가리키는 값:', array2d[1,0] )
print('(row=2,col=2) index 가리키는 값:', array2d[2,2] )

# 1, 5, 8 가져와보기
print(array2d[0,0], array2d[1,1], array2d[2,1])

array1 = np.arange(start=1, stop=10)
array3 = array1[0:3] # 0인덱스부터 3-1인덱스까지
print(array3)
print(type(array3))

# 1차원 슬라이싱
array1 = np.arange(start=1, stop=10)
array4 = array1[:3]
print(array4)

array5 = array1[3:]
print(array5)

# 값 복사(주소 복사 아님) : 전체를 다 가져온다는 의미보다 값 복사의 의미가 큼!
array6 = array1[:] 
print(array6)

# 2차원 슬라이싱
# 행 우선 / 콤마 뒤는 열
array1d = np.arange(start=1, stop=10)
array2d = array1d.reshape(3,3)
print('array2d:\n',array2d)
print('--------------------')

print('array2d[0:2, 0:2] \n', array2d[0:2, 0:2])
print('--------------------')
print('array2d[1:3, 0:3] \n', array2d[1:3, 0:3])
print('--------------------')
print('array2d[1:3, :] \n', array2d[1:3, :])
print('--------------------')
print('array2d[:, :] \n', array2d[:, :])
print('--------------------')
print('array2d[:2, 1:] \n', array2d[:2, 1:])
print('--------------------')
print('array2d[:2, 0] \n', array2d[:2, 0])

print(array2d[0])
print(array2d[1])
print('array2d[0] shape:', array2d[0].shape, 'array2d[1] shape:', array2d[1].shape)

array1d = np.arange(start=1, stop=10)
array2d = array1d.reshape(3,3)

# tolist : list 로 변환
print('array2d => ',array2d.tolist())

array3 = array2d[[0,1], 2]
print('array2d[[0,1], 2] => ',array3.tolist())

array4 = array2d[[0,1], 0:2]
print('array2d[[0,1], 0:2] => ',array4.tolist())

array5 = array2d[[0,1]]
print('array2d[[0,1]] => ',array5.tolist())

array1d = np.arange(start=4, stop=10)
print(array1d)

# [ ] 안에 array1d > 5 Boolean indexing을 적용 
array3 = array1d[array1d > 5]
print('array1d > 5 불린 인덱싱 결과 값 :', array3)

array1d > 5

boolean_indexes = np.array([False, False,  True,  True,  True,  True])
array3 = array1d[boolean_indexes]
print('불린 인덱스로 필터링 결과 :', array3)

indexes = np.array([2,3,4,5])
array4 = array1d[indexes]
print('일반 인덱스로 필터링 결과 :',array4)

# 정렬 전 원본 행렬
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( )로 정렬 : 행렬을 정렬 in place
sort_array2 = org_array.sort()
print('org_array.sort( ) 호출 후 반환된 행렬:', sort_array2)
print('org_array.sort( ) 호출 후 원본 행렬:', org_array)

# :: - 역순정렬
sort_array1_desc = np.sort(org_array)[::-1] 
print ('내림차순으로 정렬:', sort_array1_desc) 

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

# row 행 방향 -> axis = 0
sort_array2d_axis0 = np.sort(array2d, axis=0)
print('로우 방향으로 정렬:\n', sort_array2d_axis0)

# col 행 방향 -> axis = 1
sort_array2d_axis1 = np.sort(array2d, axis=1)
print('컬럼 방향으로 정렬:\n', sort_array2d_axis1)

# 오름차순
org_array = np.array([ 3, 1, 9, 5]) 
sort_indices = np.argsort(org_array)
print(type(sort_indices))
print('행렬 정렬 시 원본 행렬의 인덱스:', sort_indices)

# 내림차순
org_array = np.array([ 3, 1, 9, 5]) 
sort_indices_desc = np.argsort(org_array)[::-1]
print('행렬 내림차순 정렬 시 원본 행렬의 인덱스:', sort_indices_desc)

# 성적, 이름 데이터 정렬하기
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])

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('행렬 내적 결과:\n', dot_product)

# 1*7 + 2*9 + 3*11 = 58
# 4*7 + 5*9 + 6*11 = 139 

A = np.array([[1, 2],
              [3, 4],
              [5, 6]])

# 전치
transpose_mat = np.transpose(A)
print('A의 전치 행렬:\n', transpose_mat)

a = np.array(range(4)).reshape(2, 2)
a

a_inv = np.linalg.inv(a)
a_inv

# 내적
a.dot(a_inv)