코드잇
[코드잇 & 머신러닝] 넘파이
오월&절미
2021. 2. 2. 13:21
In [35]:
from IPython.core.display import display, HTML
display(HTML("<style>.container { width:1200px !important; }</style>"))
In [1]:
import numpy as np
ndarray = n차원 배열
numpy.full(6,0)
[0 0 0 0 0 0]
numpy.zeros(6)
[0 0 0 0 0 0]
numpy.ones(6)
[0 0 0 0 0 0]
numpy.random.random(6)
랜덤으로 6개의 값이 담긴 array생성
numpy.arange(6)
0~5 까지 값이 담긴 array생성
numpy.arange(2,7)
2~6 까지 값이 담긴 array생성
numpy.arange(2,7,2)
[2 4 6]
In [2]:
array1 = np.array([1,2,3,4])
print('array1 type : ' , type(array1) )
print('array1 array 형태 : ', array1.shape)
print('array1: {:0}차원'.format(array1.ndim))
array1 type : <class 'numpy.ndarray'>
array1 array 형태 : (4,)
array1: 1차원
In [4]:
array2 = np.array([[1,2,3,4], [5,6,7,8]])
print('array2 type : ' , type(array2) )
print('array2 array 형태 : ', array2.shape)
print('array2: {:0}차원'.format(array2.ndim))
array2 type : <class 'numpy.ndarray'>
array2 array 형태 : (2, 4)
array2: 2차원
In [5]:
array3 = np.array([[[1,2,3,4]]])
print('array3 type : ' , type(array3) )
print('array3 array 형태 : ', array3.shape)
print('array3: {:0}차원'.format(array3.ndim))
array3 type : <class 'numpy.ndarray'>
array3 array 형태 : (1, 1, 4)
array3: 3차원
In [10]:
arr1 = np.array([2, 3, 5, 7, 11, 13, 15, 17, 19, 23, 29, 31])
print(arr1[0])
print(arr1[-2])
print(arr1[[1, 3, 4]])
2
29
[ 3 7 11]
In [11]:
arr1_1 = [1, 3, 4]
arr1[arr1_1]
Out[11]:
array([ 3, 7, 11])In [12]:
arr1[2:7]
Out[12]:
array([ 5, 7, 11, 13, 15])In [13]:
arr1[:7]
Out[13]:
array([ 2, 3, 5, 7, 11, 13, 15])In [14]:
arr1[2:]
Out[14]:
array([ 5, 7, 11, 13, 15, 17, 19, 23, 29, 31])In [15]:
arr1[2:11:2] # 2,4,6,8,10번 인덱스값 추출
Out[15]:
array([ 5, 11, 15, 19, 29])In [22]:
arr1 = np.arange(10)
arr2 = np.arange(10,20)
print(f"1 : {arr1} , 2: {arr2}")
# arr1 각 원소에 2배를 하고 싶을 때
print("arr1*2 : ", arr1 *2)
print("원본 arr1 : ", arr1)
arr1 = arr1 *3
print(arr1)
arr1 = arr1 / 3
arr12 = arr1 + arr2
print(arr12)
1 : [0 1 2 3 4 5 6 7 8 9] , 2: [10 11 12 13 14 15 16 17 18 19]
arr1*2 : [ 0 2 4 6 8 10 12 14 16 18]
원본 arr1 : [0 1 2 3 4 5 6 7 8 9]
[ 0 3 6 9 12 15 18 21 24 27]
[10. 12. 14. 16. 18. 20. 22. 24. 26. 28.]
In [23]:
array1d = np.arange(start=1, stop=10)
# [ ] 안에 array1d > 5 인 불린인덱싱
array1d_5 = array1d[array1d>5]
print('array1d > 5 인 불린인덱싱 : ',array1d_5)
array1d > 5 인 불린인덱싱 : [6 7 8 9]
In [24]:
array1d_5 > 5
Out[24]:
array([ True, True, True, True])In [25]:
array1d_5 % 2 == 0
Out[25]:
array([ True, False, True, False])In [26]:
array1d > 6
Out[26]:
array([False, False, False, False, False, False, True, True, True])In [27]:
boolarray = [False, False, False, False, False, False, True, True, True]
np.where(boolarray) #True가 담긴 인덱스만 추출
Out[27]:
(array([6, 7, 8], dtype=int64),)In [28]:
##응용
arr1 = np.arange(10)
print(arr1)
print(arr1 > 4)
print(np.where(arr1>4))
[0 1 2 3 4 5 6 7 8 9]
[False False False False False True True True True True]
(array([5, 6, 7, 8, 9], dtype=int64),)
In [29]:
filter = np.where(arr1>4) # True인 인덱스 추출
filter
Out[29]:
(array([5, 6, 7, 8, 9], dtype=int64),)In [30]:
arr1[filter] # filter에 해당하는 값을 추출
Out[30]:
array([5, 6, 7, 8, 9])In [31]:
org_array = np.array([3, 1, 9, 5])
print('원본 행렬 np.array : ',org_array)
# np.sort 로 정렬
sort_nparray = np.sort(org_array)
print('np.sort 로 정렬 후 반환 : ',sort_nparray)
print('np.sort 로 정렬 후 원본행렬 : ',org_array)
# ndarray.sort 로 정렬
sort_ndarray = org_array.sort()
print('ndarray.sort 로 정렬 후 반환 : ',sort_ndarray)
print('ndarray.sort 로 정렬 후 원본행렬 : ',org_array)
# np.sort 로 정렬-defalut 값이 오름차순이기 때문에 내림차순으로 정렬하려면 [::-1]
sort_nparray_desc = np.sort(org_array)[::-1]
print('np.sort 로 정렬 후 내림차순으로 반환 : ',sort_nparray_desc)
print('np.sort 로 정렬 후 원본행렬 : ',org_array)
원본 행렬 np.array : [3 1 9 5]
np.sort 로 정렬 후 반환 : [1 3 5 9]
np.sort 로 정렬 후 원본행렬 : [3 1 9 5]
ndarray.sort 로 정렬 후 반환 : None
ndarray.sort 로 정렬 후 원본행렬 : [1 3 5 9]
np.sort 로 정렬 후 내림차순으로 반환 : [9 5 3 1]
np.sort 로 정렬 후 원본행렬 : [1 3 5 9]
In [32]:
array2d = np.array([[3, 18, 2],[10, 5, 19],[1, 15, 4]])
sort_array2d_np_axis0 = np.sort(array2d, axis=0)
print('2차원 np.sort axis=0 로우방향 :\n ',sort_array2d_np_axis0)
print('2차원 np.sort axis=0 로우방향 원본 :\n ',array2d)
sort_array2d_np_axis1 = np.sort(array2d, axis=1)
print('2차원 np.sort axis=1 컬럼방향 :\n', sort_array2d_np_axis1)
print('2차원 np.sort axis=1 컬럼방향 원본:\n', array2d)
2차원 np.sort axis=0 로우방향 :
[[ 1 5 2]
[ 3 15 4]
[10 18 19]]
2차원 np.sort axis=0 로우방향 원본 :
[[ 3 18 2]
[10 5 19]
[ 1 15 4]]
2차원 np.sort axis=1 컬럼방향 :
[[ 2 3 18]
[ 5 10 19]
[ 1 4 15]]
2차원 np.sort axis=1 컬럼방향 원본:
[[ 3 18 2]
[10 5 19]
[ 1 15 4]]
In [33]:
# np.argsort 는 인덱스를 반환한다
org_array_argsort = np.array([3, 8, 5, 10])
sort_indices = np.argsort(org_array_argsort)
array_argsort_sort = np.sort(org_array_argsort)
print(type(sort_indices))
print('원본 행렬 : ', org_array_argsort)
print('np.sort 정렬 : ', array_argsort_sort)
print('행렬 정렬 시 원본 행렬의 인덱스 : ', sort_indices)
<class 'numpy.ndarray'>
원본 행렬 : [ 3 8 5 10]
np.sort 정렬 : [ 3 5 8 10]
행렬 정렬 시 원본 행렬의 인덱스 : [0 2 1 3]
In [34]:
import numpy as np
name_array = np.array(['A' , 'B', 'C', 'D' ,'E'])
score_array = np.array(['88', '90', '66', '55', '77'])
sort_indices_asc = np.argsort(score_array)
print('성적 오름차순 정렬 score_array 인덱스 : ', sort_indices_asc)
print('성적 오름차순으로 정렬 했을 때 name_array : ', name_array[sort_indices_asc])
sort_indices_desc = np.argsort(score_array)[::-1]
print('성적 내림차순 정렬 score_array 인덱스 : ', sort_indices_desc)
print('성적 내림차순으로 정렬 했을 때 name_array : ', name_array[sort_indices_desc])
성적 오름차순 정렬 score_array 인덱스 : [3 2 4 0 1]
성적 오름차순으로 정렬 했을 때 name_array : ['D' 'C' 'E' 'A' 'B']
성적 내림차순 정렬 score_array 인덱스 : [1 0 4 2 3]
성적 내림차순으로 정렬 했을 때 name_array : ['B' 'A' 'E' 'C' 'D']
In [ ]: