[코드잇 & 머신러닝] 넘파이

 

 

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 [ ]: